nixite/testing/html.test.nix

{it, ...}: let
  html = import ../nixite/html.nix;
in
  with html; [
    (it "keeps info in the tag" (let
      p = tag "p";
    in {
      actual = p.tag;
      expected = "p";
    }))

    (it "keeps attr info in the tag" (let
      p = tag "p" {class = "";};
    in {
      actual = p.attrs;
      expected = {class = "";};
    }))

    (it "keeps tag after setting attrs" (let
      p = tag "p" {class = "";};
    in {
      actual = p.tag;
      expected = "p";
    }))

    (it "makes a p tag" {
      actual = tag "p" {} "Hello";
      expected = {
        tag = "p";
        attrs = {};
        child = "Hello";
      };
      removeDunders = true;
    })

    (it "makes element" (let
      para = tag "p" {};
    in {
      expected = "p";
      actual = para.tag;
    }))

    (it "keeps attrs on element" (let
      attrs = {style = {foo = "bar";};};
      para = tag "p" attrs;
    in {
      expected = attrs;
      actual = para.attrs;
    }))

    (it "makes renderable element" (let
      attrs = {style = {foo = "bar";};};
      para = tag "p" attrs;
    in {
      expected = "<p ></p>";
      actual = toString (para "");
    }))

    (it "keeps tag" (let
      attrs = {style = {foo = "bar";};};
      para = tag "p" attrs;
    in {
      expected = "p";
      actual = (para "").tag;
    }))

    (it "keeps style" (let
      attrs = {style = {foo = "bar";};};
      para = tag "p" attrs;
    in {
      expected = {foo = "bar";};
      actual = (para "").attrs.style;
    }))

    (it "needs no args to make string" (let
      p = tag "p";
    in {
      actual = toString p;
      expected = "<p ></p>";
    }))

    (it "needs no content to make string" (let
      p = tag "p";
    in {
      actual = toString (p {class = "foobar";});
      expected = ''<p class="foobar"></p>'';
    }))

    (it "can take many sets of props" (let
      p = tag "p";
    in {
      actual = toString (p {class = "foobar";} {style = "a style";});
      expected = ''<p class="foobar" style="a style"></p>'';
    }))

    (it "works recursively" (let
      attrs = {style = {foo = "bar";};};
      para = tag "p" attrs;
      a = tag "a" {};
    in {
      expected = "<p ><a >hello</a></p>";
      actual = toString (para (a "hello"));
    }))

    (it "throws with function child" {
      actual = toString (tag "p" (i: ""));
      throws = true;
    })

    (it "throws with a number" {
      actual = toString (tag "p" 5);
      throws = true;
    })

    (it "throws with a bool" {
      actual = toString (tag "p" true);
      throws = true;
    })

    (it "throws with a null" {
      actual = toString (tag "p" null);
      throws = true;
    })

    (it "concatinates classes" {
      actual = toString (tag "p" {class = ["class1" "class2"];} "Hello");
      expected = ''<p class="class1 class2">Hello</p>'';
    })

    (it "applies style" (let
      page = tag "html" {} [(tag "head" {} ["foo"])];
    in {
      actual = addToHead page ["bar"];
      expected = {
        tag = "html";
        attrs = {};
        child = [(tag "head" {} ["foo" "bar"])];
      };
      removeDunders = true;
    }))

    (it "renders on / off attrs" {
      actual = toString (tag "p" {
        on = true;
        off = false;
      });
      expected = "<p on></p>";
    })
  ]