The following example provides the minimum setup for defining and running a single Konsist test.
At a high-level Konsist check is a Unit test following multiple implicit steps.
3 steps are required for a declaration check and 4 steps are required for an architecture check:
Konsist Declaration Checks provide a powerful mechanism for validating the structural elements of the Kotlin codebase. These checks allow developers to enforce structural rules and coding conventions by verifying classes, interfaces, functions, properties, and other code declarations. Here few things that can be verified with Konsist:
All Use cases should reside in usecase specific package
Repository classes must implement Repository interface
All repository classes should have name ending with Repository
data classes should have only val properties
Test classes should have test subject named sut
...
Let's write a simple test to verify that all classes (all class declarations) residing in resides in controller package are annotated with the RestController annotation .
On a high level writing Konsist declaration check requires 4 steps:
Let's take a closer look at each of these steps.
The first step is to get a list of Kotlin files to be verified.
The Konsist object is an entry point to the Konsist library.
The scopeFromX methods obtains the instance of the scope containing Kotlin project files. To get all Kotlin project files present in the project use the scopeFromProject method:
Each file in the scope contains set of declarations like classes, properties functions etc. (see ). To write this declaration check for all classes present in the scope query classes using classes method :
In this project controllers are defined as classes annotated with RestController annotation. Use withAllAnnotationsOf method to filter classes with with RestController annotation:
To performa assertion use the assertTrue method:
To verify that classes are located in the controller package, use the resideInPackage method inside assertTrue block:
This verification applies to the entire collection of previously filtered classes, rather than examining just one class in isolation.
The declaration validation logic should be protected through automated testing. By wrapping Konsist checks within standard testing frameworks such as or , you can verify these rules with each :
Note that test class has a KonsistTest suffix. This is the recommended approach to name classes containing Konsist tests.
This section described the basic way of writing Konsist declaration test. To get a better understanding of how Konsist API works see and sections.
The above test will execute multiple assertions per test (all controllers will be verified in a single test). If you prefer better isolation each assertion can be executed as a separate test. See the page.
The Kotest testing framework project dependency should be added to the project. See starter projects to get a complete sample project.
Konsist // Define the scope containing all Kotlin files present in the project
Konsist.scopeFromProject() //Returns KoScopeKonsist.scopeFromProject()
// Get scope classes
.classes()
Konsist.scopeFromProject()
.classes()
// Filter classes annotated with 'RestController'
.withAllAnnotationsOf(RestController::class) Konsist.scopeFromProject()
.classes()
.withAllAnnotationsOf(RestController::class)
.assertTrue {
// Define the assertion
} Konsist.scopeFromProject()
.classes()
.withAllAnnotationsOf(RestController::class)
.assertTrue {
// Check if classes are located in the controller package
it.resideInPackage("..controller")
} class ControllerClassKonsistTest {
@Test
fun `classes annotated with 'RestController' annotation reside in 'controller' package`() {
// 1. Create a scope representing the whole project (all Kotlin files in project)
Konsist.scopeFromProject()
// 2. Retrieve class declarations
.classes()
// 3. Filter classes annotated with 'RestController'
.withAllAnnotationsOf(RestController::class)
// 4. Define the assertion
.assertTrue { it.resideInPackage("..controller..") }
}
}class ControllerClassKonsistTest : FreeSpec({
"classes annotated with 'RestController' annotation reside in 'controller' package" {
Konsist
// 1. Create a scope representing the whole project (all Kotlin files in project)
.scopeFromProject()
// 2. Retrieve class declarations
.classes() // 2. Get scope classes
// 3. Filter classes annotated with 'RestController'
.withAllAnnotationsOf(RestController::class)
// 4. Define the assertion
.assertTrue (testName = this.testCase.name.testName) {
it.resideInPackage("..controller..")
}
}
})Add the following dependency to the module\build.gradle.kts file:
dependencies {
testImplementation("com.lemonappdev:konsist:0.17.3")
}Add the following dependency to the module\build.gradle file:
dependencies {
testImplementation "com.lemonappdev:konsist:0.17.3"
}Add the following dependency to the module\pom.xml file:
<dependency>
<groupId>com.lemonappdev</groupId>
<artifactId>konsist</artifactId>
<version>0.17.3</version>
<scope>test</scope>
</dependency>repositories {
mavenCentral()
}Konsist's Architectural Checks serve as a robust tool for maintaining layer isolation, enabling development teams to enforce strict boundaries between different architectural layers. Here few things that can be verified with Konsist:
domain layer is independant
data layer depends on domain layer
...
Let's write a simple test to verify that application architecture rules are preserved. In this scenario, the application follows a simple 3-layer architecture, where Presentation and Data layers depend on Domain layer and Domain layer is independant (from these layers):
On a high level writing Konsist architectural check requires 3 steps:
Let's take a closer look at each of these steps.
Create layers instances to represent project layers. Each Layer instance accepts the name (used for presenting architecture violation errors) and package used to define layers.
The Konsist object is an entry point to the Konsist library.
The scopeFromX methods obtains the instance of the scope containing Kotlin project files. To get all Kotlin project files present in the project use the scopeFromProject method:
To performa assertion use the assertArchiteture method:
Utilize dependsX methods to validate that your project's layers adhere to the defined architectural dependencies:
Wrap Konsist Code In Test
The declaration validation logic should be protected through automated testing. By wrapping Konsist checks within standard testing frameworks such as or , you can verify these rules with each :
Note that test class has a KonsistTest suffix. This is the recommended approach to name classes containing Konsist tests.
This section described the basic way of writing Konsist architectural test. To get a better understanding of how Konsist API works see .
The Kotest testing framework project dependency should be added to the project. See starter projects to get a complete sample project.
// Define layers
private val presentationLayer = Layer("Presentation", "com.myapp.presentation..")
private val domainLayer = Layer("Domain", "com.myapp.domain..")
private val dataLayer = Layer("Data", "com.myapp.data..")Konsist// Define layers
private val presentationLayer = Layer("Presentation", "com.myapp.presentation..")
private val domainLayer = Layer("Domain", "com.myapp.domain..")
private val dataLayer = Layer("Data", "com.myapp.data..")
// Define the scope containing all Kotlin files present in the project
Konsist.scopeFromProject() //Returns KoScope// Define layers
private val presentationLayer = Layer("Presentation", "com.myapp.presentation..")
private val domainLayer = Layer("Domain", "com.myapp.domain..")
private val dataLayer = Layer("Data", "com.myapp.data..")
Konsist
.scopeFromProject()
// Assert architecture
.assertArchitecture {
// Define architectural rules
}Konsist
.scopeFromProject()
.assertArchitecture {
private val presentationLayer = Layer("Presentation", "com.myapp.presentation..")
private val domainLayer = Layer("Domain", "com.myapp.business..")
private val dataLayer = Layer("Data", "com.myapp.data..")
// Define layer dependnecies
presentationLayer.dependsOn(domainLayer)
dataLayer.dependsOn(domainLayer)
domainLayer.dependsOnNothing()
}class ArchitectureKonsistTest {
@Test
fun `architecture layers have dependencies correct`() {
Konsist
.scopeFromProject()
.assertArchitecture {
private val presentationLayer = Layer("Presentation", "com.myapp.presentation..")
private val domainLayer = Layer("Domain", "com.myapp.business..")
private val dataLayer = Layer("Data", "com.myapp.data..")
// Define layer dependnecies
presentationLayer.dependsOn(domainLayer)
dataLayer.dependsOn(domainLayer)
domainLayer.dependsOnNothing()
}
}
}class ArchitectureKonsistTest {
class UseCaseTest : FreeSpec({
"architecture layers have dependencies correct" {
Konsist
.scopeFromProject()
.assertArchitecture {
private val presentationLayer = Layer("Presentation", "com.myapp.presentation..")
private val domainLayer = Layer("Domain", "com.myapp.business..")
private val dataLayer = Layer("Data", "com.myapp.data..")
// Define layer dependnecies
presentationLayer.dependsOn(domainLayer)
dataLayer.dependsOn(domainLayer)
domainLayer.dependsOnNothing()
}
}
})
}