Improve test coverage

Author: ant8e

Readme.md

@@ -2,6 +2,7 @@
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/tech.ant8e/uuid4cats-effect_2.13/badge.svg)](https://maven-badges.herokuapp.com/maven-central/tech.ant8e/uuid4cats-effect_2.13)
 [![Code of Conduct](https://img.shields.io/badge/Code%20of%20Conduct-Scala-blue.svg)](CODE_OF_CONDUCT.md)
 ![](https://github.com/ant8e/uuid4cats-effect/actions/workflows/ci.yml/badge.svg)
+[![codecov](https://codecov.io/gh/ant8e/uuid4cats-effect/branch/main/graph/badge.svg?token=QEUSQ3T053)](https://codecov.io/gh/ant8e/uuid4cats-effect)
 # uuid4cats-effect -  UUID and TypeID Generation for cats effect
 
 

codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    project:
+      default:
+        target: auto  # auto compares coverage to the previous base commit
+    patch:
+      default:
+        informational: true

core/src/main/scala/tech/ant8e/uuid4cats/TypeID.scala

@@ -55,9 +55,8 @@ object TypeID {
     .map(uuidGenerator =>
       (prefix: String) =>
         uuidGenerator.uuid.flatMap { uuid =>
-          val typeID = build(prefix, uuid).leftMap(errors =>
-            new IllegalArgumentException(errors.mkString_(", "))
-          )
+          val typeID = build(prefix, uuid)
+            .leftMap(errors => new IllegalArgumentException(errors.show))
           ApplicativeError[F, Throwable].fromValidated(typeID)
         }
     )
@@ -198,9 +197,8 @@ object TypeID {
     override def toString: String = s"TypeID:$repr($uuid_)"
 
     override def equals(obj: Any): Boolean = obj match {
-      case other: TypeID =>
-        this.uuid.equals(other.uuid) && this.prefix.equals(other.prefix)
-      case _ => false
+      case other: TypeID => TypeID.typeIDEq.eqv(this, other)
+      case _             => false
     }
 
   }

core/src/test/scala/tech/ant8e/uuid4cats/GeneratorSuite.scala

@@ -65,6 +65,23 @@ class GeneratorSuite extends CatsEffectSuite {
       _ <- IO(typeids.distinct.size === typeids.size).assert
       _ <- IO(isSeqSorted(typeids)).assert
     } yield ()
+
+    for {
+      typeids <- TypeID
+        .generator[IO]("prefix")
+        .flatMap(generator => List.tabulate(n)(_ => generator()).sequence)
+      _ <- IO(typeids.distinct.size === typeids.size).assert
+      _ <- IO(isSeqSorted(typeids)).assert
+    } yield ()
+  }
+
+  test("TypeID generator should not accept illegal prefix") {
+    TypeID
+      .generator[IO]
+      .flatMap(generator => generator.typeid("WRONG"))
+      .intercept[IllegalArgumentException]
+
+    TypeID.generator[IO]("WRONG").intercept[IllegalArgumentException]
   }
 
   private def genN(generator: UUIDGenerator[IO], n: Int): IO[List[UUID]] =

core/src/test/scala/tech/ant8e/uuid4cats/TypeIDSuite.scala

@@ -16,6 +16,7 @@
 
 package tech.ant8e.uuid4cats
 
+import cats.Eq
 import cats.data.NonEmptyChain
 import cats.syntax.all._
 import munit.FunSuite
@@ -82,6 +83,20 @@ class TypeIDSuite extends FunSuite {
       uuid = uuid"01890a5d-ac96-774b-bcce-b302099a8057"
     )
   }
+  test("TypeID should not  build invalid typeIDs") {
+    val tooLongPrefix =
+      "0123456789012345678901234567890123456789012345678901234567890123456789"
+    assertInvalidEncoding(
+      tooLongPrefix,
+      uuid"01890a5d-ac96-774b-bcce-b302099a8057"
+    )
+
+    val v4UUID = uuid"3054b437-160c-42ac-9b68-f814f93bfc28"
+    assertInvalidEncoding("prefix", v4UUID)
+
+    assertInvalidEncoding("prefix", null)
+    assertInvalidEncoding(null, uuid"01890a5d-ac96-774b-bcce-b302099a8057")
+  }
 
   test("TypeID should decode valid typeIDs") {
     // nil
@@ -198,7 +213,36 @@ class TypeIDSuite extends FunSuite {
 
     // suffix-overflow
     assertInvalidDecoding(typeID = "prefix_8zzzzzzzzzzzzzzzzzzzzzzzzz")
+
+    // sixteen with mandatory UUIDV7
+    assertInvalidDecoding(
+      typeID = "0000000000000000000000000g",
+      enforceUUIDV7 = true
+    )
+
+    // missing separator
+    assertInvalidDecoding(
+      typeID = "prefix0000000000000000000000000g"
+    )
+  }
+
+  test("TypeID should have an Eq instance") {
+    val eq = implicitly[Eq[TypeID]]
+    assert(
+      eq.eqv(
+        TypeID.decode("prefix_01h455vb4pex5vsknk084sn02q").toOption.get,
+        TypeID.decode("prefix_01h455vb4pex5vsknk084sn02q").toOption.get
+      )
+    )
   }
+
+  test("TypeID should have a Show instance") {
+    assertEquals(
+      TypeID.decode("prefix_01h455vb4pex5vsknk084sn02q").toOption.get.show,
+      "TypeID:prefix_01h455vb4pex5vsknk084sn02q(01890a5d-ac96-774b-bcce-b302099a8057)"
+    )
+  }
+
   private def assertValidEncoding(
       typeID: String,
       prefix: String,
@@ -211,6 +255,17 @@ class TypeIDSuite extends FunSuite {
       typeID.valid[TypeID.BuildError].toValidatedNec
     )
   }
+
+  private def assertInvalidEncoding(
+      prefix: String,
+      uuid: UUID
+  ): Unit = {
+    assert(
+      TypeID
+        .build(prefix = prefix, uuid = uuid)
+        .isInvalid
+    )
+  }
   private def assertValidDecoding(
       typeID: String,
       prefix: String,
@@ -228,8 +283,12 @@ class TypeIDSuite extends FunSuite {
 
     assertEquals(obtained, expected)
   }
-  private def assertInvalidDecoding(typeID: String): Unit = {
-    val obtained = TypeID.decode(typeID)
+
+  private def assertInvalidDecoding(
+      typeID: String,
+      enforceUUIDV7: Boolean = false
+  ): Unit = {
+    val obtained = TypeID.decode(typeID, enforceUUIDV7)
     assert(obtained.isInvalid, s"$typeID should not decode as a valid TypeID")
   }