src/test/kotlin/net/pterodactylus/sone/core/SoneChangeCollectorTest.kt

   1 package net.pterodactylus.sone.core
   2
   3 import net.pterodactylus.sone.data.Post
   4 import net.pterodactylus.sone.data.PostReply
   5 import net.pterodactylus.sone.data.Sone
   6 import net.pterodactylus.sone.test.mock
   7 import net.pterodactylus.sone.test.whenever
   8 import org.hamcrest.MatcherAssert.assertThat
   9 import org.hamcrest.Matchers.containsInAnyOrder
  10 import org.hamcrest.Matchers.emptyIterable
  11 import org.hamcrest.Matchers.equalTo
  12 import org.junit.Test
  13 import java.util.concurrent.atomic.AtomicInteger
  14
  15 /**
  16  * Unit test for [SoneChangeCollectorTest].
  17  */
  18 class SoneChangeCollectorTest {
  19
  20         private val oldSone = mock<Sone>()
  21         private val newSone = mock<Sone>()
  22         private val changeCollector = SoneChangeCollector(oldSone)
  23
  24         @Test
  25         fun `new posts are correctly turned into events`() {
  26                 val posts = listOf(mock<Post>(), mock(), mock())
  27                 whenever(newSone.posts).thenReturn(posts)
  28                 changeCollector.newPostEvent { it.takeIf { it != posts[1] } }
  29                 assertThat(changeCollector.detectChanges(newSone), containsInAnyOrder<Any>(posts[0], posts[2]))
  30         }
  31
  32         @Test
  33         fun `actions can be performed on new post without being returned`() {
  34                 val posts = listOf(mock<Post>(), mock(), mock())
  35                 val counter = AtomicInteger(0)
  36                 whenever(newSone.posts).thenReturn(posts.slice(0..2))
  37                 whenever(oldSone.posts).thenReturn(posts.slice(2..2))
  38                 changeCollector.onNewPost { counter.incrementAndGet() }
  39                 assertThat(changeCollector.detectChanges(newSone), emptyIterable())
  40                 assertThat(counter.get(), equalTo(2))
  41         }
  42
  43         @Test
  44         fun `removed posts are correctly turned into events`() {
  45                 val posts = listOf(mock<Post>(), mock(), mock())
  46                 whenever(oldSone.posts).thenReturn(posts)
  47                 changeCollector.removedPostEvent { it.takeIf { it != posts[1] } }
  48                 assertThat(changeCollector.detectChanges(newSone), containsInAnyOrder<Any>(posts[0], posts[2]))
  49         }
  50
  51         @Test
  52         fun `new post replies are correctly turned into events`() {
  53                 val postReplies = listOf(mock<PostReply>(), mock(), mock())
  54                 whenever(newSone.replies).thenReturn(postReplies.toSet())
  55                 changeCollector.newPostReplyEvent { it.takeIf { it != postReplies[1] } }
  56                 assertThat(changeCollector.detectChanges(newSone), containsInAnyOrder<Any>(postReplies[0], postReplies[2]))
  57         }
  58
  59         @Test
  60         fun `actions can be performed on new replies without being returned`() {
  61                 val replies = listOf(mock<PostReply>(), mock(), mock())
  62                 val counter = AtomicInteger(0)
  63                 whenever(newSone.replies).thenReturn(replies.slice(0..2).toSet())
  64                 whenever(oldSone.replies).thenReturn(replies.slice(2..2).toSet())
  65                 changeCollector.onNewPostReply { counter.incrementAndGet() }
  66                 assertThat(changeCollector.detectChanges(newSone), emptyIterable())
  67                 assertThat(counter.get(), equalTo(2))
  68         }
  69
  70         @Test
  71         fun `removed post replies are correctly turned into events`() {
  72                 val postReplies = listOf(mock<PostReply>(), mock(), mock())
  73                 whenever(oldSone.replies).thenReturn(postReplies.toSet())
  74                 changeCollector.onRemovedPostReply { it.takeIf { it != postReplies[1] } }
  75                 assertThat(changeCollector.detectChanges(newSone), containsInAnyOrder<Any>(postReplies[0], postReplies[2]))
  76         }
  77
  78 }