Assert

function describe

describe(label: String, block: Block<Void>) -> Void

Groups related test cases under a label, and runs them.

The block is called immediately. describe blocks nest, and the output is indented to match. This is a foul function — it prints.

Parameters

label

what this group is about

block

the tests, and any nested groups

Examples

describe "String" do
  describe "count" do
    it "returns the character count" do
      assert("hello".count == 5)
    end
  end
end

function it

it(label: String, block: Block<Void>) -> Void

Defines a single test case, and runs it.

The block runs, and anything thrown inside it — typically a failed assert — marks the test failed without aborting the rest of the suite. This is a foul function — it prints.

Parameters

label

what this case establishes, phrased as a claim

block

the case body

Examples

it "returns true for even numbers" do
  assert(2.even?)
  assert(!3.even?)
end

One behaviour per case reads better than one big case

it "trims leading whitespace" do
  Assert.equal("  hi".trim, "hi")
end

it "trims trailing whitespace" do
  Assert.equal("hi  ".trim, "hi")
end

function before

before(block: Block<Void>) -> Void
before(block: Atom) -> Block<Void> -> Void

Registers setup to run before the current group's tests.

before { ... } and before(:each) { ... } run before every test in the group; before(:all) { ... } runs once before the group's first test, following RSpec's scope convention.

Parameters

block

the setup to run

Examples

describe "the parser" do
  before do
    Mock.FS.file("input.txt", "one\ntwo\n")
  end

  it "reads two lines" do
    Assert.equal(FS.File.readLines("input.txt").or([]).count, 2)
  end
end

function after

after(block: Block<Void>) -> Void
after(block: Atom) -> Block<Void> -> Void

Registers cleanup to run after the current group's tests.

Defaults to :each. Cleanup is unconditional — it runs whether the test passed or failed — and inner per-test hooks run before outer hooks.

Parameters

block

the cleanup to run

Examples

after do
  FS.File.delete("tmp/out.txt")
end

function assert

assert(value: Bool) -> Bool
assert(value: Bool) -> String -> Bool

Fails the enclosing it when value is falsy.

The primitive every other assertion is built on. Prefer the Assert helpers where one fits — they report what was expected and what arrived, which a bare assert cannot.

Parameters

value

the condition that must hold

Returns the value, when it held

Examples

assert(42 == 42)
assert("hello".count == 5)

module Assert

Focused assertions, each reporting what was expected and what arrived.

These are ordinary Kex stdlib functions layered on the primitive assert, so adding another helper does not require compiler or runtime work.

Assert.equal("hi".upperCase, "HI")
Assert.some(users.first)
Assert.ok(Integer.parse("42"))

equal(actual: A, expected: A) -> Bool

Assert.equal("hi".upperCase, "HI")
Assert.equal([1, 2, 3].sum, 6)
Assert.equal(config.get(:port), Just(8080))

notEqual(actual: A, expected: A) -> Bool

Assert.notEqual(newId, oldId)

truthy(value: A) -> Bool

Assert.truthy("hello".contains?("ell"))

falsy(value: A) -> Bool

Assert.falsy([].any? { |x| x > 0 })

some(value: A?) -> Bool

Assert.some([1, 2].first)
Assert.some(config.get(:host))

none(value: A?) -> Bool

Assert.none([].first)
Assert.none("abc".to(Integer))

ok(value: Result<A, E>) -> Bool

Assert.ok(Integer.parse("42"))

error(value: Result<A, E>) -> Bool

Assert.error(Integer.parse("4x"))