Added tests

build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
 }
 
 group = "net.igsoft"
-version = "0.5.0-SNAPSHOT"
+version = "0.5.0"
 
 repositories {
     mavenCentral()
@@ -97,6 +97,6 @@ dependencies {
     testImplementation("org.junit.platform:junit-platform-suite-commons:1.9.0")
     testImplementation("org.junit.jupiter:junit-jupiter-engine:5.9.0")
     testImplementation("org.junit.jupiter:junit-jupiter-params:5.9.0")
-    testImplementation("com.willowtreeapps.assertk:assertk-jvm:0.25")
+    testImplementation("com.willowtreeapps.assertk:assertk-jvm:0.26.1")
     testImplementation("io.mockk:mockk:1.13.2")
 }

src/main/kotlin/net/igsoft/typeutils/pipeline/Context.kt

@@ -9,5 +9,4 @@ class Context : MutableTypedProperties by TypedProperties(mutableMapOf()) {
     fun invokeNextProcessor() {
         pipeline?.process(this)
     }
-
 }

src/main/kotlin/net/igsoft/typeutils/property/ImmutableTypedPropertiesBuilder.kt

@@ -0,0 +1,14 @@
+package net.igsoft.typeutils.property
+
+import net.igsoft.typeutils.marker.TypedMarker
+
+@Suppress("unused")
+class ImmutableTypedPropertiesBuilder {
+    private val properties = TypedProperties(mutableMapOf())
+
+    fun <T> putProperty(key: TypedMarker<T>, value: T) = apply {
+        properties[key] = value
+    }
+
+    fun build(): ImmutableTypedProperties = properties
+}

src/main/kotlin/net/igsoft/typeutils/property/TypedProperties.kt

@@ -3,10 +3,10 @@ package net.igsoft.typeutils.property
 import net.igsoft.typeutils.marker.Marker
 import net.igsoft.typeutils.marker.TypedMarker
 
-@Suppress("UNCHECKED_CAST")
+@Suppress("UNCHECKED_CAST", "unused")
 class TypedProperties(private val map: MutableMap<Marker, Any?>) : MutableTypedProperties {
 
-    override fun <T> set(marker: TypedMarker<T>, value: T?) {
+    override operator fun <T> set(marker: TypedMarker<T>, value: T?) {
         map[marker] = value
     }
 
@@ -60,13 +60,13 @@ class TypedProperties(private val map: MutableMap<Marker, Any?>) : MutableTypedP
     override val size: Int
         get() = map.size
 
-    override val entries: Set<Map.Entry<Marker, Any?>>
+    override val entries: MutableSet<MutableMap.MutableEntry<Marker, Any?>>
         get() = map.entries
 
-    override val keys: Set<Marker>
+    override val keys: MutableSet<Marker>
         get() = map.keys
 
-    override val values: Collection<Any?>
+    override val values: MutableCollection<Any?>
         get() = map.values
 
     override fun isEmpty(): Boolean = map.isEmpty()
@@ -77,6 +77,15 @@ class TypedProperties(private val map: MutableMap<Marker, Any?>) : MutableTypedP
 
     override fun iterator(): Iterator<Map.Entry<Marker, Any?>> = map.iterator()
 
+    fun clear() {
+        map.clear()
+    }
+
+    fun <T> put(key: TypedMarker<T>, value: T?): Any? = map.put(key, value)
+
+    fun putAll(from: Map<out Marker, Any?>) = map.putAll(from)
+
+    fun remove(key: Marker): Any? = map.remove(key)
 
     private fun isPropertyKeyMissing(any: Any?, marker: Marker) =
         any == null && !map.containsKey(marker)

src/test/kotlin/net/igsoft/typeutils/globalcontext/GlobalContextTest.kt

@@ -0,0 +1,20 @@
+package net.igsoft.typeutils.globalcontext
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import net.igsoft.typeutils.marker.TypedMarker
+import org.junit.jupiter.api.Test
+
+data class Person(val firstName: String, val lastName: String, val age: Int)
+
+class GlobalContextTest {
+    private val person by TypedMarker.create<Person>()
+
+    @Test
+    fun `Assert that we can save and read objects on GlobalContext`() {
+        val personEntity = Person("Marcin", "Iksiński", 28)
+        GlobalContext.register(person, personEntity)
+
+        assertThat(GlobalContext[person]).isEqualTo(personEntity)
+    }
+}

src/test/kotlin/net/igsoft/typeutils/marker/TypedMarkerTest.kt

@@ -0,0 +1,30 @@
+package net.igsoft.typeutils.marker
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.prop
+import org.junit.jupiter.api.Test
+
+class TypedMarkerTest {
+    @Test
+    fun `Assert that TypedMarker can be created with property syntax`() {
+        val someProperty by TypedMarker.create<String>()
+        assertThat(someProperty).apply {
+            prop(TypedMarker<String>::clazz).isEqualTo(String::class.java)
+            prop(TypedMarker<String>::id).isEqualTo("someProperty")
+        }
+    }
+
+    @Test
+    fun `Assert that TypedMarker can be created manually`() {
+        assertThat(TypedMarker.create(String::class.java, "s1")).apply {
+            prop(TypedMarker<String>::clazz).isEqualTo(String::class.java)
+            prop(TypedMarker<String>::id).isEqualTo("s1")
+        }
+
+        assertThat(TypedMarker.create<Int>("s2")).apply {
+            prop(TypedMarker<Int>::clazz).isEqualTo(Integer::class.java)
+            prop(TypedMarker<Int>::id).isEqualTo("s2")
+        }
+    }
+}

src/test/kotlin/net/igsoft/typeutils/pipeline/PipelineTest.kt

@@ -0,0 +1,49 @@
+package net.igsoft.typeutils.pipeline
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import net.igsoft.typeutils.marker.TypedMarker
+import org.junit.jupiter.api.Test
+
+class PipelineTest {
+    private val firstname by TypedMarker.create<String>()
+    private val lastname by TypedMarker.create<String>()
+    private val age by TypedMarker.create<Int>()
+    private val shoeSize by TypedMarker.create<Int?>()
+    private val helloMessage by TypedMarker.create<String>()
+
+    private val p1: Processor = object: Processor {
+        override fun process(context: Context) {
+            context[helloMessage] = context[firstname] + " " + context[lastname]
+            context.invokeNextProcessor()
+        }
+    }
+
+    private val p2 = object: Processor {
+        override fun process(context: Context) {
+            val shoeSize = context[shoeSize]
+            val details = "age: " + context[age] + if (shoeSize != null) ", shoeSize: $shoeSize" else ""
+            context[helloMessage] = context[helloMessage] + " [$details]"
+            context.invokeNextProcessor()
+        }
+    }
+
+    @Test
+    fun `Create simple pipeline`() {
+        val context = Context()
+        context[firstname] = "Marcin"
+        context[lastname] = "Iksiński"
+        context[age] = 28
+
+        val pipeline = Pipeline(p1, p2)
+
+        pipeline.process(context)
+
+        assertThat(context[helloMessage]).isEqualTo("Marcin Iksiński [age: 28]")
+
+        context[shoeSize] = 32
+        pipeline.process(context)
+
+        assertThat(context[helloMessage]).isEqualTo("Marcin Iksiński [age: 28, shoeSize: 32]")
+    }
+}

src/test/kotlin/net/igsoft/typeutils/property/TypedPropertiesTest.kt

@@ -0,0 +1,59 @@
+package net.igsoft.typeutils.property
+
+import assertk.assertThat
+import assertk.assertions.*
+import net.igsoft.typeutils.marker.TypedMarker
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+class TypedPropertiesTest {
+    private lateinit var properties: TypedProperties
+    private val firstname by TypedMarker.create<String>()
+    private val surname by TypedMarker.create<String>()
+    private val age by TypedMarker.create<Int>()
+    private val shoeSize by TypedMarker.create<Int>()
+
+    @BeforeEach
+    fun setUp() {
+        properties = TypedProperties(mutableMapOf())
+
+        properties[firstname] = "Gregory"
+        properties[surname] = "Iksiński"
+        properties[age] = 28
+    }
+
+    @Test
+    fun `Assert that creation is possible`() {
+        val properties = TypedProperties(mutableMapOf())
+
+        assertThat(properties).isNotNull()
+        assertThat(properties).apply {
+            prop(TypedProperties::size).isEqualTo(0)
+            prop(TypedProperties::keys).isEmpty()
+            prop(TypedProperties::values).isEmpty()
+            prop(TypedProperties::entries).isEmpty()
+        }
+    }
+
+    @Test
+    fun `Assert that putting new properties is possible`() {
+        properties[shoeSize] = 32
+
+        assertThat(properties).apply {
+            prop(TypedProperties::size).isEqualTo(4)
+            prop(TypedProperties::keys).isEqualTo(setOf(firstname, surname, age, shoeSize))
+            prop(TypedProperties::values).containsExactlyInAnyOrder("Gregory", "Iksiński", 28, 32)
+        }
+    }
+
+    @Test
+    fun `Assert that removing properties is possible`() {
+        properties.remove(age)
+
+        assertThat(properties).apply {
+            prop(TypedProperties::size).isEqualTo(2)
+            prop(TypedProperties::keys).isEqualTo(setOf(firstname, surname))
+            prop(TypedProperties::values).containsExactlyInAnyOrder("Gregory", "Iksiński")
+        }
+    }
+}