src/test/kotlin/net/pterodactylus/rhynodge/queries/FallbackQueryTest.kt

   1 package net.pterodactylus.rhynodge.queries
   2
   3 import net.pterodactylus.rhynodge.Query
   4 import net.pterodactylus.rhynodge.State
   5 import net.pterodactylus.rhynodge.states.AbstractState
   6 import net.pterodactylus.rhynodge.states.FailedState
   7 import org.hamcrest.MatcherAssert.assertThat
   8 import org.hamcrest.Matchers.`is`
   9 import org.hamcrest.Matchers.sameInstance
  10 import org.junit.Rule
  11 import org.junit.Test
  12 import org.junit.rules.ExpectedException
  13 import org.mockito.Mockito.`when`
  14 import org.mockito.Mockito.mock
  15 import org.mockito.Mockito.never
  16 import org.mockito.Mockito.verify
  17
  18 /**
  19  * Unit test for [FallbackQuery].
  20  *
  21  * @author [David ‘Bombe’ Roden](mailto:bombe@pterodactylus.net)
  22  */
  23 class FallbackQueryTest {
  24
  25         @JvmField @Rule val expectedException = ExpectedException.none()!!
  26
  27         private val firstQuery = mock(Query::class.java)
  28         private val secondQuery = mock(Query::class.java)
  29         private val thirdQuery = mock(Query::class.java)
  30         private val query = FallbackQuery(firstQuery, secondQuery, thirdQuery)
  31
  32         private fun setupQueries(firstState: State = FailedState(), secondState: State = FailedState(), thirdState: State = FailedState()) {
  33                 `when`(firstQuery.state()).thenReturn(firstState)
  34                 `when`(secondQuery.state()).thenReturn(secondState)
  35                 `when`(thirdQuery.state()).thenReturn(thirdState)
  36         }
  37
  38         @Test
  39         fun `fallback query returns state of third query`() {
  40                 val successState: AbstractState = object : AbstractState() {}
  41                 setupQueries(thirdState = successState)
  42                 assertThat(query.state(), sameInstance<State>(successState))
  43         }
  44
  45         @Test
  46         fun `fallback query calls all three queries`() {
  47                 val successState: AbstractState = object : AbstractState() {}
  48                 setupQueries(thirdState = successState)
  49                 query.state()
  50                 verify(firstQuery).state()
  51                 verify(secondQuery).state()
  52                 verify(thirdQuery).state()
  53         }
  54
  55         @Test
  56         fun `fallback query returns second state`() {
  57                 val successState: AbstractState = object : AbstractState() {}
  58                 setupQueries(secondState = successState)
  59                 assertThat(query.state(), sameInstance<State>(successState))
  60         }
  61
  62         @Test
  63         fun `fallback query does not query third query`() {
  64                 val successState: AbstractState = object : AbstractState() {}
  65                 setupQueries(secondState = successState)
  66                 query.state()
  67                 verify(firstQuery).state()
  68                 verify(secondQuery).state()
  69                 verify(thirdQuery, never()).state()
  70         }
  71
  72         @Test
  73         fun `fallback query returns first state`() {
  74                 val successState: AbstractState = object : AbstractState() {}
  75                 setupQueries(firstState = successState)
  76                 assertThat(query.state(), sameInstance<State>(successState))
  77         }
  78
  79         @Test
  80         fun `fallback query does not query second and third query`() {
  81                 val successState: AbstractState = object : AbstractState() {}
  82                 setupQueries(firstState = successState)
  83                 query.state()
  84                 verify(firstQuery).state()
  85                 verify(secondQuery, never()).state()
  86                 verify(thirdQuery, never()).state()
  87         }
  88
  89         @Test
  90         fun `fallback query returns failed state if no query succeeds`() {
  91                 setupQueries()
  92                 assertThat(query.state().success(), `is`(false))
  93         }
  94
  95         @Test
  96         fun `fallback query can not be created without queries`() {
  97                 expectedException.expect(IllegalArgumentException::class.java)
  98                 FallbackQuery()
  99         }
 100
 101 }