move non-implicit methods to companion object for easier testing

Author: phelps-sg

openai-client/src/main/scala/io/cequence/openaiscala/RetryHelpers.scala

@@ -3,13 +3,49 @@ package io.cequence.openaiscala
 import akka.actor.{ActorSystem, Scheduler}
 import akka.pattern.after
 import akka.stream.Materializer
-import io.cequence.openaiscala.RetryHelpers.RetrySettings
+import io.cequence.openaiscala.RetryHelpers.{RetrySettings, retry}
 
 import scala.concurrent.duration.{DurationInt, FiniteDuration}
 import scala.concurrent.{ExecutionContext, Future}
 import scala.util.control.NonFatal
 
 object RetryHelpers {
+  private[openaiscala] def delay(
+      n: Integer
+  )(implicit retrySettings: RetrySettings): FiniteDuration =
+    FiniteDuration(
+      scala.math.round(
+        retrySettings.delayOffset.length + scala.math.pow(
+          retrySettings.delayBase,
+          n.doubleValue()
+        )
+      ),
+      retrySettings.delayOffset.unit
+    )
+
+  private[openaiscala] def retry[T](
+      attempt: () => Future[T],
+      attempts: Int
+  )(implicit
+      ec: ExecutionContext,
+      scheduler: Scheduler,
+      retrySettings: RetrySettings
+  ): Future[T] = {
+    try {
+      if (attempts > 0) {
+        attempt().recoverWith { case Retryable(_) =>
+          after(delay(attempts), scheduler) {
+            retry(attempt, attempts - 1)
+          }
+        }
+      } else {
+        attempt()
+      }
+    } catch {
+      case NonFatal(error) => Future.failed(error)
+    }
+  }
+
   final case class RetrySettings(
       maxRetries: Int = 5,
       delayOffset: FiniteDuration = 2.seconds,
@@ -18,13 +54,15 @@ object RetryHelpers {
     def constantInterval(interval: FiniteDuration): RetrySettings =
       copy(delayBase = 0).copy(delayOffset = interval)
   }
+
   object RetrySettings {
     def apply(interval: FiniteDuration): RetrySettings =
       RetrySettings().constantInterval(
         interval
       )
 
   }
+
 }
 
 trait RetryHelpers {
@@ -41,42 +79,6 @@ trait RetryHelpers {
     ): Future[T] = {
       retry(() => f, retrySettings.maxRetries)
     }
-
-    private[openaiscala] def delay(
-        n: Integer
-    )(implicit retrySettings: RetrySettings): FiniteDuration =
-      FiniteDuration(
-        scala.math.round(
-          retrySettings.delayOffset.length + scala.math.pow(
-            retrySettings.delayBase,
-            n.doubleValue()
-          )
-        ),
-        retrySettings.delayOffset.unit
-      )
-
-    private[openaiscala] def retry(
-        attempt: () => Future[T],
-        attempts: Int
-    )(implicit
-        ec: ExecutionContext,
-        scheduler: Scheduler,
-        retrySettings: RetrySettings
-    ): Future[T] = {
-      try {
-        if (attempts > 0) {
-          attempt().recoverWith { case Retryable(_) =>
-            after(delay(attempts), scheduler) {
-              retry(attempt, attempts - 1)
-            }
-          }
-        } else {
-          attempt()
-        }
-      } catch {
-        case NonFatal(error) => Future.failed(error)
-      }
-    }
-
   }
+
 }

openai-client/src/test/scala/io/cequence/openaiscala/RetryHelpersSpec.scala

@@ -2,7 +2,7 @@ package io.cequence.openaiscala
 
 import akka.actor.{ActorSystem, Scheduler}
 import akka.testkit.TestKit
-import io.cequence.openaiscala.RetryHelpers.RetrySettings
+import io.cequence.openaiscala.RetryHelpers.{RetrySettings, retry}
 import org.mockito.scalatest.MockitoSugar
 import org.scalatest.RecoverMethods._
 import org.scalatest.concurrent.ScalaFutures
@@ -111,7 +111,7 @@ class RetryHelpersSpec
     val mockRetryable = mock[Retryable]
     when(mockRetryable.attempt())
       .thenReturn(results.head, results.takeRight(results.length - 1): _*)
-    val result = future.retry(() => mockRetryable.attempt(), attempts)
+    val result = retry(() => mockRetryable.attempt(), attempts)
     test(mockRetryable, result)
   }