12. Testing

dependencies {
    testImplementation("ke.co.coinx.kandra:kandra-test:0.4.6")
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0")
}

import io.kandra.test.FakeKandraSession
import com.datastax.oss.driver.api.core.cql.BatchStatement
import com.datastax.oss.driver.api.core.cql.DefaultBatchType
import com.datastax.oss.driver.api.core.cql.SimpleStatement
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.assertThrows
 
class TodoBatchCaptureTest {
 
    private val fakeSession = FakeKandraSession()
 
    @AfterEach
    fun tearDown() = fakeSession.reset()
 
    @Test
    fun `hand-built batch statements are captured for structural assertions`() {
        val batch = BatchStatement.newInstance(DefaultBatchType.LOGGED)
            .add(SimpleStatement.newInstance(
                "INSERT INTO todos (owner_id, created_at, title) VALUES (?, ?, ?)",
                UUID.randomUUID(), Instant.now(), "Ship the release"
            ))
            .add(SimpleStatement.newInstance(
                "INSERT INTO todos_by_assignee (assignee_id, created_at, todo_id) VALUES (?, ?, ?)",
                UUID.randomUUID(), Instant.now(), UUID.randomUUID()
            ))
 
        fakeSession.execute(batch)
 
        assertEquals(1, fakeSession.capturedBatches().size)
        assertEquals(2, fakeSession.capturedBatches().single().size)
    }
 
    @Test
    fun `saveInBatch throws under FakeKandraSession — regression guard for ISS-020`() {
        val runtime = io.kandra.test.KandraTestUtils.inMemory(Todo::class)
        val todoRepo = runtime.repository(Todo::class)
 
        assertThrows<UnsupportedOperationException> {
            todoRepo.save(Todo(UUID.randomUUID(), Instant.now(), UUID.randomUUID(), "x", null))
        }
 
        runtime.close()
        io.kandra.core.SchemaRegistry.clear()
    }
}

dependencies {
    testImplementation("org.testcontainers:cassandra:1.20.4")
    testImplementation("org.testcontainers:junit-jupiter:1.20.4")
}

import io.kandra.test.KandraTestcontainers
import io.kandra.core.exception.KandraOptimisticLockException
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.*
import org.junit.jupiter.api.Assertions.*
import java.time.Instant
import java.util.UUID
 
class TodoOptimisticLockIntegrationTest {
 
    private val db = KandraTestcontainers.freshKeyspace(User::class, Todo::class)
    private val todoRepo = db.suspendRepository<Todo>()
 
    @AfterEach
    fun tearDown() = db.close()
 
    @Test
    fun `updating from a stale snapshot throws KandraOptimisticLockException`() = runTest {
        val ownerId = UUID.randomUUID()
        val createdAt = Instant.now()
        val todo = Todo(ownerId, createdAt, UUID.randomUUID(), "Ship the release", null)
        todoRepo.save(todo)
 
        // Two "concurrent" readers both load the same version-1 snapshot.
        val readerA = todoRepo.findById(ownerId, createdAt)!!
        val readerB = todoRepo.findById(ownerId, createdAt)!!
 
        todoRepo.update(readerA, readerA.copy(title = "Ship the release (edited by A)"))  // wins, version -> 2
 
        // B still holds version 1 — its update loses the race.
        assertThrows<KandraOptimisticLockException> {
            todoRepo.update(readerB, readerB.copy(title = "Ship the release (edited by B)"))
        }
    }
}

class TodoSoftDeleteIntegrationTest {
 
    private val db = KandraTestcontainers.freshKeyspace(User::class, Todo::class)
    private val todoRepo = db.suspendRepository<Todo>()
 
    @AfterEach
    fun tearDown() = db.close()
 
    @Test
    fun `delete rewrites the row with a TTL marker instead of a real DELETE`() = runTest {
        val ownerId = UUID.randomUUID()
        val createdAt = Instant.now()
        val todo = Todo(ownerId, createdAt, UUID.randomUUID(), "Renew passport", null)
        todoRepo.save(todo)
 
        todoRepo.delete(todo)   // @SoftDelete: UPDATE ... USING TTL 604800, not DELETE
 
        // A real DELETE would make this null immediately. It doesn't, here.
        val afterDelete = todoRepo.findById(ownerId, createdAt)
        assertNotNull(afterDelete)
        assertTrue(afterDelete!!.isDeleted)
        assertEquals("Renew passport", afterDelete.title)   // whole row rewritten with a fresh TTL, not just a marker column
    }
}

import io.kandra.core.ExperimentalKandraApi
 
class DenormalizedWriteAtomicityIntegrationTest {
 
    private val db = KandraTestcontainers.freshKeyspace(User::class, Todo::class, TodoByAssignee::class)
    private val todoRepo = db.suspendRepository<Todo>()
    private val byAssigneeRepo = db.suspendRepository<TodoByAssignee>()
 
    @AfterEach
    fun tearDown() = db.close()
 
    @OptIn(ExperimentalKandraApi::class)
    @Test
    fun `assigning a todo writes both tables atomically via KandraBatchScope`() = runTest {
        val ownerId = UUID.randomUUID()
        val assigneeId = UUID.randomUUID()
        val createdAt = Instant.now()
        val todoId = UUID.randomUUID()
 
        db.runtime.batch {
            todoRepo.saveInBatch(Todo(ownerId, createdAt, todoId, "Review PR", assigneeId))
            byAssigneeRepo.saveInBatch(TodoByAssignee(assigneeId, createdAt, todoId, ownerId, "Review PR"))
        }
 
        assertEquals(todoId, todoRepo.findById(ownerId, createdAt)?.todoId)
        assertEquals(todoId, byAssigneeRepo.findById(assigneeId, createdAt)?.todoId)
    }
}