Split LabelRepository off the MessageRepository

2017-11-27 22:06:25 +01:00
parent f45f6c3919
commit 760e423b9b
11 changed files with 356 additions and 279 deletions
--- a/app/src/test/java/ch/dissem/bitmessage/repository/AndroidLabelRepositoryTest.kt
+++ b/app/src/test/java/ch/dissem/bitmessage/repository/AndroidLabelRepositoryTest.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015 Christian Basler
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ch.dissem.bitmessage.repository
+
+import android.os.Build
+import ch.dissem.apps.abit.repository.AndroidLabelRepository
+import ch.dissem.apps.abit.repository.SqlHelper
+import ch.dissem.bitmessage.entity.valueobject.Label
+import ch.dissem.bitmessage.ports.LabelRepository
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = intArrayOf(Build.VERSION_CODES.LOLLIPOP), packageName = "ch.dissem.apps.abit")
+class AndroidLabelRepositoryTest : TestBase() {
+
+    private lateinit var repo: LabelRepository
+
+
+    @Before
+    fun setUp() {
+        RuntimeEnvironment.application.deleteDatabase(SqlHelper.DATABASE_NAME)
+        val sqlHelper = SqlHelper(RuntimeEnvironment.application)
+
+        repo = AndroidLabelRepository(sqlHelper, RuntimeEnvironment.application)
+    }
+
+    @Test
+    fun `ensure labels are retrieved`() {
+        val labels = repo.getLabels()
+        assertEquals(7, labels.size.toLong())
+    }
+
+    @Test
+    fun `ensure labels can be retrieved by type`() {
+        val labels = repo.getLabels(Label.Type.INBOX)
+        assertEquals(1, labels.size.toLong())
+        assertEquals("Inbox", labels[0].toString())
+    }
+
+}
--- a/app/src/test/java/ch/dissem/bitmessage/repository/AndroidMessageRepositoryTest.kt
+++ b/app/src/test/java/ch/dissem/bitmessage/repository/AndroidMessageRepositoryTest.kt
@@ -17,8 +17,8 @@
 package ch.dissem.bitmessage.repository

 import android.os.Build
-import ch.dissem.apps.abit.BuildConfig
 import ch.dissem.apps.abit.repository.AndroidAddressRepository
+import ch.dissem.apps.abit.repository.AndroidLabelRepository
 import ch.dissem.apps.abit.repository.AndroidMessageRepository
 import ch.dissem.apps.abit.repository.SqlHelper
 import ch.dissem.bitmessage.cryptography.sc.SpongyCryptography
@@ -31,12 +31,12 @@ import ch.dissem.bitmessage.entity.valueobject.ExtendedEncoding
 import ch.dissem.bitmessage.entity.valueobject.Label
 import ch.dissem.bitmessage.entity.valueobject.PrivateKey
 import ch.dissem.bitmessage.entity.valueobject.extended.Message
+import ch.dissem.bitmessage.ports.LabelRepository
 import ch.dissem.bitmessage.ports.MessageRepository
 import ch.dissem.bitmessage.utils.UnixTime
 import org.hamcrest.BaseMatcher
 import org.hamcrest.CoreMatchers.`is`
 import org.hamcrest.Description
-import org.hamcrest.Matcher
 import org.hamcrest.Matchers.*
 import org.junit.Assert.*
 import org.junit.Before
