Improved test coverage

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/IrcUser.kt

@@ -77,7 +77,7 @@ open class IrcUser(
     "lastAwayMessageTime" to qVariant(lastAwayMessageTime(), QtType.QDateTime),
     "whoisServiceReply" to qVariant(whoisServiceReply(), QtType.QString),
     "suserHost" to qVariant(suserHost(), QtType.QString),
-    "encrypted" to qVariant(encrypted(), QtType.Bool),
+    "encrypted" to qVariant(isEncrypted(), QtType.Bool),
 
     "channels" to qVariant(channels().toList(), QtType.QStringList),
     "userModes" to qVariant(userModes().joinToString(), QtType.QString)
@@ -222,7 +222,7 @@ open class IrcUser(
 
   override fun setUserModes(modes: String) {
     state.update {
-      copy(userModes = userModes.toSet())
+      copy(userModes = modes.toSet())
     }
     super.setUserModes(modes)
   }
@@ -292,7 +292,7 @@ open class IrcUser(
   fun lastAwayMessageTime() = state().lastAwayMessageTime
   fun whoisServiceReply() = state().whoisServiceReply
   fun suserHost() = state().suserHost
-  fun encrypted() = state().encrypted
+  fun isEncrypted() = state().encrypted
   fun userModes() = state().userModes
   fun channels() = state().channels
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/Network.kt

@@ -51,10 +51,10 @@ open class Network(
           ?: codecForServer,
         codecForEncoding = properties["codecForEncoding"].into<ByteBuffer>()
           ?.let(StringSerializerUtf8::deserializeRaw)
-          ?: codecForServer,
+          ?: codecForEncoding,
         codecForDecoding = properties["codecForDecoding"].into<ByteBuffer>()
           ?.let(StringSerializerUtf8::deserializeRaw)
-          ?: codecForServer,
+          ?: codecForDecoding,
         identity = properties["identityId"]
           .into(identity),
         connected = properties["isConnected"]
@@ -456,7 +456,7 @@ open class Network(
 
   override fun setIdentity(identityId: IdentityId) {
     state.update {
-      copy(identity = identity)
+      copy(identity = identityId)
     }
     super.setIdentity(identityId)
   }

libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/BufferViewConfigTest.kt

@@ -20,7 +20,7 @@ class BufferViewConfigTest {
   fun testEmpty() {
     val state = BufferViewConfigState(bufferViewId = 1)
     val actual = BufferViewConfig(state = state).apply {
-      fromVariantMap(emptyMap())
+      update(emptyMap())
     }.state()
 
     assertEquals(state, actual)
@@ -36,7 +36,7 @@ class BufferViewConfigTest {
         bufferViewId = expected.bufferViewId,
       )
     ).apply {
-      fromVariantMap(BufferViewConfig(state = expected).toVariantMap())
+      update(BufferViewConfig(state = expected).toVariantMap())
     }.state()
 
     assertEquals(expected, actual)

libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/BufferViewManagerTest.kt

@@ -20,7 +20,7 @@ class BufferViewManagerTest {
   fun testEmpty() {
     val state = BufferViewManagerState()
     val actual = BufferViewManager(state = state).apply {
-      fromVariantMap(emptyMap())
+      update(emptyMap())
     }.state()
 
     assertEquals(state, actual)
@@ -32,7 +32,7 @@ class BufferViewManagerTest {
     val expected = random.nextBufferViewManager()
 
     val actual = BufferViewManager().apply {
-      fromVariantMap(BufferViewManager(state = expected).toVariantMap())
+      update(BufferViewManager(state = expected).toVariantMap())
     }.state()
 
     assertEquals(expected, actual)

libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/IrcChannelTest.kt

@@ -13,6 +13,8 @@ import de.justjanne.libquassel.protocol.models.ids.NetworkId
 import de.justjanne.libquassel.protocol.syncables.state.IrcChannelState
 import de.justjanne.libquassel.protocol.testutil.nextIrcChannel
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotEquals
+import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 import kotlin.random.Random
 
@@ -24,7 +26,7 @@ class IrcChannelTest {
       name = "#name"
     )
     val actual = IrcChannel(state = state).apply {
-      fromVariantMap(emptyMap())
+      update(emptyMap())
     }.state()
 
     assertEquals(state, actual)
@@ -41,9 +43,43 @@ class IrcChannelTest {
         name = expected.name,
       )
     ).apply {
-      fromVariantMap(IrcChannel(state = expected).toVariantMap())
+      update(IrcChannel(state = expected).toVariantMap())
     }.state()
 
     assertEquals(expected, actual)
   }
+
+  @Nested
+  inner class Setters {
+    @Test
+    fun testTopic() {
+      val random = Random(1337)
+      val channel = IrcChannel(state = random.nextIrcChannel(NetworkId(random.nextInt())))
+
+      assertNotEquals("IMPLEMENTATION DEFINED CONTROVERSY", channel.topic())
+      channel.setTopic("IMPLEMENTATION DEFINED CONTROVERSY")
+      assertEquals("IMPLEMENTATION DEFINED CONTROVERSY", channel.topic())
+    }
+
+    @Test
+    fun testPassword() {
+      val random = Random(1337)
+      val channel = IrcChannel(state = random.nextIrcChannel(NetworkId(random.nextInt())))
+
+      assertNotEquals("hunter2", channel.password())
+      channel.setPassword("hunter2")
+      assertEquals("hunter2", channel.password())
+    }
+
+    @Test
+    fun testEncrypted() {
+      val random = Random(1337)
+      val channel = IrcChannel(state = random.nextIrcChannel(NetworkId(random.nextInt())))
+
+      channel.setEncrypted(false)
+      assertEquals(false, channel.isEncrypted())
+      channel.setEncrypted(true)
+      assertEquals(true, channel.isEncrypted())
+    }
+  }
 }

libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/syncables/IrcUserTest.kt

@@ -13,7 +13,10 @@ import de.justjanne.libquassel.protocol.models.ids.NetworkId
 import de.justjanne.libquassel.protocol.syncables.state.IrcUserState
 import de.justjanne.libquassel.protocol.testutil.nextIrcUser
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotEquals
+import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
+import org.threeten.bp.Instant
 import kotlin.random.Random
 
 class IrcUserTest {
@@ -26,7 +29,7 @@ class IrcUserTest {
       host = "host"
     )
     val actual = IrcUser(state = state).apply {
-      fromVariantMap(emptyMap())
+      update(emptyMap())
     }.state()
 
     assertEquals(state, actual)
@@ -45,9 +48,215 @@ class IrcUserTest {
         host = expected.host
       )
     ).apply {
-      fromVariantMap(IrcUser(state = expected).toVariantMap())
+      update(IrcUser(state = expected).toVariantMap())
     }.state()
 
     assertEquals(expected, actual)
   }
+
+  @Nested
+  inner class Setters {
+    @Test
+    fun testHostMask() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      val nick = user.nick()
+      assertNotEquals("$nick!user@host", user.hostMask())
+      user.updateHostmask("$nick!user@host")
+      assertEquals("$nick!user@host", user.hostMask())
+    }
+
+    @Test
+    fun testAddUserModes() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      user.setUserModes("abc")
+      assertEquals(setOf('a', 'b', 'c'), user.userModes())
+      user.addUserModes("ef")
+      assertEquals(setOf('a', 'b', 'c', 'e', 'f'), user.userModes())
+    }
+
+    @Test
+    fun testRemoveUserModes() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      user.setUserModes("abc")
+      assertEquals(setOf('a', 'b', 'c'), user.userModes())
+      user.removeUserModes("ac")
+      assertEquals(setOf('b'), user.userModes())
+    }
+
+    @Test
+    fun testUserUnverified() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("~newuser", user.user())
+      assertNotEquals(null, user.verifiedUser())
+      user.setUser("~newuser")
+      assertEquals("~newuser", user.user())
+      assertEquals(null, user.verifiedUser())
+    }
+
+    @Test
+    fun testUserVerified() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("newuser", user.user())
+      assertNotEquals("newuser", user.verifiedUser())
+      user.setUser("newuser")
+      assertEquals("newuser", user.user())
+      assertEquals("newuser", user.verifiedUser())
+    }
+
+    @Test
+    fun testHost() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("TeraPro33-41.LowerMyBills.com", user.host())
+      user.setHost("TeraPro33-41.LowerMyBills.com")
+      assertEquals("TeraPro33-41.LowerMyBills.com", user.host())
+    }
+
+    @Test
+    fun testRealName() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("Bruce Wayne", user.realName())
+      user.setRealName("Bruce Wayne")
+      assertEquals("Bruce Wayne", user.realName())
+    }
+
+    @Test
+    fun testAccount() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("thebatman", user.account())
+      user.setAccount("thebatman")
+      assertEquals("thebatman", user.account())
+    }
+
+    @Test
+    fun testAway() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      user.setAway(false)
+      assertEquals(false, user.isAway())
+      user.setAway(true)
+      assertEquals(true, user.isAway())
+    }
+
+    @Test
+    fun testAwayMessage() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("I’ll be back", user.awayMessage())
+      user.setAwayMessage("I’ll be back")
+      assertEquals("I’ll be back", user.awayMessage())
+    }
+
+    @Test
+    fun testIdleTime() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      val timestamp = Instant.ofEpochSecond(1614642922)
+      assertNotEquals(timestamp, user.idleTime())
+      user.setIdleTime(timestamp)
+      assertEquals(timestamp, user.idleTime())
+    }
+
+    @Test
+    fun testLoginTime() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      val timestamp = Instant.ofEpochSecond(1614642922)
+      assertNotEquals(timestamp, user.loginTime())
+      user.setLoginTime(timestamp)
+      assertEquals(timestamp, user.loginTime())
+    }
+
+    @Test
+    fun testIrcOperator() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("lorem ipsum i dolor sit amet", user.ircOperator())
+      user.setIrcOperator("lorem ipsum i dolor sit amet")
+      assertEquals("lorem ipsum i dolor sit amet", user.ircOperator())
+    }
+
+    @Test
+    fun testLastAwayMessage() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      val timestamp = Instant.ofEpochSecond(1614642922)
+      assertNotEquals(timestamp, user.lastAwayMessageTime())
+      user.setLastAwayMessage(timestamp.epochSecond.toInt())
+      assertEquals(timestamp, user.lastAwayMessageTime())
+    }
+
+    @Test
+    fun testLastAwayMessageTime() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      val timestamp = Instant.ofEpochSecond(1614642922)
+      assertNotEquals(timestamp, user.lastAwayMessageTime())
+      user.setLastAwayMessageTime(timestamp)
+      assertEquals(timestamp, user.lastAwayMessageTime())
+    }
+
+    @Test
+    fun testWhoisServiceReply() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("lorem ipsum i dolor sit amet", user.whoisServiceReply())
+      user.setWhoisServiceReply("lorem ipsum i dolor sit amet")
+      assertEquals("lorem ipsum i dolor sit amet", user.whoisServiceReply())
+    }
+
+    @Test
+    fun testSuserHost() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("lorem ipsum i dolor sit amet", user.suserHost())
+      user.setSuserHost("lorem ipsum i dolor sit amet")
+      assertEquals("lorem ipsum i dolor sit amet", user.suserHost())
+    }
+
+    @Test
+    fun testEncrypted() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      user.setEncrypted(false)
+      assertEquals(false, user.isEncrypted())
+      user.setEncrypted(true)
+      assertEquals(true, user.isEncrypted())
+    }
+
+    @Test
+    fun testServer() {
+      val random = Random(1337)
+      val user = IrcUser(state = random.nextIrcUser(NetworkId(random.nextInt())))
+
+      assertNotEquals("orwell.freenode.net", user.server())
+      user.setServer("orwell.freenode.net")
+      assertEquals("orwell.freenode.net", user.server())
+    }
+  }
 }

