Run linter

2023-03-07 19:46:44 +01:00
parent 2d92e1d444
commit eff8dbbafa
187 changed files with 7749 additions and 7655 deletions
@@ -10,84 +10,83 @@ import org.junit.Test
 * See [testing documentation](http://d.android.com/tools/testing).
 */
 class KeyParseTest {
-  @Test
-  fun keyParseTestNote() {
-    val result = parseDirtyWordForKey("note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn")
-    assertEquals("note", result?.type)
-    assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
-    assertEquals("", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestNote() {
+        val result = parseDirtyWordForKey("note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn")
+        assertEquals("note", result?.type)
+        assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
+        assertEquals("", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestPub() {
-    val result = parseDirtyWordForKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z")
-    assertEquals("npub", result?.type)
-    assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
-    assertEquals("", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestPub() {
+        val result = parseDirtyWordForKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z")
+        assertEquals("npub", result?.type)
+        assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
+        assertEquals("", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestNoteWithExtraChars() {
-    val result = parseDirtyWordForKey("note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
-    assertEquals("note", result?.type)
-    assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestNoteWithExtraChars() {
+        val result = parseDirtyWordForKey("note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
+        assertEquals("note", result?.type)
+        assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestPubWithExtraChars() {
-    val result = parseDirtyWordForKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
-    assertEquals("npub", result?.type)
-    assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestPubWithExtraChars() {
+        val result = parseDirtyWordForKey("npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
+        assertEquals("npub", result?.type)
+        assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestNoteWithExtraCharsAndAt() {
-    val result = parseDirtyWordForKey("@note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
-    assertEquals("note", result?.type)
-    assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestNoteWithExtraCharsAndAt() {
+        val result = parseDirtyWordForKey("@note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
+        assertEquals("note", result?.type)
+        assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestPubWithExtraCharsAndAt() {
-    val result = parseDirtyWordForKey("@npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
-    assertEquals("npub", result?.type)
-    assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestPubWithExtraCharsAndAt() {
+        val result = parseDirtyWordForKey("@npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
+        assertEquals("npub", result?.type)
+        assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestNoteWithExtraCharsAndNostrPrefix() {
-    val result = parseDirtyWordForKey("nostr:note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
-    assertEquals("note", result?.type)
-    assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestNoteWithExtraCharsAndNostrPrefix() {
+        val result = parseDirtyWordForKey("nostr:note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
+        assertEquals("note", result?.type)
+        assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestPubWithExtraCharsAndNostrPrefix() {
-    val result = parseDirtyWordForKey("nostr:npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
-    assertEquals("npub", result?.type)
-    assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
+    @Test
+    fun keyParseTestPubWithExtraCharsAndNostrPrefix() {
+        val result = parseDirtyWordForKey("nostr:npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
+        assertEquals("npub", result?.type)
+        assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }

+    @Test
+    fun keyParseTestUppercaseNoteWithExtraCharsAndNostrPrefix() {
+        val result = parseDirtyWordForKey("Nostr:note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
+        assertEquals("note", result?.type)
+        assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }

-  @Test
-  fun keyParseTestUppercaseNoteWithExtraCharsAndNostrPrefix() {
-    val result = parseDirtyWordForKey("Nostr:note1z5e2m0smx6d7e2d0zaq8d3rnd7httm6j0uf8tf90yqqjrs842czshwtkmn,")
-    assertEquals("note", result?.type)
-    assertEquals("1532adbe1b369beca9af174076c4736faeb5ef527f1275a4af200121c0f55605", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
-
-  @Test
-  fun keyParseTestUppercasePubWithExtraCharsAndNostrPrefix() {
-    val result = parseDirtyWordForKey("nOstr:npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
-    assertEquals("npub", result?.type)
-    assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
-    assertEquals(",", result?.restOfWord)
-  }
-}
+    @Test
+    fun keyParseTestUppercasePubWithExtraCharsAndNostrPrefix() {
+        val result = parseDirtyWordForKey("nOstr:npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z,")
+        assertEquals("npub", result?.type)
+        assertEquals("460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", result?.keyHex)
+        assertEquals(",", result?.restOfWord)
+    }
+}
@@ -6,27 +6,27 @@ import org.junit.Assert.assertEquals
 import org.junit.Test

 class NIP19ParserTest {
-  @Test
-  fun nAddrParser() {
-    val result = Nip19().uriToRoute("nostr:naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus")
-    assertEquals("30023:460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c:", result?.hex)
-  }
+    @Test
+    fun nAddrParser() {
+        val result = Nip19().uriToRoute("nostr:naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus")
+        assertEquals("30023:460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c:", result?.hex)
+    }

-  @Test
-  fun nAddrParser2() {
-    val result = Nip19().uriToRoute("nostr:naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8")
-    assertEquals("30023:d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c:guide-wireguard", result?.hex)
-  }
+    @Test
+    fun nAddrParser2() {
+        val result = Nip19().uriToRoute("nostr:naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8")
+        assertEquals("30023:d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c:guide-wireguard", result?.hex)
+    }

-  @Test
-  fun nAddrFormatter() {
-    val address = ATag(30023, "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", "" )
-    assertEquals("naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus", address.toNAddr())
-  }
+    @Test
+    fun nAddrFormatter() {
+        val address = ATag(30023, "460c25e682fda7832b52d1f22d3d22b3176d972f60dcdc3212ed8c92ef85065c", "")
+        assertEquals("naddr1qqqqygzxpsj7dqha57pjk5k37gkn6g4nzakewtmqmnwryyhd3jfwlpgxtspsgqqqw4rs3xyxus", address.toNAddr())
+    }

-  @Test
-  fun nAddrFormatter2() {
-    val address = ATag(30023, "d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c", "guide-wireguard" )
-    assertEquals("naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8", address.toNAddr())
-  }
-}
+    @Test
+    fun nAddrFormatter2() {
+        val address = ATag(30023, "d0debf9fb12def81f43d7c69429bb784812ac1e4d2d53a202db6aac7ea4b466c", "guide-wireguard")
+        assertEquals("naddr1qq8kwatfv3jj6amfwfjkwatpwfjqygxsm6lelvfda7qlg0tud9pfhduysy4vrexj65azqtdk4tr75j6xdspsgqqqw4rsg32ag8", address.toNAddr())
+    }
+}
@@ -6,104 +6,104 @@ import org.junit.Test

 class Nip19Test {

-  private val nip19 = Nip19();
+    private val nip19 = Nip19()

-  @Test(expected = IllegalArgumentException::class)
-  fun to_int_32_length_smaller_than_4() {
-    toInt32(byteArrayOfInts(1, 2, 3))
-  }
+    @Test(expected = IllegalArgumentException::class)
+    fun to_int_32_length_smaller_than_4() {
+        toInt32(byteArrayOfInts(1, 2, 3))
+    }

-  @Test(expected = IllegalArgumentException::class)
-  fun to_int_32_length_bigger_than_4() {
-    toInt32(byteArrayOfInts(1, 2, 3, 4, 5))
-  }
+    @Test(expected = IllegalArgumentException::class)
+    fun to_int_32_length_bigger_than_4() {
+        toInt32(byteArrayOfInts(1, 2, 3, 4, 5))
+    }

-  @Test()
-  fun to_int_32_length_4() {
-    val actual = toInt32(byteArrayOfInts(1, 2, 3, 4))
+    @Test()
+    fun to_int_32_length_4() {
+        val actual = toInt32(byteArrayOfInts(1, 2, 3, 4))

-    Assert.assertEquals(16909060, actual)
-  }
+        Assert.assertEquals(16909060, actual)
+    }

-  @Ignore("Test not implemented yet")
-  @Test()
-  fun parse_TLV() {
-    // TODO: I don't know how to test this (?)
-  }
+    @Ignore("Test not implemented yet")
+    @Test()
+    fun parse_TLV() {
+        // TODO: I don't know how to test this (?)
+    }

-  @Test()
-  fun uri_to_route_null() {
-    val actual = nip19.uriToRoute(null)
+    @Test()
+    fun uri_to_route_null() {
+        val actual = nip19.uriToRoute(null)

-    Assert.assertEquals(null, actual)
-  }
+        Assert.assertEquals(null, actual)
+    }

-  @Test()
-  fun uri_to_route_unknown() {
-    val actual = nip19.uriToRoute("nostr:unknown")
+    @Test()
+    fun uri_to_route_unknown() {
+        val actual = nip19.uriToRoute("nostr:unknown")

-    Assert.assertEquals(null, actual)
-  }
+        Assert.assertEquals(null, actual)
+    }

-  @Test()
-  fun uri_to_route_npub() {
-    val actual =
-      nip19.uriToRoute("nostr:npub1hv7k2s755n697sptva8vkh9jz40lzfzklnwj6ekewfmxp5crwdjs27007y")
+    @Test()
+    fun uri_to_route_npub() {
+        val actual =
+            nip19.uriToRoute("nostr:npub1hv7k2s755n697sptva8vkh9jz40lzfzklnwj6ekewfmxp5crwdjs27007y")

-    Assert.assertEquals(Nip19.Type.USER, actual?.type)
-    Assert.assertEquals(
-      "bb3d6543d4a4f45f402b674ecb5cb2155ff12456fcdd2d66d9727660d3037365",
-      actual?.hex
-    )
-  }
+        Assert.assertEquals(Nip19.Type.USER, actual?.type)
+        Assert.assertEquals(
+            "bb3d6543d4a4f45f402b674ecb5cb2155ff12456fcdd2d66d9727660d3037365",
+            actual?.hex
+        )
+    }

-  @Test()
-  fun uri_to_route_note() {
-    val actual =
-      nip19.uriToRoute("nostr:note1stqea6wmwezg9x6yyr6qkukw95ewtdukyaztycws65l8wppjmtpscawevv")
+    @Test()
+    fun uri_to_route_note() {
+        val actual =
+            nip19.uriToRoute("nostr:note1stqea6wmwezg9x6yyr6qkukw95ewtdukyaztycws65l8wppjmtpscawevv")

-    Assert.assertEquals(Nip19.Type.NOTE, actual?.type)
-    Assert.assertEquals(
-      "82c19ee9db7644829b4420f40b72ce2d32e5b7962744b261d0d53e770432dac3",
-      actual?.hex
-    )
-  }
+        Assert.assertEquals(Nip19.Type.NOTE, actual?.type)
+        Assert.assertEquals(
+            "82c19ee9db7644829b4420f40b72ce2d32e5b7962744b261d0d53e770432dac3",
+            actual?.hex
+        )
+    }

-  @Ignore("Test not implemented yet")
-  @Test()
-  fun uri_to_route_nprofile() {
-    val actual = nip19.uriToRoute("nostr:nprofile")
+    @Ignore("Test not implemented yet")
+    @Test()
+    fun uri_to_route_nprofile() {
+        val actual = nip19.uriToRoute("nostr:nprofile")

-    Assert.assertEquals(Nip19.Type.USER, actual?.type)
-    Assert.assertEquals("*", actual?.hex)
-  }
+        Assert.assertEquals(Nip19.Type.USER, actual?.type)
+        Assert.assertEquals("*", actual?.hex)
+    }

-  @Ignore("Test not implemented yet")
-  @Test()
-  fun uri_to_route_nevent() {
-    val actual = nip19.uriToRoute("nostr:nevent")
+    @Ignore("Test not implemented yet")
+    @Test()
+    fun uri_to_route_nevent() {
+        val actual = nip19.uriToRoute("nostr:nevent")

-    Assert.assertEquals(Nip19.Type.USER, actual?.type)
-    Assert.assertEquals("*", actual?.hex)
-  }
+        Assert.assertEquals(Nip19.Type.USER, actual?.type)
+        Assert.assertEquals("*", actual?.hex)
+    }

-  @Ignore("Test not implemented yet")
-  @Test()
-  fun uri_to_route_nrelay() {
-    val actual = nip19.uriToRoute("nostr:nrelay")
+    @Ignore("Test not implemented yet")
+    @Test()
+    fun uri_to_route_nrelay() {
+        val actual = nip19.uriToRoute("nostr:nrelay")

-    Assert.assertEquals(Nip19.Type.RELAY, actual?.type)
-    Assert.assertEquals("*", actual?.hex)
-  }
+        Assert.assertEquals(Nip19.Type.RELAY, actual?.type)
+        Assert.assertEquals("*", actual?.hex)
+    }

-  @Ignore("Test not implemented yet")
-  @Test()
-  fun uri_to_route_naddr() {
-    val actual = nip19.uriToRoute("nostr:naddr")
+    @Ignore("Test not implemented yet")
+    @Test()
+    fun uri_to_route_naddr() {
+        val actual = nip19.uriToRoute("nostr:naddr")

-    Assert.assertEquals(Nip19.Type.ADDRESS, actual?.type)
-    Assert.assertEquals("*", actual?.hex)
-  }
+        Assert.assertEquals(Nip19.Type.ADDRESS, actual?.type)
+        Assert.assertEquals("*", actual?.hex)
+    }

-  private fun byteArrayOfInts(vararg ints: Int) = ByteArray(ints.size) { pos -> ints[pos].toByte() }
+    private fun byteArrayOfInts(vararg ints: Int) = ByteArray(ints.size) { pos -> ints[pos].toByte() }
 }
@@ -11,46 +11,45 @@ import org.junit.Test
 import java.math.BigDecimal

 class UserZapsTest {
-  @Test
-  fun nothing() {
-    Assert.assertEquals(1, 1)
-  }
+    @Test
+    fun nothing() {
+        Assert.assertEquals(1, 1)
+    }

-  @Test
-  fun user_without_zaps() {
-    val actual = UserZaps.forProfileFeed(zaps = null)
+    @Test
+    fun user_without_zaps() {
+        val actual = UserZaps.forProfileFeed(zaps = null)

-    Assert.assertEquals(emptyList<Pair<Note, Note>>(), actual)
-  }
+        Assert.assertEquals(emptyList<Pair<Note, Note>>(), actual)
+    }

-  @Test
-  fun avoid_duplicates_with_same_zap_request() {
-    val zapRequest = mockk<Note>()
+    @Test
+    fun avoid_duplicates_with_same_zap_request() {
+        val zapRequest = mockk<Note>()

-    val zaps: Map<Note, Note?> = mapOf(
-      zapRequest to mockZapNoteWith("user-1", amount = 100),
-      zapRequest to mockZapNoteWith("user-1", amount = 200),
-    )
+        val zaps: Map<Note, Note?> = mapOf(
+            zapRequest to mockZapNoteWith("user-1", amount = 100),
+            zapRequest to mockZapNoteWith("user-1", amount = 200)
+        )

-    val actual = UserZaps.forProfileFeed(zaps)
+        val actual = UserZaps.forProfileFeed(zaps)

-    Assert.assertEquals(1, actual.count())
-    Assert.assertEquals(zapRequest, actual.first().first)
-    Assert.assertEquals(
-      BigDecimal(200),
-      (actual.first().second.event as LnZapEventInterface).amount()
-    )
-  }
+        Assert.assertEquals(1, actual.count())
+        Assert.assertEquals(zapRequest, actual.first().first)
+        Assert.assertEquals(
+            BigDecimal(200),
+            (actual.first().second.event as LnZapEventInterface).amount()
+        )
+    }

-  private fun mockZapNoteWith(pubkey: HexKey, amount: Int): Note {
+    private fun mockZapNoteWith(pubkey: HexKey, amount: Int): Note {
+        val lnZapEvent = mockk<LnZapEventInterface>()
+        every { lnZapEvent.amount() } returns amount.toBigDecimal()
+        every { lnZapEvent.pubKey() } returns pubkey

-    val lnZapEvent = mockk<LnZapEventInterface>()
-    every { lnZapEvent.amount() } returns amount.toBigDecimal()
-    every { lnZapEvent.pubKey() } returns pubkey
+        val zapNote = mockk<Note>()
+        every { zapNote.event } returns lnZapEvent

-    val zapNote = mockk<Note>()
-    every { zapNote.event } returns lnZapEvent
-
-    return zapNote
-  }
+        return zapNote
+    }
 }