Finished up channel tests

Author: Daniel Rees

src/test/kotlin/org/phoenixframework/ChannelTest.kt

@@ -8,25 +8,23 @@ import com.nhaarman.mockitokotlin2.never
 import com.nhaarman.mockitokotlin2.spy
 import com.nhaarman.mockitokotlin2.times
 import com.nhaarman.mockitokotlin2.verify
-import com.nhaarman.mockitokotlin2.verifyZeroInteractions
 import com.nhaarman.mockitokotlin2.whenever
+import okhttp3.OkHttpClient
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 import org.mockito.Mock
+import org.mockito.Mockito.verifyZeroInteractions
 import org.mockito.MockitoAnnotations
-import org.mockito.stubbing.Answer
 import org.phoenixframework.queue.ManualDispatchQueue
 import org.phoenixframework.utilities.getBindings
 
 class ChannelTest {
 
-  companion object {
-    const val DEFAULT_REF = "1"
-    const val DEFAULT_TIMEOUT = 10_000L
-  }
+
+  @Mock lateinit var okHttpClient: OkHttpClient
 
   @Mock lateinit var socket: Socket
   @Mock lateinit var mockCallback: ((Message) -> Unit)
@@ -39,17 +37,10 @@ class ChannelTest {
   lateinit var fakeClock: ManualDispatchQueue
   lateinit var channel: Channel
 
-  var mutableRef = 0
-  var mutableRefAnswer: Answer<String> = Answer {
-    mutableRef += 1
-    mutableRef.toString()
-  }
-
   @BeforeEach
   internal fun setUp() {
     MockitoAnnotations.initMocks(this)
 
-    mutableRef = 0
     fakeClock = ManualDispatchQueue()
 
     whenever(socket.dispatchQueue).thenReturn(fakeClock)
@@ -164,7 +155,7 @@ class ChannelTest {
 
     @BeforeEach
     internal fun setUp() {
-      socket = spy(Socket("https://localhost:4000/socket"))
+      socket = spy(Socket(url ="https://localhost:4000/socket", client = okHttpClient))
       socket.dispatchQueue = fakeClock
       channel = Channel("topic", kDefaultPayload, socket)
     }
@@ -260,56 +251,22 @@ class ChannelTest {
 
         channel.join().receive("timeout", mockCallback)
 
-        verify(socket, times(1)).push(any(), any(), any(), any(), any())
+        verify(socket, times(1)).push(any(), eq("phx_join"), any(), any(), any())
         verify(mockCallback, never()).invoke(any())
 
         fakeClock.tick(timeout) // leave pushed to server
-        verify(socket, times(2)).push(any(), any(), any(), any(), any())
+        verify(socket, times(1)).push(any(), eq("phx_leave"), any(), any(), any())
         verify(mockCallback, times(1)).invoke(any())
 
-        fakeClock.tick(timeout + 1000) // leave + rejoin
-        verify(socket, times(4)).push(any(), any(), any(), any(), any())
+        fakeClock.tick(timeout + 1000) // rejoin
+        verify(socket, times(2)).push(any(), eq("phx_join"), any(), any(), any())
+        verify(socket, times(2)).push(any(), eq("phx_leave"), any(), any(), any())
         verify(mockCallback, times(2)).invoke(any())
 
         fakeClock.tick(10_000)
         joinPush.trigger("ok", kEmptyPayload)
-        verify(socket, times(6)).push(any(), any(), any(), any(), any())
+        verify(socket, times(3)).push(any(), eq("phx_join"), any(), any(), any())
         assertThat(channel.state).isEqualTo(Channel.State.JOINED)
-
-//        var ref = 0
-//        whenever(socket.isConnected).thenReturn(true)
-//        whenever(socket.makeRef()).thenAnswer {
-//          ref += 1
-//          ref.toString()
-//        }
-//
-//        val joinPush = channel.joinPush
-//        val timeout = channel.timeout
-//
-//        channel.join()
-//        verify(socket, times(1)).push(any(), any(), any(), any(), any())
-//
-//        fakeClock.tick(timeout) // leave push sent to the server
-//        verify(socket, times(2)).push(any(), any(), any(), any(), any())
-//
-//        fakeClock.tick(1_000) // begin stepped backoff
-//        verify(socket, times(3)).push(any(), any(), any(), any(), any())
-//
-//        fakeClock.tick(2_000)
-//        verify(socket, times(4)).push(any(), any(), any(), any(), any())
-//
-//        fakeClock.tick(5_000)
-//        verify(socket, times(5)).push(any(), any(), any(), any(), any())
-//
-//        fakeClock.tick(10_000)
-//        verify(socket, times(6)).push(any(), any(), any(), any(), any())
-//
-//        joinPush.trigger("ok", kEmptyPayload)
-//        assertThat(channel.state).isEqualTo(Channel.State.JOINED)
-//
-//        fakeClock.tick(10_000)
-//        verify(socket, times(6)).push(any(), any(), any(), any(), any())
-//        assertThat(channel.state).isEqualTo(Channel.State.JOINED)
       }
 
       @Test

src/test/kotlin/org/phoenixframework/DefaultsTest.kt

@@ -1,5 +1,45 @@
 package org.phoenixframework
 
-import org.junit.jupiter.api.Assertions.*
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
 
-internal class DefaultsTest
+internal class DefaultsTest {
+
+  @Test
+  internal fun `default timeout is 10_000`() {
+    assertThat(Defaults.TIMEOUT).isEqualTo(10_000)
+  }
+
+  @Test
+  internal fun `default heartbeat is 30_000`() {
+    assertThat(Defaults.HEARTBEAT).isEqualTo(30_000)
+  }
+
+  @Test
+  internal fun `default reconnectAfterMs returns all values`() {
+    val reconnect = Defaults.reconnectSteppedBackOff
+
+    assertThat(reconnect(1)).isEqualTo(10)
+    assertThat(reconnect(2)).isEqualTo(50)
+    assertThat(reconnect(3)).isEqualTo(100)
+    assertThat(reconnect(4)).isEqualTo(150)
+    assertThat(reconnect(5)).isEqualTo(200)
+    assertThat(reconnect(6)).isEqualTo(250)
+    assertThat(reconnect(7)).isEqualTo(500)
+    assertThat(reconnect(8)).isEqualTo(1_000)
+    assertThat(reconnect(9)).isEqualTo(2_000)
+    assertThat(reconnect(10)).isEqualTo(5_000)
+    assertThat(reconnect(11)).isEqualTo(5_000)
+  }
+
+  @Test
+  internal fun `default rejoinAfterMs returns all values`() {
+    val reconnect = Defaults.rejoinSteppedBackOff
+
+    assertThat(reconnect(1)).isEqualTo(1_000)
+    assertThat(reconnect(2)).isEqualTo(2_000)
+    assertThat(reconnect(3)).isEqualTo(5_000)
+    assertThat(reconnect(4)).isEqualTo(10_000)
+    assertThat(reconnect(5)).isEqualTo(10_000)
+  }
+}