#dsl #kdl #document

test-dsl

A helper crate to define easy-to-author tests as KDL documents

2 unstable releases

Uses new Rust 2024

new 0.2.0 Mar 28, 2025
0.1.0 Mar 28, 2025
0.0.0 Mar 25, 2025

#26 in #kdl

Download history 77/week @ 2025-03-21

77 downloads per month

MIT/Apache

41KB
915 lines

test-dsl is a test-helper library to write your own DSLs

Crates.io Version docs.rs (with version)

cargo add --dev test-dsl

test-dsl allows you define a set of verbs and conditions, to more easily concentrate on authoring tests.

How to use it

Using test-dsl is straightforward:

  • You define a test harness
  • You define a set of 'verbs' that will allow you to act on your test harness
  • You define a set of 'conditions' that you will be able to assert during your tests

For example, a fairly simple test-setup to check arithmetic can be defined as follows:

use std::sync::Arc;
use test_dsl::condition::Condition;
use test_dsl::verb::FunctionVerb;
use miette::NamedSource;

let mut ts = test_dsl::TestDsl::<usize>::new();

ts.add_condition("is_fortytwo", Condition::new_now(|h: &usize| Ok(*h == 42)));
ts.add_condition(
    "is_equal",
    Condition::new_now(|h: &usize, num: usize| Ok(*h == num)),
);

ts.add_verb(
    "add",
    FunctionVerb::new(|h: &mut usize, num: usize| {
        *h += num;
        Ok(())
    }),
);

ts.add_verb(
    "mul",
    FunctionVerb::new(|h: &mut usize, num: usize| {
        *h *= num;
        Ok(())
    }),
);

let testcases = ts
    .parse_document(NamedSource::new(
        "test.kdl",
        Arc::from(
            r#"
        testcase {
            add 21
            mul 2
            assert {
                is_fortytwo
            }
        }

        testcase {
            add 10
            mul 10
            assert {
                is_equal 100
            }
        }
    "#,
        ),
    ))
    .unwrap();

// Check that its true
testcases[0].run(&mut 0).unwrap();
testcases[1].run(&mut 0).unwrap();

Builtin verbs

The following verbs come builtin:

  • repeat <number> { .. }: it allows for repetition of a given block. Used as such:

    testcase {
        repeat 3 {
            print "Hello World"
    
            print "World Hello"
        }
    }
    
  • group { .. }: it allows to group verbs together. Used as such:

    testcase {
        group {
            print "Hello"
            print "World"
        }
    }
    

    NB: There is currently not much use to groups, but this may change in the future

  • assert { .. }: it allows to assert a list of conditions. Used as such:

    testcase {
        send_message
        assert {
            message_was_sent
        }
    }
    

Dependencies

~4MB
~83K SLoC