test: Cleanup RefinedOpsSuite

main/test/src/io/github/iltotore/iron/testing/RefinedOpsSuite.scala

@@ -1,15 +1,10 @@
 package io.github.iltotore.iron.testing
 
-import io.github.iltotore.iron.{:|, IronType, autoRefine}
-import io.github.iltotore.iron.constraint.numeric.{Positive, *}
-import utest.{TestSuite, Tests, compileError, test}
 import io.github.iltotore.iron.*
-import io.github.iltotore.iron.constraint.all.*
+import io.github.iltotore.iron.constraint.numeric.*
+import utest.*
 
-import scala.util.{Failure, Try}
-
-opaque type Temperature = Double :| Positive
-object Temperature extends RefinedTypeOps[Temperature]
+import scala.util.{Failure, Success, Try}
 
 object RefinedTypeOpsSuite extends TestSuite:
   val tests: Tests = Tests {
@@ -32,65 +27,43 @@ object RefinedTypeOpsSuite extends TestSuite:
       val t1 = Temperature(x)
       val t2 = Temperature(y)
 
-      assert(t1 == Temperature(5.0), "should be result of 'apply'")
-      assert(t2 == Temperature(15.0), "should be result of 'apply'")
+      assert(t1 == Temperature(5.0))
+      assert(t2 == Temperature(15.0))
     }
 
     test("either") {
       val eitherWithFailingPredicate = Temperature.either(-5.0)
-      assert(eitherWithFailingPredicate == Left("Should be strictly positive"), "'either' returns left if predicate fails")
+      assert(eitherWithFailingPredicate == Left("Should be strictly positive"))
       val eitherWithSucceedingPredicate = Temperature.either(100)
-      assert(eitherWithSucceedingPredicate == Right(Temperature(100)), "right should contain result of 'apply'")
+      assert(eitherWithSucceedingPredicate == Right(Temperature(100)))
     }
 
     test("option") {
       val fromWithFailingPredicate = Temperature.option(-5.0)
-      assert(fromWithFailingPredicate == None, "'option' returns None if predicate fails")
+      assert(fromWithFailingPredicate == None)
       val fromWithSucceedingPredicate = Temperature.option(100)
-      assert(fromWithSucceedingPredicate == Some(Temperature(100)), "Some should contain result of 'apply'")
+      assert(fromWithSucceedingPredicate == Some(Temperature(100)))
     }
 
     test("applyUnsafe") {
-      val appliedUnsafeWithFailingPredicate = Try(Temperature.applyUnsafe(-1))
-
-      assert(appliedUnsafeWithFailingPredicate.isFailure, "appliedUnsafe should fail when predicate fails")
-      assert(
-        appliedUnsafeWithFailingPredicate.toEither.swap.toOption.get.getMessage == "Should be strictly positive",
-        "exception should duplicate message of failed predicate"
-      )
-
-      val appliedUnsafeWithSucceedingPredicate = Try(Temperature.applyUnsafe(100))
-      assert(
-        appliedUnsafeWithSucceedingPredicate.toOption.get == Temperature(100),
-        "should be wrapped result of apply"
-      )
+      test - assertMatch(Try(Temperature.applyUnsafe(-100))) { case Failure(e) if e.getMessage == "Should be strictly positive" => }
+      test - assert(Temperature.applyUnsafe(100) == Temperature(100))
     }
 
-    test("assume") {
-      val x: Double = -15.0
-      val t1 = Temperature.assume(x)
-
-      assert(t1 == -15.0.asInstanceOf[Temperature])
-    }
+    test("assume") - assert(Temperature.assume(-15) == -15.0.asInstanceOf[Temperature])
 
-    test("ops are being applied to non-opaque types and don't change behaviour") {
-      type Moisture = Double :| Positive
-      object Moisture extends RefinedTypeOps[Moisture]
+    test("nonOpaque") {
       val moisture = Moisture(11)
       val positive: Double :| Positive = 11
       val greaterThan10: Double :| Greater[10] = 11
 
-      assert(Moisture(positive) == moisture)
-      assert(Moisture(greaterThan10) == moisture)
-      assert(Moisture(positive) == moisture)
-      val eitherWithFailingPredicate = Moisture.either(-5.0)
-      assert(eitherWithFailingPredicate == Left("Should be strictly positive"), "'either' returns left if predicate fails")
-      val eitherWithSucceedingPredicate = Moisture.either(100)
-      assert(eitherWithSucceedingPredicate == Right(Moisture(100)), "right should contain result of 'apply'")
-      val fromWithFailingPredicate = Moisture.option(-5.0)
-      assert(fromWithFailingPredicate == None, "'option' returns None if predicate fails")
-      val fromWithSucceedingPredicate = Moisture.option(100)
-      assert(fromWithSucceedingPredicate == Some(Moisture(100)), "Some should contain result of 'apply'")
+      test - assert(Moisture(positive) == moisture)
+      test - assert(Moisture(greaterThan10) == moisture)
+      test - assert(Moisture(positive) == moisture)
+      test - assert(Moisture.either(-5.0) == Left("Should be strictly positive"))
+      test - assert(Moisture.either(100) == Right(Moisture(100)))
+      test - assert(Moisture.option(-5.0) == None)
+      test - assert(Moisture.option(100) == Some(Moisture(100)))
     }
 
   }

main/test/src/io/github/iltotore/iron/testing/RefinedOpsTypes.scala

@@ -0,0 +1,11 @@
+package io.github.iltotore.iron.testing
+
+import io.github.iltotore.iron.*
+import io.github.iltotore.iron.constraint.numeric.Positive
+
+//Opaque types are truly opaque when used in another file than the one where they're defined. See Scala documentation.
+opaque type Temperature = Double :| Positive
+object Temperature extends RefinedTypeOps[Temperature]
+
+type Moisture = Double :| Positive
+object Moisture extends RefinedTypeOps[Moisture]