fluent-asserts 0.10.1

Writing unit tests is easy with Dlang. The unittest block allows you to start writing tests and to be productive with no special setup.

Unfortunately the assert expression does not help you to write expressive asserts, and in case of a failure it's hard to find why an assert failed. The fluent-asserts library allows you to more naturally specify the expected outcome of a TDD or BDD-style test.

To begin

1. Add the DUB dependency: https://code.dlang.org/packages/fluent-asserts
2. Import it:

   in dub.json:

       ...
       "configurations": [
           ...
           {
               "name": "unittest",
               "dependencies": {
                   "fluent-asserts": "~>0.9.0",
                   ...
               }
           },
           ...
       ]
       ...
   

   in your source files:

   version(unittest) import fluent.asserts;
   

3. Use it:

    unittest {
        true.should.equal(false).because("this is a failing assert");
    }

    unittest {
        Assert.equal(true, false, "this is a failing assert");
    }

1. Run the tests:

➜  dub test --compiler=ldc2

API Docs

The library provides the should template and the Assert struct.

Should

should can be used in combination with Uniform Function Call Syntax (UFCS)

auto should(T)(lazy const T testData);

So the following statements are equivalent

testedValue.should.equal(42);
should(testedValue).equal(42);

In addition, the library provides the not and because modifiers that allow to improve your asserts.

not negates the assert condition:

testedValue.should.not.equal(42);

because allows you to add a custom message:

    true.should.equal(false).because("of test reasons");
    ///will output this message: Because of test reasons, true should equal `false`.

Assert

Assert is a wrapper for the should struct that allows you to use the asserts with a different syntax.

For example, the following lines are equivalent:

    testedValue.should.equal(42);
    Assert.equal(testedValue, 42);

All the asserts that are available using the should syntax are available with Assert. If you want to negate the check, just add not before the assert name:

    Assert.notEqual(testedValue, 42);

You can use fluent asserts with:

• Basic Data Types
• Objects
• Strings
• Ranges and Arrays
• Callable
• Vibe.d Json
• Vibe.d requests

Do you already have a lot of tests?

If you want to get the failure location for failing tests written using the Dlang's assert you can use the fluent assert handler which will add extra information to the default assert message.

    shared static this() {
        import fluent.asserts;
        setupFluentHandler;
    }

Too much verbosity in the assert messages?

If you want to get less informations when an assert fails, you can use several versions:

• DisableDiffResult - will not show a diff for the string equal assert
• DisableSourceResult - will not show the source code where the test failed
• DisableMessageResult - will not show the defaul message for the assert

In dub.json:

    "versions": [
        "DisableDiffResult",
        "DisableSourceResult",
        "DisableMessageResult"
    ],

License

MIT. See LICENSE for details.