Unit Testing¶

tested.test("tables with self-cycles, but the same structure should be equal", function()
   local cycle_a: {any:any} = {}
   cycle_a["self"] = cycle_a

   local cycle_b: {any:any} = {}
   cycle_b["self"] = cycle_b

   tested.assert({
      given = "two tables that each contain a reference to themselves",
      should = "be considered structurally equal",
      expected = cycle_a,
      actual = cycle_b
   })
end)

tested.skip("skipping because tested.skip", function()
    tested.assert({expected = 8, actual = sum(4, 4)})
end)

-- this will be marked as skipped
tested.test("skipping because others are tested.only", function()
    tested.assert({expected = 8, actual = sum(4, 4)})
end)

-- only these two will be run in a specific file!
tested.only("this will run!", function()
    tested.assert({expected = 8, actual = sum(5, 3) })
end)

-- this also gets run since it is an only test
tested.only("this will also run!", function()
    tested.assert({expected = 8, actual = sum(2, 6) })
end)

-- the `run_when` option takes in a boolean where true runs the test, false will skip it
tested.test("luajit only test", {run_when=(type(jit) == "table")}, function()
    tested.assert({expected = 8, actual = sum(5, 3) })
end)

tested.test("expected exception: throws as expected", {expected="EXCEPTION"}, function()
   error("this exception is expected")
end)

-- this will show up in the tested output with an error message indicating that it's passed but has expected to fail.
tested.test("unexpected: expected fail but test passes", {expected="FAIL"}, function()
   tested.assert({
      given = "1 + 1",
      should = "equal 2",
      expected = 2,
      actual = 1 + 1
   })
end)

local exception_attempt_count = 0
tested.test("retries: exception retried and then passes", {retries = 1, retry_delay = 1.5}, function()
   exception_attempt_count = exception_attempt_count + 1
   if exception_attempt_count == 1 then
      error("first attempt raises an exception")
   end
   tested.assert({
      given = "second attempt after exception",
      should = "pass after initial exception",
      expected = true,
      actual = true
   })
end)

tested.test("truthy", function()
   tested.assert_truthy({given="empty string", actual=""})
   tested.assert_truthy({given="a number", actual=0})
   tested.assert_truthy({given="a function", actual=function() end})
   tested.assert_truthy({given="a table", actual={}})
   tested.assert_truthy({given="an unpack", actual=table.unpack({"a", "b"})})
   tested.assert_truthy({given="true boolean", actual=true})
   tested.assert_truthy({given="not false", actual=not false})
   tested.assert_truthy({given="not nil", actual=not nil})
   tested.assert_truthy({given="string.find he in hello", actual=string.find("hello", "he")})
end)

tested.test("falsy", function()
   local b
   tested.assert_falsy({given="nil", actual=nil})
   tested.assert_falsy({given="false", actual=false})
   tested.assert_falsy({given="unset variable", actual=b})
end)

-- simple check that exception will be raised
tested.test("assert_throws_exception handles exception in assert", function()
    tested.assert_throws_exception({
        given = "an explicit error",
        actual = function() error("gets raised, but handled!") end
    })
end)

-- check that a specific exception was thrown
tested.test("example with exceptions and error checking", function()

    -- will throw the specific exception in "expected" below
    local function_that_throws = function()
        local options = {loadFromString=true, headers=false, fieldsToKeep={1, 2}}
        ftcsv.parse("apple>banana>carrot\ndiamond>emerald>pearl", ">", options)
    end
    tested.assert_throws_exception({
        given="no headers and no renaming takes place",
        expected="ftcsv: fieldsToKeep only works with header-less files when using the 'rename' functionality",
        actual=function_that_throws
    })
end)

local counts = { before = 0, after = 0, before_each = 0, after_each = 0 }

tested.before(function() counts.before = counts.before + 1 end)
tested.after(function() counts.after = counts.after + 1 end)
tested.before_each(function() counts.before_each = counts.before_each + 1 end)
tested.after_each(function() counts.after_each = counts.after_each + 1 end)

tested.test("before runs once before first test", function()
    tested.assert({ given = "before count",       should = "be 1",  expected = 1, actual = counts.before })
    tested.assert({ given = "after count",         should = "be 0",  expected = 0, actual = counts.after })
    tested.assert({ given = "before_each count",   should = "be 1",  expected = 1, actual = counts.before_each })
    tested.assert({ given = "after_each count",    should = "be 0",  expected = 0, actual = counts.after_each })
end)

tested.test("after_each runs after first test, before_each runs again", function()
    tested.assert({ given = "before count",       should = "still be 1", expected = 1, actual = counts.before })
    tested.assert({ given = "after count",         should = "still be 0", expected = 0, actual = counts.after })
    tested.assert({ given = "before_each count",   should = "be 2",       expected = 2, actual = counts.before_each })
    tested.assert({ given = "after_each count",    should = "be 1",       expected = 1, actual = counts.after_each })
end)

-- before_each and after_each will not run on skipped tests!
tested.test("this test is skipped", { run_when = false }, function() end)