libquassel-protocol/src/test/kotlin/de/justjanne/libquassel/protocol/testutil/MockSession.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.testutil
+
+import de.justjanne.libquassel.annotations.ProtocolSide
+import de.justjanne.libquassel.protocol.models.SignalProxyMessage
+import de.justjanne.libquassel.protocol.models.ids.IdentityId
+import de.justjanne.libquassel.protocol.models.ids.NetworkId
+import de.justjanne.libquassel.protocol.syncables.AliasManager
+import de.justjanne.libquassel.protocol.syncables.BufferSyncer
+import de.justjanne.libquassel.protocol.syncables.BufferViewManager
+import de.justjanne.libquassel.protocol.syncables.CoreInfo
+import de.justjanne.libquassel.protocol.syncables.DccConfig
+import de.justjanne.libquassel.protocol.syncables.HighlightRuleManager
+import de.justjanne.libquassel.protocol.syncables.Identity
+import de.justjanne.libquassel.protocol.syncables.Network
+import de.justjanne.libquassel.protocol.syncables.NetworkConfig
+import de.justjanne.libquassel.protocol.syncables.ObjectRepository
+import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.syncables.SyncableObject
+import de.justjanne.libquassel.protocol.syncables.stubs.BacklogManagerStub
+import de.justjanne.libquassel.protocol.syncables.stubs.IgnoreListManagerStub
+import de.justjanne.libquassel.protocol.syncables.stubs.IrcListHelperStub
+import de.justjanne.libquassel.protocol.variant.QVariantMap
+
+abstract class MockSession : Session {
+  override val protocolSide: ProtocolSide
+    get() = TODO("Mock Implementation")
+  override val objectRepository: ObjectRepository
+    get() = TODO("Mock Implementation")
+
+  override fun network(id: NetworkId): Network? = TODO("Mock Implementation")
+
+  override fun identity(id: IdentityId): Identity = TODO("Mock Implementation")
+
+  override fun aliasManager(): AliasManager = TODO("Mock Implementation")
+
+  override fun bufferSyncer(): BufferSyncer = TODO("Mock Implementation")
+
+  override fun backlogManager(): BacklogManagerStub = TODO("Mock Implementation")
+
+  override fun bufferViewManager(): BufferViewManager = TODO("Mock Implementation")
+
+  override fun ignoreListManager(): IgnoreListManagerStub = TODO("Mock Implementation")
+
+  override fun highlightRuleManager(): HighlightRuleManager = TODO("Mock Implementation")
+
+  override fun ircListHelper(): IrcListHelperStub = TODO("Mock Implementation")
+
+  override fun coreInfo(): CoreInfo = TODO("Mock Implementation")
+
+  override fun dccConfig(): DccConfig = TODO("Mock Implementation")
+
+  override fun networkConfig(): NetworkConfig = TODO("Mock Implementation")
+
+  override fun synchronize(it: SyncableObject): Unit = TODO("Mock Implementation")
+
+  override fun stopSynchronize(it: SyncableObject): Unit = TODO("Mock Implementation")
+
+  override fun emit(message: SignalProxyMessage): Unit = TODO("Mock Implementation")
+
+  override fun dispatch(message: SignalProxyMessage): Unit = TODO("Mock Implementation")
+
+  override fun dispatch(message: SignalProxyMessage.Sync): Unit = TODO("Mock Implementation")
+
+  override fun dispatch(message: SignalProxyMessage.Rpc): Unit = TODO("Mock Implementation")
+
+  override fun dispatch(message: SignalProxyMessage.InitRequest): Unit = TODO("Mock Implementation")
+
+  override fun dispatch(message: SignalProxyMessage.InitData): Unit = TODO("Mock Implementation")
+
+  override fun dispatch(message: SignalProxyMessage.HeartBeat): Unit = TODO("Mock Implementation")
+
+  override fun dispatch(message: SignalProxyMessage.HeartBeatReply): Unit = TODO("Mock Implementation")
+
+  override val className: String
+    get() = TODO("Mock Implementation")
+  override val objectName: String
+    get() = TODO("Mock Implementation")
+  override val initialized: Boolean
+    get() = TODO("Mock Implementation")
+  override val session: Session?
+    get() = TODO("Mock Implementation")
+
+  override fun fromVariantMap(properties: QVariantMap): Unit = TODO("Mock Implementation")
+
+  override fun toVariantMap(): QVariantMap = TODO("Mock Implementation")
+}