nixite/testing/html.test.nix

let
  html = import ../nixite/html.nix;
  it = import ./it.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;
  }))

]