For the complete documentation index, see llms.txt. This page is also available as Markdown.

Verify Properties

Properties can be checked for proper access modifiers, type declarations, and initialization patterns.

To verify properties start by querying all properties present in the project:

Konsist
.scopeFromProject()
.properties()
...

In practical scenarios you'll typically want to verify a specific subset of properties - such as those defined inside classes:

Konsist
.scopeFromProject()
.classes()
.properties()
...

Konsist allows you to verify multiple aspects of properties. For the complete list of available APIs, explore KoPropertyDeclaration in your IDE (code completion and KDoc).

Let's look at a few examples.

Verify Name

Property names can be validated to ensure they follow project naming conventions and patterns.

Check if Boolean property has name starting with is:

...
.filter { it.type?.name == "Boolean" }
.assertTrue { 
    it.hasNameStartingWith("is")
}

Verify Type

Property types can be validated to ensure type safety and conventions:

Verify Modifiers

Property modifiers can be validated to ensure proper encapsulation:

Verify Annotations

Property annotations can be verified for presence and correct usage:

Verify Accessors

Getter and setter presence and implementation can be validated:

Check if property has getter:

Check if property has setter:

Verify Initialization

Property initialization can be verified:

Verify Delegates

Property delegates can be verified. Built-in delegate checks are available since Konsist 1.0.0-beta.1.

Check if property has lazy delegate (matches lazy { }, lazy<T> { } and lazy(mode) { }):

Check if property has lazy delegate with a given thread safety mode (lazy without an explicit mode uses LazyThreadSafetyMode.SYNCHRONIZED):

Check if property does not use Delegates.observable or Delegates.vetoable delegate:

Check if lazy properties using LazyThreadSafetyMode.NONE or LazyThreadSafetyMode.PUBLICATION are private:

Available built-in delegate checks and list filters:

Member
List filters
Matches

hasLazyDelegate(mode)

withLazyDelegate(vararg modes), withoutLazyDelegate(vararg modes)

lazy { }, lazy<T> { }, lazy(mode) { }

hasObservableDelegate

withObservableDelegate(), withoutObservableDelegate()

Delegates.observable(...)

hasVetoableDelegate

withVetoableDelegate(), withoutVetoableDelegate()

Delegates.vetoable(...)

hasNotNullDelegate

withNotNullDelegate(), withoutNotNullDelegate()

Delegates.notNull()

hasPropertyReferenceDelegate

withPropertyReferenceDelegate(), withoutPropertyReferenceDelegate()

by ::otherProperty, by this::otherProperty

withLazyDelegate() with no modes keeps properties with any lazy delegate. With modes, it keeps properties whose lazy delegate uses any of the given modes. withoutLazyDelegate(modes) removes only those properties, so non-lazy properties are kept. Both filters also accept a Collection<LazyThreadSafetyMode>.

Custom delegates can be verified using hasDelegate("delegateName").

Delegate checks match the delegate text, not resolved types:

  • observable(...), vetoable(...) and notNull() imported directly (without the Delegates. prefix) are not detected.

  • by map delegation is not supported by built-in checks - use hasDelegate("map").

  • hasLazyDelegate(mode) returns false when the mode is not a literal constant, e.g. lazy(lock) { } or lazy(modeVariable) { }. hasLazyDelegate() (no mode) still returns true. For the same reason withLazyDelegate(modes) drops and withoutLazyDelegate(modes) keeps such properties.

  • Interface delegation (class Foo : Bar by baz) inherits these members. They are designed for property delegates. For interface delegates they check the delegate expression text the same way (usually false).

Verify Explicit Backing Field

Property explicit backing field (field = ...) can be verified:

Check if property has explicit backing field:

The explicit backing field declaration (explicitBackingField) provides access to its type (e.g. field: MutableStateFlow<Int> = ...), tacitType and value.

Verify Visibility

Property visibility scope can be validated:

Check if property has internal modifier:

Verify Mutability

Property mutability can be checked.

Check if property is immutable:

Check if property is mutable:

Check if public property does not expose a mutable type (e.g. MutableList, ArrayList, Array or a class with a var property), including type arguments (e.g. List<MutableList<String>>):

Check if property in a data class has an immutable type (e.g. String, List<String>, java.time.LocalDate or a final project class without mutable properties):

isMutableType and isImmutableType check only the type itself (for List<MutableList<String>> isImmutableType is true); use hasMutableTypeArgument and hasImmutableTypeArgument to check type arguments at any nesting level. Type aliases and import aliases are resolved to the type they point to. List filters are available: withMutableType(), withImmutableType(), withMutableTypeArgument(), withImmutableTypeArgument() and their without... counterparts.

A type can be neither mutable nor immutable. When mutability cannot be determined, isImmutableType returns false (and isMutableType returns false unless the type itself is mutable), e.g. for type parameters (T), function types, external types not known to be immutable (e.g. java.util.Date), Kotlin types commonly implemented by mutable types (Any, Comparable, CharSequence, Number), and interfaces, open, abstract or sealed classes declared in the project. To verify that a type is not mutable, use assertFalse { it.type?.isMutableType == true } instead of checking isImmutableType.

Verify Context Parameters

Property context parameters can be verified:

Check if property has no context parameters:

Check if property has Logger context parameter:

Last updated