Coverage

Author: tobi-laa

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/ports/PortProvider.kt

@@ -7,12 +7,12 @@ import java.util.concurrent.ConcurrentSkipListSet
 /**
  * The default port used by Redis Sentinel.
  */
-private const val DEFAULT_SENTINEL_PORT: Int = 26379
+internal const val DEFAULT_SENTINEL_PORT: Int = 26379
 
 /**
  * This offset is used to calculate the port for the Redis cluster bus.
  */
-private const val BUS_PORT_OFFSET: Int = 10000
+internal const val BUS_PORT_OFFSET: Int = 10000
 
 /**
  * Is used for providing free ports for Redis instances.
@@ -26,25 +26,19 @@ internal class PortProvider {
      * @param sentinel If `true`, the next free port for a Redis Sentinel instance is provided.
      */
     fun next(sentinel: Boolean = false): Int {
-        return if (sentinel) {
-            next(DEFAULT_SENTINEL_PORT..REDIS_CLUSTER_MAX_PORT_EXCLUSIVE)
-        } else {
-            next(DEFAULT_REDIS_PORT..REDIS_CLUSTER_MAX_PORT_EXCLUSIVE)
-        }
-    }
-
-    private fun next(candidates: IntRange): Int {
-        for (candidate in candidates) {
-            if (portCanBeHandedOut(candidate) && handedOutPorts.add(candidate)) {
+        val minPort = if (sentinel) DEFAULT_SENTINEL_PORT else DEFAULT_REDIS_PORT
+        for (candidate in minPort until REDIS_CLUSTER_MAX_PORT_EXCLUSIVE + 1) {
+            val candidateBusPort = candidate + BUS_PORT_OFFSET
+            if (portCanBeHandedOut(candidate) && portCanBeHandedOut(candidateBusPort)) {
+                handedOutPorts.add(candidate)
+                handedOutPorts.add(candidateBusPort)
                 return candidate
             }
         }
         throw IllegalStateException("Could not find an available TCP port")
     }
 
     private fun portCanBeHandedOut(port: Int): Boolean {
-        val busPort = port + BUS_PORT_OFFSET
-        return !handedOutPorts.contains(port) && !handedOutPorts.contains(busPort) &&
-                PortChecker.available(port) && PortChecker.available(busPort)
+        return !handedOutPorts.contains(port) && PortChecker.available(port)
     }
 }

src/test/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/ports/PortProviderTest.kt

@@ -6,11 +6,13 @@ import io.mockk.mockkObject
 import io.mockk.unmockkObject
 import org.assertj.core.api.AbstractIntegerAssert
 import org.assertj.core.api.Assertions.*
+import org.assertj.core.api.ListAssert
 import org.assertj.core.api.ThrowableAssert
 import org.junit.jupiter.api.*
 import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.ValueSource
+import redis.embedded.Redis.DEFAULT_REDIS_PORT
 import java.util.stream.IntStream.range
 
 @ExtendWith(MockKExtension::class)
@@ -77,13 +79,31 @@ internal class PortProviderTest {
 
     @DisplayName("Multiple valid ports should be returned if all ports are free")
     @ParameterizedTest(name = "{0} valid ports should be returned")
-    @ValueSource(ints = [5, 10, 100, 10000])
+    @ValueSource(ints = [5, 10, 100])
     fun freePorts_requestingPorts_returnsValidPorts(nOfPorts: Int) {
         givenFreePorts()
         whenNextPortsAreRequested(nOfPorts)
         thenValidPortsAreReturned(nOfPorts)
     }
 
+    @Test
+    @DisplayName("If port 16379 (bus port) is taken, port 6379 should not be handed out")
+    fun defaultBusPortTaken_requestingPort_skipDefaultPort() {
+        givenFreePorts()
+        givenFirstBusPortTaken()
+        whenNextPortIsRequested()
+        thenValidPortIsReturned().isNotEqualTo(DEFAULT_REDIS_PORT)
+    }
+
+    @Test
+    @DisplayName("If a bus port has been handed out, the corresponding Redis port should not be handed out")
+    fun busPortHandedOut_requestingPort_skipPortWithHandedOutBusPort() {
+        givenFreePorts()
+        givenSentinelPortPreviouslyRequested()
+        whenNextPortsAreRequested(10000)
+        thenValidPortsAreReturned(10000).doesNotContain(DEFAULT_REDIS_PORT + BUS_PORT_OFFSET)
+    }
+
     private fun givenSentinel() {
         givenSentinel = true
     }
@@ -99,6 +119,16 @@ internal class PortProviderTest {
         every { PortChecker.available(any()) } returns false
     }
 
+    private fun givenFirstBusPortTaken() {
+        val firstBusPort = DEFAULT_REDIS_PORT + BUS_PORT_OFFSET
+        every { PortChecker.available(eq(firstBusPort)) } returns false
+        every { PortChecker.available(neq(firstBusPort)) } returns true
+    }
+
+    private fun givenSentinelPortPreviouslyRequested() {
+        portProvider.next(true)
+    }
+
     private fun whenNextPortIsRequested() = whenNextPortsAreRequested(1)
 
     private fun whenNextPortsAreRequested(nOfPorts: Int) {
@@ -118,7 +148,7 @@ internal class PortProviderTest {
         return assertThat(actualPorts.first())
     }
 
-    private fun thenValidPortsAreReturned(nOfPorts: Int) {
+    private fun thenValidPortsAreReturned(nOfPorts: Int): ListAssert<Int> {
         assertThatCode(requestPorts!!).doesNotThrowAnyException()
         assertThat(actualPorts).hasSize(nOfPorts)
         assertThat(actualPorts).isNotEmpty.doesNotHaveDuplicates()
@@ -129,5 +159,6 @@ internal class PortProviderTest {
         }
         // bus port should have been left free
         assertThat(actualPorts).allSatisfy { assertThat(actualPorts).doesNotContain(it + 10000) }
+        return assertThat(actualPorts)
     }
 }