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 dependencies
To test our Vert.x application, we'll use the JUnit 5 framework.
We'll need the following two dependencies in our `build.gradle.kts` file:
```
dependencies {
...
testImplementation("org.junit.jupiter:junit-jupiter-
api:5.6.0")
testRuntimeOnly("org.junit.jupiter:junit-jupiter-
engine:5.6.0")
}
```
## Writing tests in the `AppTest.kt` file:
Our first test will be located in the `/src/test/kotlin/catsshelter/AppTest.kt` file. 

The basic structure of all the integration tests looks something like this:
```
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class ServerTest {
    private val vertx: Vertx = Vertx.vertx()
    
    @BeforeAll
    fun setup() {
        runBlocking {
            vertx.deployVerticle(ServerVerticle()).await()
        }
    }
    @AfterAll
    fun tearDown() {
        // And you want to stop your server once
        vertx.close()
    }

    @Test
    fun `status should return 200`() {
    
   }
}
```
This structure is different from Ktor. Here, we start the server ourselves, in the `setup()` method.

Since Vert.x is Reactive, the `deployVerticle()` method will return a `Future` object immediately, releasing the thread, but that doesn't mean that the server verticle has started yet.

To avoid this race, we can use the `await()` method, which will block the execution of our tests until the server is ready to receive requests.

Now, we want to issue an actual HTTP call to our `/status` endpoint, for example, and check the response code. For that, we'll use the Vert.x web client.

Let's add it to our `build.gradle.kts` dependencies section:

```
testImplementation("io.vertx:vertx-web-client:$vertxVersion")
```

Since we only plan to use `WebClient` in tests, we specify `testImplementation` instead of `implementation`. But `WebClient` is so useful that you'll probably end up using it in your production code anyway.

After adding this new dependency, we need to instantiate our web client in the `setup()` method:

```
lateinit var client: WebClient
@BeforeAll
fun setup() {
    vertx.deployVerticle(ServerVerticle())
    client = WebClient.create(
         vertx,
         WebClientOptions()
            .setDefaultPort(8081)
            .setDefaultHost("localhost")
    )
}
```

The `setup()` method will be called once before all the tests start. In this method, we are deploying our server verticle and creating a web client with some defaults for all our tests to share.

Now, let's write a test to check that our server is up and running:
```
@Test
fun `status should return 200`() {
    runBlocking {
        val response = client.get("/status").send().await()
        assertEquals(201, response.statusCode())
    }
}
```

Now, let's understand what happens in this test:

* `client` is an instance of `WebClient` that is shared by all our tests. We invoke the `/status` endpoint using the `get` verb. This is a Builder design pattern, so to issue our request, we need to use the `send()` method. Otherwise, nothing will happen.
* Vert.x is a Reactive framework, so instead of blocking our thread until a response is received, the `send()` method returns a Future. Then, we use `await()`, which adapts a Future to a Kotlin coroutine to be able to wait for the results concurrently.
* Once the response is received, we check it in the same way that we did in other tests---by using the `assertEquals` function, which comes from JUnit.



Learn how to test the routes in a Vert.x 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

Testing Vert.x Applications

Adding dependencies