@@ -67,14 +67,16 @@ class AndroidMessageRepositoryTest : TestBase() {
        val sqlHelper = SqlHelper(RuntimeEnvironment.application)

        val addressRepo = AndroidAddressRepository(sqlHelper)
-        repo = AndroidMessageRepository(sqlHelper, RuntimeEnvironment.application)
+        val labelRepo = AndroidLabelRepository(sqlHelper, RuntimeEnvironment.application)
+        repo = AndroidMessageRepository(sqlHelper)
        mockedInternalContext(
-                cryptography = SpongyCryptography(),
-                addressRepository = addressRepo,
-                messageRepository = repo,
-                port = 12345,
-                connectionTTL = 10,
-                connectionLimit = 10
+            cryptography = SpongyCryptography(),
+            addressRepository = addressRepo,
+            labelRepository = labelRepo,
+            messageRepository = repo,
+            port = 12345,
+            connectionTTL = 10,
+            connectionLimit = 10
        )
        val tmp = BitmessageAddress(PrivateKey(false, 1, 1000, 1000, DOES_ACK))
        contactA = BitmessageAddress(tmp.address)
@@ -86,29 +88,16 @@ class AndroidMessageRepositoryTest : TestBase() {
        identity = BitmessageAddress(PrivateKey(false, 1, 1000, 1000, DOES_ACK))
        addressRepo.save(identity)

-        inbox = repo.getLabels(Label.Type.INBOX)[0]
-        sent = repo.getLabels(Label.Type.SENT)[0]
-        drafts = repo.getLabels(Label.Type.DRAFT)[0]
-        unread = repo.getLabels(Label.Type.UNREAD)[0]
+        inbox = labelRepo.getLabels(Label.Type.INBOX)[0]
+        sent = labelRepo.getLabels(Label.Type.SENT)[0]
+        drafts = labelRepo.getLabels(Label.Type.DRAFT)[0]
+        unread = labelRepo.getLabels(Label.Type.UNREAD)[0]

        addMessage(contactA, identity, Plaintext.Status.RECEIVED, inbox, unread)
        addMessage(identity, contactA, Plaintext.Status.DRAFT, drafts)
        addMessage(identity, contactB, Plaintext.Status.DRAFT, unread)
    }

-    @Test
-    fun `ensure labels are retrieved`() {
-        val labels = repo.getLabels()
-        assertEquals(7, labels.size.toLong())
-    }
-
-    @Test
-    fun `ensure labels can be retrieved by type`() {
-        val labels = repo.getLabels(Label.Type.INBOX)
-        assertEquals(1, labels.size.toLong())
-        assertEquals("Inbox", labels[0].toString())
-    }
-
    @Test
    fun `ensure messages can be found by label`() {
        val messages = repo.findMessages(inbox)
@@ -176,12 +165,12 @@ class AndroidMessageRepositoryTest : TestBase() {
    @Test
    fun `ensure message can be saved`() {
        val message = Plaintext.Builder(MSG)
-                .IV(randomInventoryVector())
-                .from(identity)
-                .to(contactA)
-                .message("Subject", "Message")
-                .status(Plaintext.Status.DOING_PROOF_OF_WORK)
-                .build()
+            .IV(randomInventoryVector())
+            .from(identity)
+            .to(contactA)
+            .message("Subject", "Message")
+            .status(Plaintext.Status.DOING_PROOF_OF_WORK)
+            .build()
        repo.save(message)

        assertNotNull(message.id)
@@ -220,14 +209,14 @@ class AndroidMessageRepositoryTest : TestBase() {
    @Test
    fun `ensure unacknowledged messages are found for resend`() {
        val message = Plaintext.Builder(MSG)
-                .IV(randomInventoryVector())
-                .from(identity)
-                .to(contactA)
-                .message("Subject", "Message")
-                .sent(UnixTime.now)
-                .status(Plaintext.Status.SENT)
-                .ttl(2)
-                .build()
+            .IV(randomInventoryVector())
+            .from(identity)
+            .to(contactA)
+            .message("Subject", "Message")
+            .sent(UnixTime.now)
+            .status(Plaintext.Status.SENT)
+            .ttl(2)
+            .build()
        message.updateNextTry()
        assertThat(message.retries, `is`(1))
        assertThat<Long>(message.nextTry, greaterThan(UnixTime.now))
@@ -265,57 +254,57 @@ class AndroidMessageRepositoryTest : TestBase() {

    private fun addMessage(from: BitmessageAddress, to: BitmessageAddress, status: Plaintext.Status, vararg labels: Label): Plaintext {
        val content = Message.Builder()
-                .subject("Subject")
-                .body("Message")
-                .build()
+            .subject("Subject")
+            .body("Message")
+            .build()
        return addMessage(from, to, content, status, *labels)
    }

    private fun addMessage(from: BitmessageAddress, to: BitmessageAddress,
                           content: ExtendedEncoding, status: Plaintext.Status, vararg labels: Label): Plaintext {
        val message = Plaintext.Builder(MSG)
-                .IV(randomInventoryVector())
-                .from(from)
-                .to(to)
-                .message(content)
-                .status(status)
-                .labels(Arrays.asList(*labels))
-                .build()
+            .IV(randomInventoryVector())
+            .from(from)
+            .to(to)
+            .message(content)
+            .status(status)
+            .labels(Arrays.asList(*labels))
+            .build()
        repo.save(message)
        return message
    }

    private fun storeConversation(): Plaintext {
        val older = addMessage(identity, contactA,
-                Message.Builder()
-                        .subject("hey there")
-                        .body("does it work?")
-                        .build(),
-                Plaintext.Status.SENT, sent)
+            Message.Builder()
+                .subject("hey there")
+                .body("does it work?")
+                .build(),
+            Plaintext.Status.SENT, sent)

        val root = addMessage(identity, contactA,
-                Message.Builder()
-                        .subject("new test")
-                        .body("There's a new test in town!")
-                        .build(),
-                Plaintext.Status.SENT, sent)
+            Message.Builder()
+                .subject("new test")
+                .body("There's a new test in town!")
+                .build(),
+            Plaintext.Status.SENT, sent)

        addMessage(contactA, identity,
-                Message.Builder()
-                        .subject("Re: new test")
-                        .body("Nice!")
-                        .addParent(root)
-                        .build(),
-                Plaintext.Status.RECEIVED, inbox)
+            Message.Builder()
+                .subject("Re: new test")
+                .body("Nice!")
+                .addParent(root)
+                .build(),
+            Plaintext.Status.RECEIVED, inbox)

        addMessage(contactA, identity,
-                Message.Builder()
-                        .subject("Re: new test")
-                        .body("PS: it did work!")
-                        .addParent(root)
-                        .addParent(older)
-                        .build(),
-                Plaintext.Status.RECEIVED, inbox)
+            Message.Builder()
+                .subject("Re: new test")
+                .body("PS: it did work!")
+                .addParent(root)
+                .addParent(older)
+                .build(),
+            Plaintext.Status.RECEIVED, inbox)

        return repo.getMessage(root.id!!)
    }
--- a/app/src/test/java/ch/dissem/bitmessage/repository/AndroidProofOfWorkRepositoryTest.kt
+++ b/app/src/test/java/ch/dissem/bitmessage/repository/AndroidProofOfWorkRepositoryTest.kt
@@ -17,10 +17,7 @@
 package ch.dissem.bitmessage.repository

 import android.os.Build.VERSION_CODES.LOLLIPOP
-import ch.dissem.apps.abit.repository.AndroidAddressRepository
-import ch.dissem.apps.abit.repository.AndroidMessageRepository
-import ch.dissem.apps.abit.repository.AndroidProofOfWorkRepository
-import ch.dissem.apps.abit.repository.SqlHelper
+import ch.dissem.apps.abit.repository.*
 import ch.dissem.bitmessage.entity.BitmessageAddress
 import ch.dissem.bitmessage.entity.ObjectMessage
 import ch.dissem.bitmessage.entity.Plaintext
@@ -64,10 +61,11 @@ class AndroidProofOfWorkRepositoryTest : TestBase() {
        val sqlHelper = SqlHelper(RuntimeEnvironment.application)

        addressRepo = AndroidAddressRepository(sqlHelper)
-        messageRepo = AndroidMessageRepository(sqlHelper, RuntimeEnvironment.application)
+        messageRepo = AndroidMessageRepository(sqlHelper)
        repo = AndroidProofOfWorkRepository(sqlHelper)
        mockedInternalContext(
            addressRepository = addressRepo,
+            labelRepository = AndroidLabelRepository(sqlHelper, RuntimeEnvironment.application),
            messageRepository = messageRepo,
            proofOfWorkRepository = repo,
            cryptography = cryptography()
--- a/app/src/test/java/ch/dissem/bitmessage/repository/TestBase.kt
+++ b/app/src/test/java/ch/dissem/bitmessage/repository/TestBase.kt
@@ -18,6 +18,7 @@ package ch.dissem.bitmessage.repository

 import ch.dissem.bitmessage.BitmessageContext
 import ch.dissem.bitmessage.InternalContext
+import ch.dissem.bitmessage.Preferences
 import ch.dissem.bitmessage.cryptography.sc.SpongyCryptography
 import ch.dissem.bitmessage.entity.BitmessageAddress
 import ch.dissem.bitmessage.entity.ObjectMessage
@@ -40,42 +41,45 @@ open class TestBase {
        @JvmStatic
        fun init() {
            mockedInternalContext(
-                    cryptography = SpongyCryptography(),
-                    proofOfWorkEngine = MultiThreadedPOWEngine()
+                cryptography = SpongyCryptography(),
+                proofOfWorkEngine = MultiThreadedPOWEngine()
            )
        }

        fun mockedInternalContext(
-                cryptography: Cryptography = mock {},
-                inventory: Inventory = mock {},
-                nodeRegistry: NodeRegistry = mock {},
-                networkHandler: NetworkHandler = mock {},
-                addressRepository: AddressRepository = mock {},
-                messageRepository: MessageRepository = mock {},
-                proofOfWorkRepository: ProofOfWorkRepository = mock {},
-                proofOfWorkEngine: ProofOfWorkEngine = mock {},
-                customCommandHandler: CustomCommandHandler = mock {},
-                listener: BitmessageContext.Listener = mock {},
-                labeler: Labeler = mock {},
-                port: Int = 0,
-                connectionTTL: Long = 0,
-                connectionLimit: Int = 0
+            cryptography: Cryptography = mock {},
+            inventory: Inventory = mock {},
+            nodeRegistry: NodeRegistry = mock {},
+            networkHandler: NetworkHandler = mock {},
+            addressRepository: AddressRepository = mock {},
+            labelRepository: LabelRepository = mock {},
+            messageRepository: MessageRepository = mock {},
+            proofOfWorkRepository: ProofOfWorkRepository = mock {},
+            proofOfWorkEngine: ProofOfWorkEngine = mock {},
+            customCommandHandler: CustomCommandHandler = mock {},
+            listener: BitmessageContext.Listener = mock {},
+            labeler: Labeler = mock {},
+            port: Int = 0,
+            connectionTTL: Long = 0,
+            connectionLimit: Int = 0
        ) = spy(InternalContext(
-                cryptography,
-                inventory,
-                nodeRegistry,
-                networkHandler,
-                addressRepository,
-                messageRepository,
-                proofOfWorkRepository,
-                proofOfWorkEngine,
-                customCommandHandler,
-                listener,
-                labeler,
-                "/Jabit:TEST/",
-                port,
-                connectionTTL,
-                connectionLimit
+            cryptography,
+            inventory,
+            nodeRegistry,
+            networkHandler,
+            addressRepository,
+            labelRepository,
+            messageRepository,
+            proofOfWorkRepository,
+            proofOfWorkEngine,
+            customCommandHandler,
+            listener,
+            labeler,
+            Preferences().apply {
+                this.port = port
+                this.connectionTTL = connectionTTL
+                this.connectionLimit = connectionLimit
+            }
        ))

        fun randomInventoryVector(): InventoryVector {
@@ -85,7 +89,7 @@ open class TestBase {
        }

        private fun getResource(resourceName: String) =
-                TestBase::class.java.classLoader.getResourceAsStream(resourceName)
+            TestBase::class.java.classLoader.getResourceAsStream(resourceName)

        private fun loadObjectMessage(version: Int, resourceName: String): ObjectMessage {
            val data = getBytes(resourceName)