Harmonizing Kotlin codebase with Konsist Igor Wojda @igorwojda Natalia Peterwas

COMPLEX PROJECTS Poor Codebase Quality No Coding Standards  Codebase Growth  Team Changes  New features + Bug Fixes  Time Pressure  Personal Preferences  Poor PR Reviews  No Big Picture  No Automated Testing  No Documentation  Tech Debt 

L I N T E R S 

Codebase quality  Code Readability  Adherence to coding standards  Improve productivity  Prevent bugs  LINTERS

KOTLIN LINTERS • Code Maintainability • Complexity Reduction • Code Safety Popular linters in Kotlin Ecosystem Lint • Code Readability • Style Consistency • Structural Clarity • Compatibility Awareness • Performance Efficiency • API Adherence

MEET JANE Passionate Developer

FIRST TASK Let’s Code

DISCOVERY Explore the Code Base

EXISTING USE CASES  USE CASES Use Case 1 public class MarkSongAsFavorite { fun execute() { // business logic } } class CreatePlaylistUC { fun run() { // business logic } fun calculateCalories() { // business logic } } Use Case 3 Use Case 2 private class ShareSongUseCase { operator fun invoke() { // business logic } } Use Case 4 class SubscribeToArtisUseCase { fun invoke() { // business logic } }

USE CASE SUFFIXES Use Case 1 public class MarkSongAsFavorite { fun execute() { // business logic } } No Suffix Use Case 2 private class ShareSongUseCase { operator fun invoke() { // business logic } } Use Case 4 class SubscribeToArtisUseCase { fun invoke() { // business logic } } “UseCase” Suffix class CreatePlaylistUC { fun run() { // business logic } fun calculateCalories() { // business logic } } Use Case 3 “UC” Suffix

USE CASE METHOD NAMES Use Case 1 public class MarkSongAsFavorite { fun execute() { // business logic } } “execute” Method Use Case 2 private class ShareSongUseCase { operator fun invoke() { // business logic } } Use Case 4 class SubscribeToArtisUseCase { fun invoke() { // business logic } } “invoke” Method class CreatePlaylistUC { fun run() { // business logic } fun calculateCalories() { // business logic } } Use Case 3 “run” Method

USE CASE NUM PUBLIC METHODS Use Case 1 public class MarkSongAsFavorite { fun execute() { // business logic } } Use Case 2 private class ShareSongUseCase { operator fun invoke() { // business logic } } Use Case 4 class SubscribeToArtisUseCase { fun invoke() { // business logic } } 1 public Method class CreatePlaylistUC { fun run() { // business logic } fun calculateCalories() { // business logic } } Use Case 3 2 public Methods

USE CASE CLASS VISIBILITY MODIFIERS Use Case 1 public class MarkSongAsFavorite { fun execute() { // business logic } } Explicit “public” Use Case 2 private class ShareSongUseCase { operator fun invoke() { // business logic } } Explicit “private” Use Case 4 class SubscribeToArtisUseCase { fun invoke() { // business logic } } class CreatePlaylistUC { fun run() { // business logic } fun calculateCalories() { // business logic } } Use Case 3 Implicit “public”

USE CASE OPERATOR MODIFIER Use Case 1 public class MarkSongAsFavorite { fun execute() { // business logic } } Use Case 2 private class ShareSongUseCase { operator fun invoke() { // business logic } } Use Case 4 class SubscribeToArtisUseCase { fun invoke() { // business logic } } 1 Operator Modifier class CreatePlaylistUC { fun run() { // business logic } fun calculateCalories() { // business logic } } Use Case 3 3 No Operator Modifier

USECASE DECLARATIONS Suffix Method Name Operator Num Public Methods Class Visibility MarkSongAsFavorite None execute No 1 Public (explicit) ShareSong UseCase invoke Yes 1 Private CreatePlaylist UC run No 2 Public (implicit) SubscribeToArtist UseCase invoke No 1 Public (implicit)

M E E T K O N S I S T

Create The Scope STRUCTURE OF KONSIST TEST Filter The Declarations Define Assertion 1 2 3

1. CREATE THE SCOPE

SCOPE Konsist.scopeFromProject() Scope contains all *.kt files present in project.

SCOPE Konsist.scopeFromModule("app") Each scope contains all *.kt files present in module. Konsist.scopeFromModule("ui")

SCOPE Scope contains all *.kt files from “integrationTest” source set. Konsist.scopeFromSourceSet("integrationTest")

SCOPE Konsist.scopeFromProduction()

val customScope = appScope + uiScope SCOPE COMPOSITION val appScope = Konsist.scopeFromModule(“app") val uiScope = Konsist.scopeFromModule(“ui")

2. FILTER DECLARATIONS

Konsist .scopeFromProduction() FILTER DECLARATIONS

Konsist .scopeFromProduction() .classes() FILTER DECLARATIONS List

Konsist .scopeFromProduction() .classes() FILTER DECLARATIONS .filter { it.name.endsWith(“Repository") } .withNameEndingWith("Repository")

Konsist .scopeFromProduction() .classes() .withAllAnnotationsOf( CachingService::class, ValidationService::class ) .withInternalModifier() .withSecondaryConstructors() .withParentClassOf(Service::class) @CachingService @ValidationService internal class PhotoService : Service { // code constructor(cache: LocalCache) { // code } } FILTER DECLARATIONS .without... .with... { it. } Konsist Test Codebase

Konsist .scopeFromProduction() .functions() .withPackage("com.app.data") .withExpressionBody() .withParameters { parameters -> parameters.any { it.representsTypeOf() } } .withReturnType { it.isKotlinType } FILTER DECLARATIONS Konsist Test

3. DEFINE ASSERTION

ASSERTIONS @Repository public open class Car constructor() { val speed = 0 open suspend fun startEngine(fuelType: FuelType) { // .. } } Methods .name .properties .functions .constructors .hasNameContaining .hasBlockBody .isTopLevel .hasOpenModifier Properties

Konsist .scopeFromProduction() .classes() .withNameEndingWith("Repository") .assertTrue { it.resideInPackage("..repository..") } ASSERT Check multiple classes Last expression determines test outcome

@Test fun `test name`() { Konsist .scopeFromProduction() .classes() .withAllAnnotationsOf(Repository::class) .assertTrue { it.resideInPackage("..repository..") } } “com.lemonappdev:konsist:0.15.1” “Test framework dependency” Add to test source set RUNNING KONSIST TEST Konsist .scopeFromProduction() .classes() .withAllAnnotationsOf(Repository::class) .assertTrue { it.resideInPackage("..repository..") } class SampleKonsistTest : FreeSpec({ “test name" { Konsist .scopeFromProduction() .classes() .withAllAnnotationsOf(Repository::class) .assertTrue { it.resideInPackage("..repository..") } } }) Konsist .scopeFromProduction() .classes() .withAllAnnotationsOf(Repository::class) .assertTrue { it.resideInPackage("..repository..") }

U N Y F Y I N G P R O J E C T U S E C A S E S

EVERY USE CASE CLASS I S D E F I N E D I N S I D E “USECASE” PACKAGE FIRST TEST

CHECK CLASS NAME @Test fun `every use case has name ending with 'UseCase'`() { Konsist .scopeFromProduction() .classes() .filter { it.resideInPackage("..usecase..") } .assertTrue { it.hasNameEndingWith("UseCase") } }

CHECK CLASS NAME public class MarkSongAsFavorite { // … } class CreatePlaylistUC { // … } MarkSongAsFavoriteUseCase { CreatePlaylistUseCase {

CHECK “INVOKE” METHOD @Test fun `every use case has method named 'invoke'`() { Konsist .scopeFromProduction() .classes() .filter { it.resideInPackage("..usecase..") } .assertTrue { it.hasFunction { function -> function.name == "invoke" } } }

CHECK “INVOKE” METHOD public class MarkSongAsFavoriteUseCase { fun execute() { // business logic } } class CreatePlaylistUseCase { fun run() { // business logic } // ... } invoke() { invoke() {

@Test fun `every use case has name ending with 'UseCase'`() { Konsist .scopeFromProduction() .classes() .filter { it.resideInPackage("..usecase..") } .assertTrue it.hasNameEndingWith("UseCase") } } @Test fun `every use case method named 'invoke'`() { Konsist .scopeFromProduction() .classes() .filter { it.resideInPackage("..usecase..") } .assertTrue { it.hasFunction { function -> function.name == "invoke" } } } REFACTOR private val useCaseScope = Konsist .scopeFromProject() .classes() .filter { it.resideInPackage("..usecase..") } @Test fun `every use case has name ending with 'UseCase'`() { useCaseScope .assertTrue it.hasNameEndingWith("UseCase") } } @Test fun `every use case method named 'invoke'`() { useCaseScope .assertTrue { it.hasFunction { function -> function.name == "invoke" } } }

CHECK OPERATOR MODIFIER @Test fun `every use case method named 'invoke'`() { useCaseScope .assertTrue { it.hasFunction { function -> function.name == “invoke" } } } function.hasOperatorModifier && fun `every use case has operator method named 'invoke'`() {

CHECK OPERATOR MODIFIER public class MarkSongAsFavoriteUseCase { fun invoke() { // business logic } } class SubscribeToArtisUseCase { fun invoke() { // business logic } } class CreatePlaylistUseCase { fun invoke() { // business logic } // .. } operator fun invoke() { operator fun invoke() { operator fun invoke() {

CHECK SINGLE PUBLIC METHOD @Test fun `every use case has single public method`() { useCaseScope .assertTrue { it.countFunctions { item -> item.hasPublicOrDefaultModifier } == 1 } }

CHECK SINGLE PUBLIC METHOD class CreatePlaylistUseCase { operator fun invoke() { // business logic } fun calculateCalories() { // business logic } } private fun calculateCalories() {

CLASS VISIBILITY @Test fun `every use case class is public'`() { useCaseScope .assertTrue { it.hasPublicOrDefaultModifier } }

CLASS VISIBILITY private class ShareSongUseCase { operator fun invoke() { // business logic } } class ShareSongUseCase {

USECASE DECLARATIONS Suffix Method Name Operator Num Public Methods Class Visibility MarkSongAsFavorite UseCase invoke Yes 1 Public ShareSong UseCase invoke Yes 1 Public CreatePlaylist UseCase invoke Yes 1 Public SubscribeToArtist UseCase invoke Yes 1 Public

A R C H I T E C T U R E C H E C K S

STRUCTURE OF KONSIST TEST Konsist .scopeFromProduction() .assertArchitecture { // Define layers val domain = Layer("Domain", "com.app.domain..") val presentation = Layer("Presentation", "com.app.presentation..") val data = Layer("Data", "com.app.data..") // Define architecture assertions domain.dependsOnNothing() presentation.dependsOn(domain) data.dependsOn(domain) } Presentation Data Domain

A N O T H E R L I N T E R

• Code Maintainability • Complexity Reduction • Code Safety Popular linters in Kotlin Ecosystem Lint • Code Readability • Style Consistency • Structural Clarity • Compatibility Awareness • Performance Efficiency • API Adherence KOTLIN LINTERS

• Code Maintainability • Complexity Reduction • Code Safety Popular linters in Kotlin Ecosystem Lint • Code Readability • Style Consistency • Structural Clarity • Compatibility Awareness • Performance Efficiency • API Adherence KOTLIN LINTERS • Architectural Integrity • Layer Separation • Testability & Scalability

JAVA BYTECODE Java Source Code Kotlin Source Code Java Compiler Kotlin Compiler JVM Bytecode

SINGLE METHOD CHECK Overload 1 (no arguments) Overload 2 (one argument) Overload 3 (all arguments) fun greet(name: String = "World", greeting: String = "Hello") fun greet() Kotlin Source Code JVM Bytecode Method

FILTER DECLARATIONS @Test fun `every class should have a test class`() { } extensions default arguments data classes sealed interfaces companion objects

JAVA BYTECODE Java Source Code Kotlin Source Code Java Compiler Kotlin Compiler JVM Bytecode

KOTLIN MULTIPLATFORM JVM Bytecode Native WebAssembly JavaScript Kotlin Source Code   x x x    Targets

ARCHUNIT VERBOSE SYNTAX @Test fun `classes with 'UseCase' suffix should have single method named ‘invoke'`() { classes() .that().haveSimpleNameEndingWith("UseCase") .should(haveOnePublicMethodWithName("invoke")) .check(allClasses) } fun haveOnePublicMethodWithName(methodName: String) = object : ArchCondition("have exactly one public method named '$methodName'") { override fun check(javaClass: JavaClass, conditionEvents: ConditionEvents) { val publicMethods = javaClass .methods .filter { it.modifiers.contains(JavaModifier.PUBLIC) } if (publicMethods.size == 1) { val method = publicMethods[0] // When method accepts Kotlin value class then Kotlin will generate // a random suffix to the method name e.g. methodName-suffix val methodExists = method.name == methodName || method.name.startsWith("$methodName-") if (!methodExists) { val message: String = createMessage( javaClass, "contains does not have method named '${method.name}' ${method.sourceCodeLocation}", ) conditionEvents.add(violated(javaClass, message)) } } else { val message: String = createMessage( javaClass, "contains multiple public methods", ) conditionEvents.add(violated(javaClass, message)) } } }

K O N S I S T D E E P D I V E

KoFunction KoProperty KO DECLARATION KoScope KoClass KoFunction KoFile Konsist .scopeFromProject() .classes() .functions()

DEBUGGING Konsist .scopeFromProduction() .functions() .print() .print(prefix = “KonsistTest") .print { it.name } .withExpressionBody() .assertTrue { it.name }

DEBUGGING

DEBUGGING

DYNAMIC TESTS @Test fun `use case should have test`() { // Konsist Test } @Test fun `use case should reside in ..usecase.. package`() { // Konsist Test } Static Konsist Test Dynamic Konsist Test

S T A T E O F K O N S I S T

KONSIST IN NUMBERS Lines Of Code 180K Github Stars 900  Community Members 150+ Versions Released 10 PRs Closed 1K Contributors 50 Doc pages 150

DOCUMENTATION docs.konsist.lemonappdev.com

KONSIST COMPATIBILITY Testing Frameworks Projects Types Build Systems Multiplatform

EXTENSIVE TESTING

PRODUCTION READY Test Only Dependency

Structural Linter 06 Production Ready  05 Free To Use  04 Declaration and Architecture Verification  03 Flexible API  02 Open Source  KEY TAKEAWAYS 01 Kotlin Dedicated 

WHERE TO START?  docs.konsist.lemonappdev.com Examine Documentation

THANKS FOR LISTENING! Any Questions? 

@igorwojda Thank you,
 and please vote Natalia Peterwas Igor Wojda 