DEV Community: Lahiru Jayawickrama

Konsist: Protect Kotlin Multiplatform projects from architecture guidelines violations.

Lahiru Jayawickrama — Sun, 08 Oct 2023 12:50:02 +0000

Step-by-step instructions on integrating Konsist with Kotlin Multiplatform Mobile.

Let’s say you have created a project architecture and you expect your team members to follow the architecture guidelines. But there might be a developer who does not follow the guidelines strictly always. Depending on the scope of the project, developers may get reassigned, or teams may be divided into multiple small teams where they must focus on specific modules. So most of the team members will not have a holistic view of the project and with time, things can get messy.

And here comes the Linter tool to save your day. Even though it won’t solve your personal debt and problems, it certainly prevents you from accumulating technical debt and also provides visibility into your code health.

So to have consistency through the project structure and to test whether the project architecture guideline hasn’t been violated we can use an architectural linter called Konsist. Konsist is a Kotlin static code analyzer that supports Kotlin-based projects including Android, Kotlin Multiplatform, and Spring. Although this library is in its early stages of development, it covers the problems and usecases we see every day today.

Konsist offers two types of checks: Declaration Checks, which test for declaration-level violations, and Architectural Checks, which test for architectural guidelines and boundaries.

Without further delay, let’s dive right in.

Prerequisites

#Kotlin Multiplatform Mobile Project

#Konsist

For this example, I’m using a Multi-Module Kotlin Multiplatform Mobile project with the following structure. Alternatively, you can use Kotlin Multiplatform Mobile’s default structure.

Multi-Module KMM

Configuration

As a first step, we’ll create a new module for the Konsist Test that separates the konsist test from the unit test to improve readability.

Right click on the shared module.
Select New then Module to open the Create New Module window.
Select the Kotlin Multiplatform Shared Module Template
Enter your desired module name. Ex: :shared:konsisttest.
Name your package. The rest is the same as the following image, so click Finish.

You will then be able to see your new module on the project as follows.

Dependency

Add mavenCentral repository

repositories {
    //...
    mavenCentral()
    //...    
}

Next, we will configure the Gradle file for :shared:konsisttest.

Remove the Android Gradle plugin from the :shared:konsisttest module’s Gradle, along with its corresponding ‘android()’ Kotlin Target
Add the ‘jvm()’ Kotlin Target and ‘jvmTest’ source set.
Add the Konsist dependency to ‘jvmTest’ in the :shared:konsisttest module’s Gradle.

val jvmTest by getting {
    dependencies {
        implementation("com.lemonappdev:konsist:{VERSION}")
    }
 }

Following these steps, create a file in your ‘jvmTest’ source set that will be used to write test methods.

Select New then Directory from the right-click menu on the module (:shared:konsisttest)
Create the source set directory (src/jvmTest/kotlin)
Create your package (Ex: com.stargatex.mt.lahiru.konsisttest)
Create a file (Ex: AppKonsistTest)

Directory creation

jvmTest source set directory

Package creation

Test file creation

Implementation

First let’s take a look at the steps for ‘declaration check’.

As a first step, we need to determine the scope, which includes files from an entire project, a module, a package, or just one Kotlin file. (Create the scope)

// Scope for Kotlin files availble in the project
Konsist.scopeFromProject() 
// Scope for Kotlin files availble in the 'app' module
Konsist.scopeFromModule("app")
// Scope for Kotlin files availble in the 'test' source set
Konsist.scopeFromSourceSet("test")
// Scope for Kotlin files availble for production code
Konsist.scopeFromProduction()

We then query all items in the scope and filter them according to our needs. (Query and Filter)
Finally, we define the assertion. (Assert)

Now let’s examine the steps for ‘architecture check’.

As a first step, we need to determine the scope.
Next, we define layers of the project and assertions using the ‘assertArchiteture’ method

Konsist
    .scopeFromProduction() // Define the scope
    .assertArchitecture { // Assert architecture
        // Define layers
        val domain = Layer("Domain", "com.stargatex.mt.kmm.lahiru.shared.domain..")

        // Define the relations between each layer for architecture assertions
        domain.dependsOnNothing()
    }

