Architecture Assertion

Verify codebase using Konsist API

Architecture assertions are used to perform architecture verification. It is the final step of Konsist verification preceded by scope creation (Create The Scope):

Assert Architecture

As an example, this simple 2-layer architecture will be used:

The assertArchitecture block defines architecture layer rules and verifies that the layer requirements are met.

Konsist
    .scopeFromProject()
    .assertArchitecture { 
        // Assert architecture 
    }

The Konsist repository contains multiple architectural tests. These tests are used internally to verify Konsist API. Each test has a Konsist code and a mermaid diagram presenting the architecture.

Define Layers

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.

Konsist
    .scopeFromProject()
    .assertArchitecture {
        // Define layers
        val presentation = Layer("Presentation", "com.myapp.presentation..")
        val data = Layer("Data", "com.myapp.data..")
    }

The inclusion of two trailing dots indicates that the layer is denoted by the com.myapp.business package together with all of its sub-packages.

val data = Layer("Data", "com.myapp.data..") // This package only and all sub-packages
val data = Layer("Data", "com.myapp.data") // This package only

Define Architecture Assertions

The final step is to define the relations between each layer:

koScope.assertArchitecture {
        val presentation = Layer("Presentation", "com.myapp.presentation..")
        val data = Layer("Data", "com.myapp.data..")

        presentation.dependsOn(data)
        data.dependsOnNothing()
    }

Architecture verification can be performed on KoScope (as seen above) and a list containing KoFiles. For example, you can remove a few files from the scope before performing an architectural check:

koScope
    .files
    .filter { it.name.startsWith("Repository") }
    .assertArchitecture {
        val presentation = Layer("Presentation", "com.myapp.presentation..")
        val data = Layer("Data", "com.myapp.data..")

        presentation.dependsOn(data)
        data.dependsOnNothing()
    }

This approach provides more flexibility when working with complex projects, however, The desired approach is to create a dedicated scope. See Create The Scope.

Architecture As A Variable

Architecture configuration can be defined beforehand and stored in a variable to facilitate checks for multiple scopes:

// Define architecture
val architecture = architecture {
        val presentation = Layer("Presentation", "com.myapp.presentation..")
        val data = Layer("Data", "com.myapp.data..")

        presentation.dependsOn(data)
        data.dependsOnNothing()
}

// Assert Architecture of two modules using common architecture rules
moduleFeature1Scope.assertArchitecture(architecture)
moduleFeature2Scope.assertArchitecture(architecture)

This approach may be helpful when refactoring existing applications. To facilitate readability the above checks should be expressed as two unit tests:

class ArchitectureTest {
    private val architecture = architecture {
        val presentation = Layer("Presentation", "com.myapp.presentation..")
        val data = Layer("Data", "com.myapp.data..")

        presentation.dependsOn(data)
        data.dependsOnNothing()
    }

    @Test
    fun `architecture layers of feature1 module have dependencies correct`() {
        moduleFeature1Scope.assertArchitecture(architecture)
    }
    
    @Test
    fun `architecture layers of feature2 module have dependencies correct`() {
        moduleFeature2Scope.assertArchitecture(architecture)
    }
}