AndroidHandleManagerTest.kt

package arcs.android.storage.handle

import android.app.Application
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.LifecycleRegistry
import androidx.test.core.app.ActivityScenario
import androidx.test.core.app.ApplicationProvider
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.work.testing.WorkManagerTestInitHelper
import arcs.core.crdt.CrdtSet
import arcs.core.crdt.CrdtSingleton
import arcs.core.crdt.VersionMap
import arcs.core.data.FieldType
import arcs.core.data.RawEntity
import arcs.core.data.Schema
import arcs.core.data.SchemaFields
import arcs.core.data.SchemaName
import arcs.core.data.util.toReferencable
import arcs.core.storage.StorageKey
import arcs.core.storage.driver.RamDisk
import arcs.core.storage.driver.RamDiskStorageKey
import arcs.core.storage.handle.HandleManager
import arcs.core.storage.handle.SetCallbacks
import arcs.core.storage.handle.SingletonCallbacks
import arcs.core.storage.referencemode.ReferenceModeStorageKey
import arcs.sdk.android.storage.service.DefaultConnectionFactory
import arcs.sdk.android.storage.service.testutil.TestBindingDelegate
import com.google.common.truth.Truth.assertThat
import com.nhaarman.mockitokotlin2.mock
import kotlinx.coroutines.runBlocking
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.Mockito.times
import org.mockito.Mockito.verify


@Suppress("EXPERIMENTAL_API_USAGE")
@RunWith(AndroidJUnit4::class)
class AndroidHandleManagerTest : LifecycleOwner {
    private lateinit var lifecycle: LifecycleRegistry
    override fun getLifecycle() = lifecycle

    private lateinit var app: Application

    private lateinit var handleManager: HandleManager

    val entity1 = RawEntity(
        "entity1",
        singletons = mapOf(
            "name" to "Jason".toReferencable(),
            "age" to 21.toReferencable(),
            "is_cool" to false.toReferencable()
        ),
        collections = emptyMap()
    )

    val entity2 = RawEntity(
        "entity2",
        singletons = mapOf(
            "name" to "Jason".toReferencable(),
            "age" to 22.toReferencable(),
            "is_cool" to true.toReferencable()
        ),
        collections = emptyMap()
    )

    private val schema = Schema(
        listOf(SchemaName("Person")),
        SchemaFields(
            singletons = mapOf(
                "name" to FieldType.Text,
                "age" to FieldType.Number,
                "is_cool" to FieldType.Boolean
            ),
            collections = emptyMap()
        ),
        "1234acf"
    )

    private val singletonKey = ReferenceModeStorageKey(
        backingKey = RamDiskStorageKey("single-back"),
        storageKey = RamDiskStorageKey("single-ent")
    )

    private val setKey = ReferenceModeStorageKey(
        backingKey = RamDiskStorageKey("set-back"),
        storageKey = RamDiskStorageKey("set-ent")
    )

    @Before
    fun setUp() {
        RamDisk.clear()
        lifecycle = LifecycleRegistry(this).apply {
            setCurrentState(Lifecycle.State.CREATED)
            setCurrentState(Lifecycle.State.STARTED)
            setCurrentState(Lifecycle.State.RESUMED)
        }
        app = ApplicationProvider.getApplicationContext()

        // Initialize WorkManager for instrumentation tests.
        WorkManagerTestInitHelper.initializeTestWorkManager(app)

        handleManager = AndroidHandleManager(
            lifecycle = lifecycle,
            context = app,
            connectionFactory = DefaultConnectionFactory(app, TestBindingDelegate(app))
        )
    }

    @Test
    fun singleton_writeAndReadback() = runBlocking {
        val singletonHandle = handleManager.singletonHandle(singletonKey, schema)
        singletonHandle.store(entity1)

        // Now read back from a different handle
        val readbackHandle = handleManager.singletonHandle(singletonKey, schema)
        val readBack = readbackHandle.fetch()
        assertThat(readBack).isEqualTo(entity1)

    }

    @Test
    fun set_writeAndReadback() = runBlocking<Unit> {
        val setHandle = handleManager.setHandle(setKey, schema)
        setHandle.store(entity1)
        setHandle.store(entity2)

        // Now read back from a different handle
        val secondHandle = handleManager.setHandle(setKey, schema)
        val readBack = secondHandle.fetchAll()
        assertThat(readBack).containsExactly(entity1, entity2)
    }

    private fun testMapForKey(key: StorageKey) = VersionMap(key.toKeyString() to 1)

    @Test
    fun set_onHandleUpdate() = runBlocking<Unit> {
        val testCallback1 = mock<SetCallbacks<RawEntity>>()
        val testCallback2 = mock<SetCallbacks<RawEntity>>()
        val firstHandle = handleManager.setHandle(setKey, schema, testCallback1)
        val secondHandle = handleManager.setHandle(setKey, schema, testCallback2)

        val expectedAdd = CrdtSet.Operation.Add(
            setKey.toKeyString(),
            testMapForKey(setKey),
            entity1
        )
        secondHandle.store(entity1)
        verify(testCallback1, times(1)).onUpdate(firstHandle, expectedAdd)
        verify(testCallback2, times(1)).onUpdate(secondHandle, expectedAdd)

        firstHandle.remove(entity1)
        val expectedRemove = CrdtSet.Operation.Remove(
            setKey.toKeyString(),
            testMapForKey(setKey),
            entity1
        )
        verify(testCallback1, times(1)).onUpdate(firstHandle, expectedRemove)
        verify(testCallback2, times(1)).onUpdate(secondHandle, expectedRemove)
    }

    @Test
    fun singleton_OnHandleUpdate() = runBlocking<Unit> {
        val testCallback1 = mock<SingletonCallbacks<RawEntity>>()
        val testCallback2 = mock<SingletonCallbacks<RawEntity>>()
        val firstHandle = handleManager.singletonHandle(singletonKey, schema, testCallback1)
        val secondHandle = handleManager.singletonHandle(singletonKey, schema, testCallback2)
        secondHandle.store(entity1)
        val expectedAdd = CrdtSingleton.Operation.Update(
            singletonKey.toKeyString(),
            testMapForKey(singletonKey),
            entity1
        )
        verify(testCallback1, times(1)).onUpdate(firstHandle, expectedAdd)
        verify(testCallback2, times(1)).onUpdate(secondHandle, expectedAdd)
        firstHandle.clear()

        val expectedRemove = CrdtSingleton.Operation.Clear<RawEntity>(
            singletonKey.toKeyString(),
            testMapForKey(singletonKey)
        )
        verify(testCallback1, times(1)).onUpdate(firstHandle, expectedRemove)
        verify(testCallback2, times(1)).onUpdate(secondHandle, expectedRemove)
    }

    @Test
    fun set_syncOnRegister() = runBlocking<Unit> {
        val testCallback = mock<SetCallbacks<RawEntity>>()
        val firstHandle = handleManager.setHandle(setKey, schema, testCallback)
        verify(testCallback, times(1)).onSync(firstHandle)
        firstHandle.fetchAll()
        verify(testCallback, times(1)).onSync(firstHandle)
    }

    @Test
    fun testSingletonSyncOnRegister() = runBlocking<Unit> {
        val testCallback = mock<SingletonCallbacks<RawEntity>>()
        val firstHandle = handleManager.singletonHandle(setKey, schema, testCallback)
        verify(testCallback, times(1)).onSync(firstHandle)
        firstHandle.fetch()
        verify(testCallback, times(1)).onSync(firstHandle)
    }
}