soxtoby / easyassertions Goto Github PK

ShouldHaveFlag for [Flags] enums.
Try adding ShouldBe for enums that gets R# autocompletion working.

new[] { "foo", "bar" }.ShouldOnlyContain(new[] { "foo" })
produces an error where the sample shows up like:

[
    [
        <f>,
        <o>,
        <o>
...

Obviously, strings shouldn't get treated like IEnumerable for this sort of thing.

Specifically function exceptions, but things like .And() and equality predicates as well.

E.g. .ShouldNotBeNull().And is never null

"foo\nbar".ShouldBe("foo\nbaz");

results in an error message like:

should be "foo\nbaz"
but was   "foo\nbar"
                 ^

new [] { new [] { 1 } }.ShouldMatch(new[] { new [] { 2 } });

Fails with a message like "Array'1[Int32] should have been Array'1[Int32]", but it should be more like: "Item 0, 0 should have been 2, but was 1". Doesn't have to be perfect, but it should get across that it's the items that aren't matching, not the inner enumerables.

To stop people from accidentally using comparison functions when they should be asserting, add ItemsSatisfy, AllItemsSatisfy etc. functions that take Funcs instead of Actions, and mark them as obsolete.

Replace single extension with two more constrained extensions:

public static void ShouldBeNull<TActual>(this TActual actual, string message = null) where TActual : class { }
public static void ShouldBeNull<TActual>(this TActual? actual, string message = null) where TActual : struct { }

One of the versions is 2.0.0.0 and another is 2.0.0.17941 (which is what gets used in the reference), which might be the problem. They should probably both be 2.0.0 (or whatever version the NuGet package is).

Should support ValueTask & IAsyncEnumerable. Record types are probably fine, but better double-check.

As much as I hoped to avoid it, I keep needing to assert that a task doesn't complete after a certain period of time. If it has a default timeout, it should be much less than ShouldComplete's default of 1 second.

Instead of

listA.ShouldMatch(listB, (a, b) => a.Prop == b.Prop));

you should be able to assert:

listA.ShouldMatch(listB, (a, b) => a.Prop.ShouldBe(b.Prop));

The error messages would be a lot more useful when you know which property didn't match.