nixite/testing/md.test.nix

{
  describe,
  it,
  ...
}: let
  md = import ../nixite/md.nix;
  elems = import ../nixite/elems.nix;
in
  with md; [
    (
      describe "list" [
        (it "matches a list of one element" {
          actual = list [
            ''
              - something
            ''
          ];
          expected = [(elems.List ["something"])];
        })

        (it "makes a list of many elements" {
          actual = list [
            ''
              - something
              - something else
            ''
          ];
          expected = [(elems.List ["something" "something else"])];
        })

        (it "makes a list of many checkboxes" {
          actual = list [
            ''
              - [ ] something
              - [X] something else
            ''
          ];
          expected = [
            (elems.List [
              [
                (elems.input {
                  type = "checkbox";
                  disabled = true;
                  checked = false;
                } "")
                "something"
              ]
              [
                (elems.input {
                  type = "checkbox";
                  disabled = true;
                  checked = true;
                } "")
                "something else"
              ]
            ])
          ];
        })

        (it "matches a list with no whitespace around" {
          actual = list [
            ''
              - something
              - something else''
          ];
          expected = [(elems.List ["something" "something else"])];
        })

        (it "doesnt match not a list" (let
          str = "blah blah";
        in {
          actual = list [str];
          expected = [str];
        }))
      ]
    )
    (
      describe "process string" [
        (it "processes whole string with all rules" {
          actual = processStr ''
            this text **may** *or may not* contain **bold** words *inside* it.
          '';
          expected = elems.p [
            "this text"
            (elems.strong "may")
            (elems.em "or may not")
            "contain"
            (elems.strong "bold")
            "words"
            (elems.em "inside")
            "it."
          ];
          asString = true;
        })

        (it "makes paragraphs" {
          actual = processStr ''
            lorem ipsum
            dolor sit

            foo bar
          '';
          expected = ''
            <p >lorem ipsum
            dolor sit
            </p><p >foo bar</p>'';
          asString = true;
        })
      ]
    )
    (
      describe "fix appendix" [
        (it "can fix file appendixes" {
          actual = fixAppendix "index.md";
          expected = "index.html";
        })
      ]
    )
    (
      describe "mdToPage" [
        (it "converts markdown to a page" {
          actual = toString (mdToPage ./blog/index.md) + "\n\n"; # inflation
          expected = builtins.readFile ./out/index.html;
          asString = true;
        })
      ]
    )
    (
      describe "recReadMd" [
        (it "recursively reads dir" {
          actual = recReadMd ./blog;
          expected = {
            "index.md" = mdToPage ./blog/index.md;
            "dir" = {"index.md" = mdToPage ./blog/dir/index.md;};
          };
          asJSON = true;
        })
      ]
    )
    (
      describe "recFixAppendix" [
        (it "recursively fixes filename" {
          actual = recFixAppendix {
            "index.md" = "something";
            dir = {"index.md" = "something else";};
          };
          expected = {
            "index.html" = "something";
            dir = {"index.html" = "something else";};
          };
        })
      ]
    )
    (
      describe "readDir" [
        (it "recursively translates md to html" {
          actual = builtins.toJSON (readDir ./blog);
          expected = builtins.toJSON {
            "index.html" = mdToPage ./blog/index.md;
            "dir" = {"index.html" = mdToPage ./blog/dir/index.md;};
          };
        })
      ]
    )
  ]