Gain insights into Kotlin language essentials and delve into design patterns and best practices. Discover functional programming techniques to enhance code reuse, robustness, and build reliable, scalable projects.

Packt MBE - Kotlin Design Patterns and Best Practices.png

Kotlin_optimized.tar.gz

Kotlin

Kotlin_Co

Kotlin_SPA

Cats_Hostel

Cats_Shelter(1..5)

Cats_Shelter(6-7-8)

Design patterns enable developers to speed up the development process by providing proven development paradigms. Reusing design patterns helps prevent complex issues that can cause major problems. Moreover, it improves your codebase, promotes code reuse, and makes an architecture more robust.

In this course, you will start with a gentle introduction of the Kotlin language. You will explore design patterns that are part of the best practices that help developers use Kotlin efficiently. Design patterns appeared in the era of object-oriented languages such as C++ and Java. You will learn the language features that Kotlin provides, which allow developers to program in a functional style and implement the design patterns.

After taking this course, you’ll be able to take your knowledge of Kotlin, design patterns, and associated best practices to the software industry and apply it to build reliable, scalable, and maintainable projects.

Kotlin Design Patterns and Best Practices

## Adding a cat to our virtual shelter
Now our task is to add the first cat to our virtual shelter.

Following the REST principles, it should be a `POST` request, where the body of the request looks something like this:
```
{"name": "Meatloaf", "age": 4}
```
We'll start by writing a new test in our `AppTest.kt` file: 
```
@Test
fun `POST creates a new cat`() {
    ...
}
```
Backticks are a useful Kotlin feature that allow us to have spaces in the names of our functions. This helps us create descriptive test names.
Next, let's look at the body of our test,  in the `AppTest.kt` file:
```
withTestApplication(Application::mainModule) {
     val response = handleRequest(HttpMethod.Post, "/cats") {
         addHeader(
            HttpHeaders.ContentType,
            ContentType.Application.FormUrlEncoded.toString()
         )
         setBody(
            listOf(
                "name" to "Meatloaf",
                "age" to 4.toString()
            ).formUrlEncode()
         )
     }.response
     assertEquals(HttpStatusCode.Created, response.status())
}
```



We discussed the `withTestApplication()` and `handleRequest()` functions in the previous section. This time, we are using a `POST` request. These types of requests should have the correct header, so we must set those headers using the `addHeader()` function. We must also set the body to the contents discussed previously.

Finally, we must check whether the response header is set to the `Created` HTTP code.

If we run this test now, it will fail with an HTTP code of `404` because we haven't implemented the `post` `/cats` endpoint yet.

## Implementing the POST endpoint

Let's go back to our `routing` block and add a new endpoint in `App.kt` file :
```
post("/cats") {
    ...
    call.respond(HttpStatusCode.Created)
}
```
To create a new cat, we'll need to read the body of the `POST` request. We'll use the `receiveParameters()` function for this:

```
val parameters = call.receiveParameters()
val name = requireNotNull(parameters["name"])
val age = parameters["age"]?.toInt() ?: 0
```

The `receiveParameters()` function returns a case-insensitive map. First, we will attempt to fetch the cat's name from this map, and if there's no name in the request, we will fail the call. This will be handled by Ktor.

Then, if we didn't receive `age`, we will default it to `0` using the Elvis operator. 

Now, we must insert those values into the database:
```
transaction {
    CatsTable.insert { cat ->
        cat[CatsTable.name] = name
        cat[CatsTable.age] = age
   }
}
```

In the code above, we open a `transaction` block to make changes to the database. Then, we use the `insert()` method, which is available on every table. Inside the `insert` lambda, the cat variable refers to the new row we are going to populate. We set the name of that row to the value of the `name` parameter and do the same for `age`.

If we run our test now, it should pass. But if we run it again, it will fail. That's because the name of a cat in the database is unique. Also, we don't clean the database between test runs. So, the first run creates a cat named `Meatloaf`, while the second run fails. This is because such a cat already exists.

## Making the tests consistent


Let's go back to our test and add the following piece of code in our `AppTest.kt` file:

```
@AfterAll
fun cleanup() {
    DB.connect()
    transaction {
       SchemaUtils.drop(CatsTable)
    }
}
```
Here, we are using the `@BeforeEach` annotation on a function. As its name suggests, this code will run before each test. The function will establish a connection to the database and drop the table completely. Then, our application will recreate the table.


Learrn how we can use the database connection to add a few entities in our Ktor application.

Getting Started with Kotlin

Working with Creational Patterns

Understanding Structural Patterns

Getting Familiar with Behavioral Patterns

Introducing Functional Programming

Threads and Coroutines

Controlling the Data Flow

Designing for Concurrency

Idioms and Anti-Patterns

Concurrent Microservices with Ktor

Reactive Microservices with Vert.x

Conclusion

Creating new Entities

Adding a cat to our virtual shelter