Lastly, both ‘declaration check’ and ‘architecture check’ of Konsist test code will be executed as unit tests.

Use cases

Here are some examples of use cases you might need to test in a project.

For more examples, They have provided good examples that you can use as inspiration on how this can be used (Snippets / Articles).

All right, that’s it. Using this library correctly could mean you don’t accumulate technical debt resulting from architectural violations and those violations might be found in reviews rather than going unnoticed. I have begun integrating this library into my current organization’s Kotlin Android and Kotlin Multiplatform Mobile projects. It was a pleasant experience thanks to good documentation, seamless integration abilities, and extensibility for custom needs.

I hope you found this useful. Until next time 🙏 👋

Token refresh implementation with Ktor in Kotlin Multiplatform Mobile

Lahiru Jayawickrama — Sun, 13 Aug 2023 10:58:31 +0000

Hey everyone, This is a short step-by-step guide for integrating a token refresh implementation with Ktor in Kotlin Multiplatform Mobile. Ktor offers an easy and straightforward approach to implementing a token refresh feature and managing the lifecycle of tokens. Without any further delay, let’s dive right in.

In this example, I will also be using Koin DI framework to get HttpClientEngine (platform-specific engine for processing network requests) and a secure store for storing and retrieving tokens (called UserManager).

Prerequisites

Kotlin Multiplatform Mobile with Koin

ktor

Napier

Add dependencies

Implementation

First we will assume that we have configured Koin DI for our KMM project. Then we will configure the platform specific Ktor HttpClientEngine with OkHttp for Android and Darwin for IOS.

In commonMain define your expected declaration for HttpClientEngine.

In AndroidMain , define your platform-specific actual declaration for the HttpClientEngine.

In IosMain, define your platform-specific actual declaration for the HttpClientEngine.

Then add your declaration to the startKoin function.

Token Refresh

Our next step will be to configure the token refresh feature using the refreshTokens ktor API.

Full HttpClient configuration,

Accordingly, what this code does is. A request will be made with a token to the protected API. API will respond with a 401 unauthorized response if the token is expired, and this will trigger the refreshTokens block to retrieve new tokens. Once the token has been retrieved, it will request the same protected API that previously responded with a 401 unauthorized response.

Code Snippets — https://gist.github.com/stargatex/7678d15a6e7bef0b3cf1262f38a7a31d

I hope you found this useful. Until next time 🙏 👋

Configure SonarQube in a Android Project using Docker

Lahiru Jayawickrama — Thu, 25 Aug 2022 18:19:12 +0000

Hey everyone,

This is a step-by-step guide for integrating SonarQube for Android project using docker. Without any further delay, let’s dive right in.

What is SonarQube?

According to the official documentation,

“SonarQube is an automatic code review tool to detect bugs, vulnerabilities, and code smells in your code.”

What is Docker?

Docker simplifies the process of developing applications. It provides a set of tools that allow developers to create, test and deploy applications in loosely isolated environments.

Prerequisites

Docker (https://cutt.ly/WG4feRX)

Android Development Environment

Starting SonarQube

Start the Docker engine and log in to your account. Next, Install the SonarQube image and run it with the below command in the terminal.

With this, it will print the container ID once SonarQube is up and running successfully. To access it: “http://localhost:9000/”. The default user and password is “admin”

Configure a SonarQube Project.

Once you logged in to your SonarQube instance. Select the project creation option as “Manually” to run the scan from your local codebase.

To set up the project provide a Display Name and Project Key.

Next, provide “Locally” as the way you want to analyse your repository.

To authenticate the user to perform the analysis, generate the token by providing a name

Performing an analysis

Add the sonar scanner plugin in your Project level Gradle.

Next, in your App level Gradle configure as below

Replace the PROJECT-NAME, PROJECT-KEY, and TOKEN with the generated and provided values in the previous steps. Inclusion and exclusion depend on your requirement.

Sync your Gradle and run the following command on your terminal.

After the build is successful access your project at “http://localhost:9000/projects” to view your project report

That’s it. Now you can review your project and improve your code quality. But this is a basic SonarQube Android setup. There are a lot of things you can do with SonarQube. Learn it, research it & share it. I hope you found this useful. Until next time 🙏 👋