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:
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").
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.
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