{
  describe,
  it,
  ...
}: let
  html = import ../nixite/html.nix;
in
  with html;
    describe "tag" [
      (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 "renders on / off attrs" {
        actual = toString (tag "p" {
          on = true;
          off = false;
        });
        expected = "<p on></p>";
      })
    ]
    ++ describe "addToHead" [
      (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;
      }))
    ]