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

Following the REST practices, the URL for fetching all cats should be `/cats`, while for fetching a single cat, it should be `/cats/123`, where `123` is the `ID` of the cat we are trying to fetch all the rows from the table for. Then, we map each row to our data class.

### Adding new routes to the `App.kt` file:

Let's add two new routes for that in the `App.kt`:





```
get("/cats") {
   ...
}
get("/cats/{id}") {
   ...
}
```
The first route is very similar to the `/status` route we introduced earlier in this chapter. But the second round is slightly different: it uses a query parameter in the URL. You can recognize query parameters by the curly brackets around their name.

To read a query parameter, we can access the parameters map:
```
val id = requireNotNull(call.parameters["id"]).toInt()
```
If there is an `ID` on the URL, we need to try and fetch a cat from the database:

```
val cat = transaction {
    CatsTable.select {
        CatsTable.id.eq(id)
    }.firstOrNull()
}
```
Here, we open a transaction and use the `select` statement to get a cat with an `ID` equal to what we were provided previously.

If an object was returned, we would convert it into JSON. Otherwise, we would return an HTTP code of `404 Not Found`:
```
if (row == null) {
    call.respond(HttpStatusCode.NotFound)
} else {
    call.respond(
        Cat(
            row[CatsTable.id].value,
            row[CatsTable.name],
            row[CatsTable.age]
        )
    )
}
```

## Adding tests to the `AppTest.kt` file
 
Let's add a test in the `AppTest.kt` file for fetching a single cat as well:

```
@Test
fun `GET with ID fetches a single cat`() {
    withTestApplication(Application::mainModule) {
         val id = transaction {
             CatsTable.insertAndGetId { cat -&gt;
                 cat[name] = "Fluffy"
             }
         }
         val response = handleRequest(HttpMethod.Get,
             "/cats/$id").response
         assertEquals("""{"id":1,"name":
              "Fluffy","age":0}""", response.content)
    }
}
```
In this test, we create a cat using `exposed`. Here, we're using a new method called `insertAndGetId()`. As its name suggests, it will return the `ID` of a newly created row. Then, we try to fetch that cat using our newly created endpoint.

If we try to run this test, though, it will fail with the following exception:
```
&gt; Serializer for class 'Cat' is not found.
```

By default, Ktor doesn't know how to turn our custom data class into JSON. To fix that, we'll need to add a new plugin to our `build.gradle.kts` file:

```
plugins {
    kotlin("jvm") version "1.5.10"
    application
    kotlin("plugin.serialization") version "1.5.10"
}
```
This plugin will create serializers at compile time for any class marked with the `@Serializable` annotation. All we need to do now for the test to pass is add that annotation to our `Cat` class:
```
@Serializable
data class Cat(
    val id: Int,
    val name: String,
    val age: Int
)

```

That's it; now, our test for fetching a cat by its ID should pass.



Finally, we would like to be able to fetch all the cats from the database. To do that, we must change our test setup a little:
```
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class ServerTest {
     @BeforeAll
     fun setup() {
         DB.connect()
         transaction {
              SchemaUtils.create(CatsTable)
         }
     }
     @AfterAll
     fun cleanup() {
         DB.connect()
         transaction {
              SchemaUtils.drop(CatsTable)
         }
     }
     ...
}
```

Here, we changed the setup of our test to drop the table once all the tests have been executed. So, instead of the `@BeforeEach` annotation, which executes the function before each test, we use the `@AfterAll` annotation, which executes the function after all tests have been executed.

For this annotation to work, we also need to add the `@TestInstance` annotation to our class. The default for that is `PER_METHOD`, but since we want to execute multiple tests at once, and then clean up after, we need to set the life cycle of our test class to `PER_CLASS`.

Next, let's wrap our test into a nested class, like this:

```
@Nested
inner class `With cat in DB` {
   
    @Test
    fun `GET with ID fetches a single cat`() {
       ...
    }
}
```

Nested test classes are a great way to encapsulate specific test situations. In our case, we would like to run two tests when there is a cat in our database already.

Now, let's add the following setup code to our nested test:
```
lateinit var id: EntityID<int>
@BeforeEach
fun setup() {
    DB.connect()
    id = transaction {
        CatsTable.insertAndGetId { cat -&gt;
            cat[name] = "Fluffy"
        }
    }
}
@AfterEach
fun teardown() {
   DB.connect()
   transaction {
       CatsTable.deleteAll()
   }
}
```
Before we execute each test in this nested class, we will create a cat in the database and after each test, we will delete all the cats from our database. Since we would like to keep track of the `ID` of the cat that we create, we will store it in a variable.

Now, our test class for fetching a single entity looks like this:
```
@Test
fun `GET with ID fetches a single cat`() {
    withTestApplication(Application::mainModule) {
         val response = handleRequest(HttpMethod.Get,
             "/cats/$id").response
         assertEquals("""{"id":$id,"name":"Fluffy",
             "age":0}""", response.content)
    }
}
```
Notice that we interpolate the cat's `ID` into our expected response because it will change with each test execution.

The test for fetching all the cats from the database will look almost the same:
```
@Test
fun `GET without ID fetches all cats`() {
    withTestApplication(Application::mainModule) {
       val response = handleRequest(HttpMethod.Get,  
           "/cats").response
       assertEquals("""[{"id":$id,"name":"Fluffy", 
           "age":0}]""", response.content)
    }
}
```
We just don't specify the `ID`, and the response is wrapped into a JSON array, as we can see by the square brackets around it.

Now, all we need to do is implement this new route:
```
get("/cats") {
    val cats = transaction {
        CatsTable.selectAll().map { row -&gt;
            Cat(
                row[CatsTable.id].value,
                row[CatsTable.name],
                row[CatsTable.age]
            )
        }
    }
    call.respond(cats)
}
```

&gt;**Note:** If you followed the example for fetching a single entity from the database (from the beginning of this section), then this example won't be very different for you. We use the `selectAll()` function to fetch all the rows from the table. Then, we map each row to our data class. 
 
</int>

Learn how to fetch data from the database using the exposed library.

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

Fetching new Entities

Adding new routes to the `App.kt` file:

Fetching new Entities

Adding new routes to the App.kt file:

Adding new routes to the `App.kt` file: