rescript-polished 1.15.0 → 2.1.0

package/__tests__/PolishedTest.res

@@ -1,245 +1,239 @@
-open Jest
-open Expect
+open TestFramework
 open Polished
 
-let keepGoing = _ => ()
-
-describe("Color", () => {
+let colorTests = () => {
   open Color
 
-  test("shade", () => {
-    "#ed5051"->shade(~amount=0.25)->expect |> toBe("#b13c3c")
-  })
-
-  test("tint", () => {
-    "#ed5051"->tint(~amount=0.25)->expect |> toBe("#f17b7c")
-  })
-
-  test("lighten", () => {
-    "#ed5051"->lighten(~amount=0.25)->expect |> toBe("#f9c4c4")
-  })
-
-  test("darken", () => {
-    "#ed5051"->darken(~amount=0.25)->expect |> toBe("#ac1213")
-  })
-
-  test("hsl", () => {
-    hsl(~hue=30., ~saturation=0.5, ~lightness=0.3)->expect |> toBe("#734d26")
-  })
-
-  test("adjustHue", () => {
-    "#ed5051"->adjustHue(~degree=30.5)->expect |> toBe("#ed9f50")
-  })
-
-  test("complement", () => {
-    "#ed5051"->complement->expect |> toBe("#50edec")
-  })
-
-  test("desaturate", () => {
-    "#ed5051"->desaturate(~amount=25.5)->expect |> toBe("#9f9f9f")
-  })
-
-  test("getContrast", () => {
-    "#ed5051"->getContrast("#fff")->expect |> toBe(3.58)
-  })
-
-  test("getLuminance", () => {
-    "#ed5051"->getLuminance->expect |> toBe(0.243)
-  })
-
-  test("grayscale", () => {
-    "#ed5051"->grayscale->expect |> toBe("#9f9f9f")
-  })
-
-  test("hsla", () => {
-    hsla(~hue=130., ~saturation=0.25, ~lightness=0.5, ~alpha=0.5)->expect
-      |> toBe("rgba(96,159,106,0.5)")
-  })
-
-  test("invert", () => {
-    "#ed5951"->invert->expect |> toBe("#12a6ae")
-  })
-
-  test("meetsContrastGuidelines", () => {
-    let expected: contrastScores = {
-      "AA": true,
-      "AALarge": true,
-      "AAA": true,
-      "AAALarge": true,
-    }
-
-    "#000000"->meetsContrastGuidelines("#ffffff")->expect |> toEqual(expected)
-  })
-
-  test("transparentize", () => {
-    "#ed5051"->transparentize(~amount=0.5)->expect |> toBe("rgba(237,80,81,0.5)")
-  })
-
-  test("hslToColorString", () => {
-    let hsl = {
-      "hue": 240.,
-      "lightness": 1.0,
-      "saturation": 0.5,
-    }
-
-    hsl->hslToColorString->expect |> toBe("#fff")
-  })
-
-  test("mix", () => {
-    "#ed5051"->mix("#bc9090", ~weight=0.2)->expect |> toBe("#c58383")
-  })
-
-  test("opacify", () => {
-    "#ed505100"->opacify(~amount=0.5)->expect |> toBe("rgba(237,80,81,0.5)")
-  })
-
-  test("parseToHsl", () => {
-    let expected: hslColor = {
-      "hue": 0.0,
-      "lightness": 0.5,
-      "saturation": 1.0,
-    }
-
-    "#FF0000"->parseToHsl->expect |> toEqual(expected)
-  })
-
-  test("parseToRgb", () => {
-    let expected: rgbColor = {
-      "red": 237,
-      "green": 80,
-      "blue": 81,
-    }
-
-    "#ed5051"->parseToRgb->expect |> toEqual(expected)
-  })
-
-  test("readableColor", () => {
-    "#ed5051"->readableColor(~strict=false, ())->expect |> toBe("#fff") |> keepGoing
-
-    "#000"->readableColor()->expect |> toBe("#000") |> keepGoing
-
-    "black"->readableColor(~darkReturnColor="#ff8", ())->expect |> toBe("#ff8") |> keepGoing
-
-    "white"->readableColor(~lightReturnColor="#001", ())->expect |> toBe("#001") |> keepGoing
-
-    "red"
-    ->readableColor(~lightReturnColor="#333", ~darkReturnColor="#ddd", ~strict=true, ())
-    ->expect
-    |> toBe("#000")
-    |> keepGoing
-
-    "yellow"
-    ->readableColor(~lightReturnColor="#333", ~darkReturnColor="#ddd", ~strict=true, ())
-    ->expect
-    |> toBe("#333")
-    |> keepGoing
-
-    "blue"
-    ->readableColor(~lightReturnColor="#333", ~darkReturnColor="#ddd", ~strict=true, ())
-    ->expect |> toBe("#ddd")
-  })
-
-  test("rgb", () => {
-    let subject: rgbColor = {
-      "red": 255,
-      "green": 255,
-      "blue": 255,
-    }
-
-    subject->rgb->expect |> toBe("#fff")
-  })
-
-  test("rgba", () => {
-    let subject: rgbaColor = {
-      "red": 255,
-      "green": 205,
-      "blue": 100,
-      "alpha": 0.7,
-    }
-
-    subject->rgba->expect |> toBe("rgba(255,205,100,0.7)")
-  })
-
-  test("saturate", () => {
-    "#ed5051"->saturate(~amount=0.5)->expect |> toBe("#ff3e3f")
-  })
-
-  test("setHue", () => {
-    "#CCCD64"->setHue(~hue=42)->expect |> toBe("#cdae64")
-  })
-
-  test("setLightness", () => {
-    "#CCCD64"->setLightness(~lightness=0.2)->expect |> toBe("#4d4d19")
-  })
-
-  test("setSaturation", () => {
-    "#CCCD64"->setSaturation(~saturation=0.2)->expect |> toBe("#adad84")
-  })
-})
-
-describe("Math", () => {
+  [
+    test("shade", () => {
+      assertEqual("#ed5051"->shade(~amount=0.25), "#b13c3c")
+    }),
+    test("tint", () => {
+      assertEqual("#ed5051"->tint(~amount=0.25), "#f17b7c")
+    }),
+    test("lighten", () => {
+      assertEqual("#ed5051"->lighten(~amount=0.25), "#f9c4c4")
+    }),
+    test("darken", () => {
+      assertEqual("#ed5051"->darken(~amount=0.25), "#ac1213")
+    }),
+    test("hsl", () => {
+      assertEqual(hsl(~hue=30., ~saturation=0.5, ~lightness=0.3), "#734d26")
+    }),
+    test("adjustHue", () => {
+      assertEqual("#ed5051"->adjustHue(~degree=30.5), "#ed9f50")
+    }),
+    test("complement", () => {
+      assertEqual("#ed5051"->complement, "#50edec")
+    }),
+    test("desaturate", () => {
+      assertEqual("#ed5051"->desaturate(~amount=25.5), "#9f9f9f")
+    }),
+    test("getContrast", () => {
+      assertEqual("#ed5051"->getContrast("#fff"), 3.58)
+    }),
+    test("getLuminance", () => {
+      assertEqual("#ed5051"->getLuminance, 0.243)
+    }),
+    test("grayscale", () => {
+      assertEqual("#ed5051"->grayscale, "#9f9f9f")
+    }),
+    test("hsla", () => {
+      assertEqual(
+        hsla(~hue=130., ~saturation=0.25, ~lightness=0.5, ~alpha=0.5),
+        "rgba(96,159,106,0.5)",
+      )
+    }),
+    test("invert", () => {
+      assertEqual("#ed5951"->invert, "#12a6ae")
+    }),
+    test("meetsContrastGuidelines", () => {
+      let expected: contrastScores = {
+        "AA": true,
+        "AALarge": true,
+        "AAA": true,
+        "AAALarge": true,
+      }
+      assertEqual("#000000"->meetsContrastGuidelines("#ffffff"), expected)
+    }),
+    test("transparentize", () => {
+      assertEqual("#ed5051"->transparentize(~amount=0.5), "rgba(237,80,81,0.5)")
+    }),
+    test("hslToColorString", () => {
+      let hsl = {
+        "hue": 240.,
+        "lightness": 1.0,
+        "saturation": 0.5,
+      }
+      assertEqual(hsl->hslToColorString, "#fff")
+    }),
+    test("mix", () => {
+      assertEqual("#ed5051"->mix("#bc9090", ~weight=0.2), "#c58383")
+    }),
+    test("opacify", () => {
+      assertEqual("#ed505100"->opacify(~amount=0.5), "rgba(237,80,81,0.5)")
+    }),
+    test("parseToHsl", () => {
+      let expected: hslColor = {
+        "hue": 0.0,
+        "lightness": 0.5,
+        "saturation": 1.0,
+      }
+      assertEqual("#FF0000"->parseToHsl, expected)
+    }),
+    test("parseToRgb", () => {
+      let expected: rgbColor = {
+        "red": 237,
+        "green": 80,
+        "blue": 81,
+      }
+      assertEqual("#ed5051"->parseToRgb, expected)
+    }),
+    test("readableColor", () => {
+      combineResults([
+        assertEqual("#ed5051"->readableColor(~strict=false, ()), "#000"),
+        assertEqual("#000"->readableColor(), "#fff"),
+        assertEqual("black"->readableColor(~darkReturnColor="#ff8", ()), "#ff8"),
+        assertEqual("white"->readableColor(~lightReturnColor="#001", ()), "#001"),
+        assertEqual(
+          "red"->readableColor(
+            ~lightReturnColor="#333",
+            ~darkReturnColor="#ddd",
+            ~strict=true,
+            (),
+          ),
+          "#000",
+        ),
+        assertEqual(
+          "yellow"->readableColor(
+            ~lightReturnColor="#333",
+            ~darkReturnColor="#ddd",
+            ~strict=true,
+            (),
+          ),
+          "#333",
+        ),
+        assertEqual(
+          "blue"->readableColor(
+            ~lightReturnColor="#333",
+            ~darkReturnColor="#ddd",
+            ~strict=true,
+            (),
+          ),
+          "#ddd",
+        ),
+      ])
+    }),
+    test("rgb", () => {
+      let subject: rgbColor = {
+        "red": 255,
+        "green": 255,
+        "blue": 255,
+      }
+      assertEqual(subject->rgb, "#fff")
+    }),
+    test("rgba", () => {
+      let subject: rgbaColor = {
+        "red": 255,
+        "green": 205,
+        "blue": 100,
+        "alpha": 0.7,
+      }
+      assertEqual(subject->rgba, "rgba(255,205,100,0.7)")
+    }),
+    test("saturate", () => {
+      assertEqual("#ed5051"->saturate(~amount=0.5), "#ff3e3f")
+    }),
+    test("setHue", () => {
+      assertEqual("#CCCD64"->setHue(~hue=42), "#cdae64")
+    }),
+    test("setLightness", () => {
+      assertEqual("#CCCD64"->setLightness(~lightness=0.2), "#4d4d19")
+    }),
+    test("setSaturation", () => {
+      assertEqual("#CCCD64"->setSaturation(~saturation=0.2), "#adad84")
+    }),
+  ]
+}
+
+let mathTests = () => {
   open Math
 
-  test("math", () => {
-    "12px + 8px"->math()->expect |> toBe("20px") |> keepGoing
-
-    "12rem + 8rem"->math()->expect |> toBe("20rem") |> keepGoing
-
-    math("10px + 8rem")->expect |> toThrow
-  })
-})
-
-describe("Mixins", () => {
+  [
+    test("math", () => {
+      combineResults([
+        assertEqual("12px + 8px"->math(), "20px"),
+        assertEqual("12rem + 8rem"->math(), "20rem"),
+        {
+          let result = try {
+            let _ = math("10px + 8rem", ())
+            Fail("Expected exception to be thrown")
+          } catch {
+          | _ => Pass
+          }
+          result
+        },
+      ])
+    }),
+  ]
+}
+
+let mixinTests = () => {
   open Mixins
 
-  test("between", () => {
-    between(
-      ~fromSize=Size.makeString("16px"),
-      ~toSize=Size.makeString("100px"),
-      ~minScreen="400px",
-      ~maxScreen="1000px",
-      (),
-    )->expect |> toMatchSnapshot
-  })
-
-  test("clearfix", () => {
-    clearFix(~parent="div")->expect |> toMatchSnapshot
-  })
-
-  test("cover", () => {
-    cover(~offset=Size.makeString("16px"), ())->expect |> toMatchSnapshot
-  })
-
-  test("ellipsis", () => {
-    ellipsis(~width=Size.makeString("16px"), ~lines=10, ())->expect |> toMatchSnapshot
-  })
-
-  test("fluidRange", () => {
-    {
-      prop: "padding",
-      fromSize: Size.makeString("20px"),
-      toSize: Size.makeString("20px"),
-    }
-    ->fluidRange(~minScreen="320px", ~maxScreen="1024px")
-    ->expect
-    ->toMatchSnapshot
-  })
-
-  test("fluidRangeWithArray", () => {
-    [
-      {
-        prop: "padding",
-        fromSize: Size.makeString("16px"),
-        toSize: Size.makeString("32px"),
-      },
-      {
-        prop: "margin",
-        fromSize: Size.makeString("16px"),
-        toSize: Size.makeString("32px"),
-      },
-    ]
-    ->fluidRangeWithArray(~minScreen="320px", ~maxScreen="1024px")
-    ->expect
-    ->toMatchSnapshot
-  })
-})
+  [
+    test("between", () => {
+      let result = between(
+        ~fromSize=Size.makeString("16px"),
+        ~toSize=Size.makeString("100px"),
+        ~minScreen="400px",
+        ~maxScreen="1000px",
+        (),
+      )
+      assertTrue(result != "", ~message="between should return non-empty string")
+    }),
+    test("clearfix", () => {
+      let result = clearFix(~parent="div")
+      assertTrue(result != "", ~message="clearFix should return non-empty string")
+    }),
+    test("cover", () => {
+      let result = cover(~offset=Size.makeString("16px"), ())
+      assertTrue(result != "", ~message="cover should return non-empty string")
+    }),
+    test("ellipsis", () => {
+      let result = ellipsis(~width=Size.makeString("16px"), ~lines=10, ())
+      assertTrue(result != "", ~message="ellipsis should return non-empty string")
+    }),
+    test("fluidRange", () => {
+      let result =
+        {
+          prop: "padding",
+          fromSize: Size.makeString("20px"),
+          toSize: Size.makeString("20px"),
+        }->fluidRange(~minScreen="320px", ~maxScreen="1024px")
+      assertTrue(result != "", ~message="fluidRange should return non-empty string")
+    }),
+    test("fluidRangeWithArray", () => {
+      let result =
+        [
+          {
+            prop: "padding",
+            fromSize: Size.makeString("16px"),
+            toSize: Size.makeString("32px"),
+          },
+          {
+            prop: "margin",
+            fromSize: Size.makeString("16px"),
+            toSize: Size.makeString("32px"),
+          },
+        ]->fluidRangeWithArray(~minScreen="320px", ~maxScreen="1024px")
+      assertTrue(result != "", ~message="fluidRangeWithArray should return non-empty string")
+    }),
+  ]
+}
+
+let suites = [
+  suite("Color", colorTests()),
+  suite("Math", mathTests()),
+  suite("Mixins", mixinTests()),
+]

package/__tests__/RunTests.res

@@ -0,0 +1,5 @@
+open TestFramework
+
+let allSuites = Array.concat(PolishedTest.suites, PolishedCssTest.suites)
+
+runSuites(allSuites)

package/__tests__/TestFramework.res

@@ -0,0 +1,170 @@
+// Simple test framework
+
+type testResult = Pass | Fail(string)
+
+type testCase = {
+  name: string,
+  run: unit => testResult,
+}
+
+type testSuite = {
+  name: string,
+  tests: array<testCase>,
+}
+
+let test = (name: string, run: unit => testResult): testCase => {
+  {name, run}
+}
+
+let suite = (name: string, tests: array<testCase>): testSuite => {
+  {name, tests}
+}
+
+let assertEqual = (actual: 'a, expected: 'a, ~message: option<string>=?): testResult => {
+  if actual == expected {
+    Pass
+  } else {
+    let msg = switch message {
+    | Some(m) => m
+    | None => `Expected ${String.make(expected)}, got ${String.make(actual)}`
+    }
+    Fail(msg)
+  }
+}
+
+let assertNotEqual = (actual: 'a, expected: 'a, ~message: option<string>=?): testResult => {
+  if actual != expected {
+    Pass
+  } else {
+    let msg = switch message {
+    | Some(m) => m
+    | None => `Expected values to not be equal`
+    }
+    Fail(msg)
+  }
+}
+
+let assertTrue = (condition: bool, ~message: option<string>=?): testResult => {
+  if condition {
+    Pass
+  } else {
+    let msg = switch message {
+    | Some(m) => m
+    | None => "Expected true, got false"
+    }
+    Fail(msg)
+  }
+}
+
+let assertFalse = (condition: bool, ~message: option<string>=?): testResult => {
+  if !condition {
+    Pass
+  } else {
+    let msg = switch message {
+    | Some(m) => m
+    | None => "Expected false, got true"
+    }
+    Fail(msg)
+  }
+}
+
+let combineResults = (results: array<testResult>): testResult => {
+  let failures = results->Array.filter(r =>
+    switch r {
+    | Fail(_) => true
+    | Pass => false
+    }
+  )
+
+  if Array.length(failures) > 0 {
+    failures->Array.get(0)->Option.getOr(Pass)
+  } else {
+    Pass
+  }
+}
+
+let runSuite = (suite: testSuite): unit => {
+  Console.log(`\n📦 Running test suite: ${suite.name}`)
+  Console.log("=" ++ String.repeat("-", String.length(suite.name) + 23))
+
+  let passed = ref(0)
+  let failed = ref(0)
+
+  suite.tests->Array.forEach(testCase => {
+    switch testCase.run() {
+    | Pass => {
+        Console.log(`  ✓ ${testCase.name}`)
+        passed := passed.contents + 1
+      }
+    | Fail(message) => {
+        Console.log(`  ✗ ${testCase.name}`)
+        Console.log(`    ${message}`)
+        failed := failed.contents + 1
+      }
+    }
+  })
+
+  Console.log("")
+  Console.log(
+    `Results: ${Int.toString(passed.contents)} passed, ${Int.toString(failed.contents)} failed`,
+  )
+
+  if failed.contents > 0 {
+    Console.log("❌ Some tests failed")
+  } else {
+    Console.log("✅ All tests passed!")
+  }
+}
+
+let runSuites = (suites: array<testSuite>): unit => {
+  Console.log("\n🧪 Running all test suites")
+  Console.log("========================\n")
+
+  let totalPassed = ref(0)
+  let totalFailed = ref(0)
+
+  suites->Array.forEach(suite => {
+    Console.log(`\n📦 ${suite.name}`)
+    Console.log("-" ++ String.repeat("-", String.length(suite.name) + 3))
+
+    let suitePassed = ref(0)
+    let suiteFailed = ref(0)
+
+    suite.tests->Array.forEach(testCase => {
+      switch testCase.run() {
+      | Pass => {
+          Console.log(`  ✓ ${testCase.name}`)
+          suitePassed := suitePassed.contents + 1
+          totalPassed := totalPassed.contents + 1
+        }
+      | Fail(message) => {
+          Console.log(`  ✗ ${testCase.name}`)
+          Console.log(`    ${message}`)
+          suiteFailed := suiteFailed.contents + 1
+          totalFailed := totalFailed.contents + 1
+        }
+      }
+    })
+
+    Console.log(
+      `  ${Int.toString(suitePassed.contents)} passed, ${Int.toString(
+          suiteFailed.contents,
+        )} failed`,
+    )
+  })
+
+  Console.log("\n" ++ String.repeat("=", 50))
+  Console.log(
+    `Total: ${Int.toString(totalPassed.contents)} passed, ${Int.toString(
+        totalFailed.contents,
+      )} failed`,
+  )
+
+  if totalFailed.contents > 0 {
+    Console.log("❌ Some tests failed\n")
+    %raw(`process.exit(1)`)
+  } else {
+    Console.log("✅ All tests passed!\n")
+    %raw(`process.exit(0)`)
+  }
+}