Exploratory commit to rough out what could constitute a useful test

I don't like this strategy, but I'm interested to see what codecov (and others) think about this approach.
I've basically just reimplemented the business logic in the test, but short of mocking out the whole git repo
in order to extract state, I'm not sure how best to represent what I'm trying to test.

Author: Devon Stewart

modules/core/src/main/scala/org/scalasteward/core/nurture/NurtureAlg.scala

@@ -155,29 +155,18 @@ final class NurtureAlg[F[_]](config: Config)(implicit
       gitAlg.removeBranch(repo, branch)
     }
 
-  def ensureDistinctBranch(
-      data: UpdateData,
-      seenBranches: Ref[F, List[Branch]],
-      whenDistinct: F[ProcessResult]
-  ): F[ProcessResult] =
-    seenBranches.get
-      .flatMap(_.forallM(gitAlg.diff(data.repo, _).map(_.nonEmpty)))
-      .ifM(
-        whenDistinct,
-        logger.warn("Discovered a duplicate branch, not pushing").as(Ignored)
-      )
-
   def applyNewUpdate(data: UpdateData, seenBranches: Ref[F, List[Branch]]): F[ProcessResult] =
     gitAlg.returnToCurrentBranch(data.repo) {
       val createBranch = logger.info(s"Create branch ${data.updateBranch.name}") >>
         gitAlg.createBranch(data.repo, data.updateBranch)
       editAlg.applyUpdate(data.repoData, data.update, createBranch).flatMap { editCommits =>
         if (editCommits.isEmpty) logger.warn("No commits created").as(Ignored)
         else
-          ensureDistinctBranch(
-            data,
+          NurtureAlg.ensureDistinctBranch(
             seenBranches,
-            pushCommits(data, editCommits) >> createPullRequest(data)
+            gitAlg.diff(data.repo, _).map(_.nonEmpty),
+            pushCommits(data, editCommits) >> createPullRequest(data),
+            logger.warn("Discovered a duplicate branch, not pushing").as[ProcessResult](Ignored)
           )
       }
     }
@@ -267,10 +256,11 @@ final class NurtureAlg[F[_]](config: Config)(implicit
       )
       maybeMergeCommit <- gitAlg.mergeTheirs(data.repo, data.baseBranch)
       editCommits <- editAlg.applyUpdate(data.repoData, data.update)
-      result <- ensureDistinctBranch(
-        data,
+      result <- NurtureAlg.ensureDistinctBranch(
         seenBranches,
-        pushCommits(data, maybeMergeCommit.toList ++ editCommits)
+        gitAlg.diff(data.repo, _).map(_.nonEmpty),
+        pushCommits(data, maybeMergeCommit.toList ++ editCommits),
+        logger.warn("Discovered a duplicate branch, not pushing").as[ProcessResult](Ignored)
       )
     } yield result
 }
@@ -295,4 +285,14 @@ object NurtureAlg {
           .compile
           .drain
     }
+
+  def ensureDistinctBranch[F[_]: Sync: cats.FlatMap](
+      seenBranches: Ref[F, List[Branch]],
+      isDistinct: Branch => F[Boolean],
+      whenDistinct: F[ProcessResult],
+      whenDuplicate: F[ProcessResult]
+  ): F[ProcessResult] =
+    seenBranches.get
+      .flatMap(_.forallM(isDistinct))
+      .ifM(whenDistinct, whenDuplicate)
 }

modules/core/src/test/scala/org/scalasteward/core/TestInstances.scala

@@ -9,7 +9,7 @@ import org.scalacheck.{Arbitrary, Cogen, Gen}
 import org.scalasteward.core.TestSyntax._
 import org.scalasteward.core.data.Update.Single
 import org.scalasteward.core.data._
-import org.scalasteward.core.git.Sha1
+import org.scalasteward.core.git.{Branch, Sha1}
 import org.scalasteward.core.git.Sha1.HexString
 import org.scalasteward.core.repocache.RepoCache
 import org.scalasteward.core.repoconfig.PullRequestFrequency.{Asap, Timespan}
@@ -59,6 +59,13 @@ object TestInstances {
       } yield Single(groupId % artifactId % currentVersion, Nel.one(newerVersion))
     )
 
+  implicit val branchArbitrary: Arbitrary[Branch] =
+    Arbitrary(
+      for {
+        name <- Gen.alphaStr
+      } yield Branch(name)
+    )
+
   private val hashGen: Gen[String] =
     for {
       sep <- Gen.oneOf('-', '+')

modules/core/src/test/scala/org/scalasteward/core/nurture/NurtureAlgTest.scala

@@ -1,13 +1,17 @@
 package org.scalasteward.core.nurture
 
+import cats.Applicative
 import cats.data.StateT
 import cats.effect.IO
+import cats.effect.concurrent.Ref
+import cats.syntax.all._
 import eu.timepit.refined.types.numeric.NonNegInt
 import munit.ScalaCheckSuite
 import org.scalacheck.Prop._
 import org.scalasteward.core.TestInstances._
 import org.scalasteward.core.data.ProcessResult.{Ignored, Updated}
 import org.scalasteward.core.data.{ProcessResult, Update}
+import org.scalasteward.core.git.Branch
 
 class NurtureAlgTest extends ScalaCheckSuite {
   test("processUpdates with No Limiting") {
@@ -42,4 +46,29 @@ class NurtureAlgTest extends ScalaCheckSuite {
       assertEquals(obtained, updates.size)
     }
   }
+
+  test(
+    "Ensure distinct should not push branches that are not different to other visited branches"
+  ) {
+    forAll { branches: Set[Branch] =>
+      val (duplicateBranches, distinctBranches) = branches.toList.splitAt(branches.size / 2)
+      type F[A] = StateT[IO, Int, A]
+      val F = Applicative[F]
+      val f: StateT[IO, Int, ProcessResult] =
+        StateT[IO, Int, ProcessResult](actionAcc => IO.pure(actionAcc + 1 -> Updated))
+      val obtained = (for {
+        seenBranches <- Ref[F].of(duplicateBranches)
+        res <- (duplicateBranches ++ distinctBranches).traverse { branch =>
+          NurtureAlg
+            .ensureDistinctBranch(
+              seenBranches,
+              _ => F.pure(distinctBranches.contains(branch)),
+              f,
+              F.pure[ProcessResult](Ignored)
+            )
+        }
+      } yield res).runS(0).unsafeRunSync()
+      assertEquals(obtained, distinctBranches.length)
+    }
+  }
 }