⚡️ Use shell to store reply data

[Sone.git] / src / test / kotlin / net / pterodactylus / sone / database / memory / MemoryDatabaseTest.kt

diff --git a/src/test/kotlin/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.kt b/src/test/kotlin/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.kt
index 4d7a105..6e9b31a 100644 (file)
--- a/src/test/kotlin/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.kt
+++ b/src/test/kotlin/net/pterodactylus/sone/database/memory/MemoryDatabaseTest.kt
@@ -1,5 +1,5 @@
 /*
- * Sone - MemoryDatabaseTest.kt - Copyright © 2013–2019 David Roden
+ * Sone - MemoryDatabaseTest.kt - Copyright © 2013–2020 David Roden
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,6 +25,7 @@ import net.pterodactylus.sone.test.*
 import net.pterodactylus.sone.test.Matchers.*
 import net.pterodactylus.util.config.*
 import org.hamcrest.MatcherAssert.*
+import org.hamcrest.Matchers
 import org.hamcrest.Matchers.*
 import org.mockito.ArgumentMatchers.anyString
 import org.mockito.Mockito.*
@@ -50,15 +51,15 @@ class MemoryDatabaseTest {
        @Test
        fun `stored sone is made available`() {
                storeSone()
-               assertThat(memoryDatabase.getPost("post1"), isPost("post1", 1000L, "post1", absent()))
-               assertThat(memoryDatabase.getPost("post2"), isPost("post2", 2000L, "post2", of(RECIPIENT_ID)))
+               assertThat(memoryDatabase.getPost("post1"), isPost("post1", 1000L, "post1", null))
+               assertThat(memoryDatabase.getPost("post2"), isPost("post2", 2000L, "post2", RECIPIENT_ID))
                assertThat(memoryDatabase.getPost("post3"), nullValue())
                assertThat(memoryDatabase.getPostReply("reply1"), isPostReply("reply1", "post1", 3000L, "reply1"))
                assertThat(memoryDatabase.getPostReply("reply2"), isPostReply("reply2", "post2", 4000L, "reply2"))
                assertThat(memoryDatabase.getPostReply("reply3"), isPostReply("reply3", "post1", 5000L, "reply3"))
                assertThat(memoryDatabase.getPostReply("reply4"), nullValue())
-               assertThat(memoryDatabase.getAlbum("album1"), isAlbum("album1", null, "album1", "album-description1"))
-               assertThat(memoryDatabase.getAlbum("album2"), isAlbum("album2", null, "album2", "album-description2"))
+               assertThat(memoryDatabase.getAlbum("album1"), isAlbum("album1", "root", "album1", "album-description1"))
+               assertThat(memoryDatabase.getAlbum("album2"), isAlbum("album2", "root", "album2", "album-description2"))
                assertThat(memoryDatabase.getAlbum("album3"), isAlbum("album3", "album1", "album3", "album-description3"))
                assertThat(memoryDatabase.getAlbum("album4"), nullValue())
                assertThat(memoryDatabase.getImage("image1"), isImage("image1", 1000L, "KSK@image1", "image1", "image-description1", 16, 9))
@@ -123,9 +124,10 @@ class MemoryDatabaseTest {
                                .setDescription("album-description3")
                                .update()
                firstAlbum.addAlbum(thirdAlbum)
-               val rootAlbum = mock<Album>()
-               whenever(rootAlbum.id).thenReturn("root")
-               whenever(rootAlbum.albums).thenReturn(listOf(firstAlbum, secondAlbum))
+               val rootAlbum = AlbumImpl(sone, "root").also {
+                       it.addAlbum(firstAlbum)
+                       it.addAlbum(secondAlbum)
+               }
                whenever(sone.rootAlbum).thenReturn(rootAlbum)
                val firstImage = TestImageBuilder().withId("image1")
                                .build()
@@ -193,27 +195,17 @@ class MemoryDatabaseTest {
        @Test
        fun `post replies are managed correctly`() {
                val firstPost = createPost(absent())
-               val firstPostFirstReply = createPostReply(firstPost, 1000L)
+               val firstPostFirstReply = createPostReply(id = "p1r1", post = firstPost, time = 1000L)
                val secondPost = createPost(absent())
-               val secondPostFirstReply = createPostReply(secondPost, 1000L)
-               val secondPostSecondReply = createPostReply(secondPost, 2000L)
+               val secondPostFirstReply = createPostReply(id = "p2r1", post = secondPost, time = 1000L)
+               val secondPostSecondReply = createPostReply(id = "p2r2", post = secondPost, time = 2000L)
                memoryDatabase.storePost(firstPost)
                memoryDatabase.storePost(secondPost)
                memoryDatabase.storePostReply(firstPostFirstReply)
                memoryDatabase.storePostReply(secondPostFirstReply)
                memoryDatabase.storePostReply(secondPostSecondReply)
-               assertThat(memoryDatabase.getReplies(firstPost.id), contains(firstPostFirstReply))
-               assertThat(memoryDatabase.getReplies(secondPost.id), contains(secondPostFirstReply, secondPostSecondReply))
-       }
-
-       private fun createPostReply(post: Post, time: Long): PostReply {
-               val postReply = mock<PostReply>()
-               whenever(postReply.id).thenReturn(randomUUID().toString())
-               whenever(postReply.time).thenReturn(time)
-               whenever(postReply.post).thenReturn(of(post))
-               val postId = post.id
-               whenever(postReply.postId).thenReturn(postId)
-               return postReply
+               assertThat(memoryDatabase.getReplies(firstPost.id).map(PostReply::id), Matchers.contains("p1r1"))
+               assertThat(memoryDatabase.getReplies(secondPost.id).map(PostReply::id), contains("p2r1", "p2r2"))
        }
 
        @Test
@@ -404,7 +396,7 @@ class MemoryDatabaseTest {
                prepareConfigurationValues()
                val postReply = mock<PostReply>()
                whenever(postReply.id).thenReturn("post-reply-id")
-               memoryDatabase.setPostReplyKnown(postReply, true)
+               memoryDatabase.setPostReplyKnown(postReply)
                assertThat(configuration.getStringValue("KnownReplies/0/ID").value, equalTo("post-reply-id"))
                assertThat(configuration.getStringValue("KnownReplies/1/ID").value, equalTo<Any>(null))
        }
@@ -417,6 +409,28 @@ class MemoryDatabaseTest {
                verify(configuration.getStringValue("KnownPosts/0/ID"), times(1)).value = null
        }
 
+       @Test
+       @Dirty("the rate limiter should be mocked")
+       fun `setting posts as knows twice in a row only saves the database once`() {
+               prepareConfigurationValues()
+               val post = mock<Post>()
+               whenever(post.id).thenReturn("post-id")
+               memoryDatabase.setPostKnown(post, true)
+               memoryDatabase.setPostKnown(post, true)
+               verify(configuration, times(1)).getStringValue("KnownPosts/1/ID")
+       }
+
+       @Test
+       @Dirty("the rate limiter should be mocked")
+       fun `setting post replies as knows twice in a row only saves the database once`() {
+               prepareConfigurationValues()
+               val postReply = mock<PostReply>()
+               whenever(postReply.id).thenReturn("post-reply-id")
+               memoryDatabase.setPostReplyKnown(postReply)
+               memoryDatabase.setPostReplyKnown(postReply)
+               verify(configuration, times(1)).getStringValue("KnownReplies/1/ID")
+       }
+
 }
 
 private const val SONE_ID = "sone"