как определяте, че NUnit тест трябва да се провали?

Какво ще кажете за Assert.Throws‹XXXException›(x.DoSomething());

Хубавото тук е, че ако тестът премине (т.е. изключението е хвърлено), върнатата стойност е самото действително изключение и след това можете да го разпитате и да потвърдите допълнително въз основа на това.

Като се има предвид, че в този случай искате да тествате NUnit разширения, които, предполагам, функционират чрез извикване на Assert, можете да Assert.Throws‹AssertionException›(...) и след това да направите горното.

Мисля да напиша подобен тестов водопроводен код, за който може да имам нужда от тестове, така че ще ви уведомя, ако открия нещо друго в тази област.

Единичните тестове трябва да бъдат проектирани така, че:
Те настройват някакво състояние
Те изпълняват тествания метод
Те твърдят, че едно нещо е правилно, след като тестваният метод приключи

(справка: Изкуството на модулното тестване от Рой Ошеров)

Защо тестовете, които са предназначени да се провалят, са нещо лошо? Те могат да се провалят по неочаквани начини и пак да бъдат маркирани като пропуск, защото са се провалили. Във вашия пример, приемайки, че Should() е тестваният метод (въпреки че тази точка остава дори и да не е), вие пишете теста по-горе и го маркирате като „очаква се неуспешен“. Проваля се. Всичко е наред. След няколко месеца се връщате към Should() и разбирате, че се нуждае от известно преработване, така че променяте изпълнението му.

Сега, във вашия пример, Should() хвърля изключение, защото случайно сте въвели грешка. Но вашият тест (който се проваля поради изключението сега, а не поради логиката) е маркиран като трябва да се провали и той го прави, така че все още е маркиран като преминаващ, въпреки прекъсващата промяна.

Тестът трябва да бъде проектиран да премине, а не да се провали, по този начин, ако се провали по друг, неочакван начин, ще бъдете уведомени. Така че във вашия пример трябва да напишете тестове с противоположна логика:

[Test]
public void TypeOf_ShouldBeString() {
    string str = "abc";
    str.Should().Be.TypeOf<string>();
}

or:

[Test]
public void TypeOf_ShouldNotBeInt() {
    string str = "abc";
    str.Should().Not.Be.TypeOf<int>();
}

(Не съм сигурен в синтаксиса, който използвате, така че вероятно няма да има нужда от замяна с правилния синтаксис, но мнението остава).

Edit2: Ако това, което се опитвате да направите, е да се уверите, че вашият метод Should() е неуспешен (чрез неуспех на Assert. метод), тогава това, което искате да направите, е да хванете NUnit AssertionException, което е Assert. статични методи хвърлят. Опитайте тази:

[Test]
[ExpectedException(typeof(AssertionException))]
public void ShouldBeTypeOf_WithInt_Fails() {
    string str = "abc";
    str.Should().Be.TypeOf<int>();
}    

Знам, че това е стара публикация, но ето какво ми помогна, използвайки NUnit:

[TestCase("SomeValidValue")]
[TestCase("{3X5XFX9X-7XCX-4XCX-8X3X-3XAXEX9X0XBX}", ExpectedException = typeof(AssertionException))]
public void GetSpecificConfiguration(string key)
{
    Assert.IsNotNull(Config.Instance.GetRecord(key));
}

Този подход ми позволява да имам един и същ тест, с две очаквания, едно успешно и едно неуспешно.

Ако имате предвид, че се очаква блокът от код да хвърли изключение за преминаване на теста, ето кода:

[Test]
[ExpectedException(typeof(Exception))]
public void TypeOf_fail() {
    string str = "abc";
    str.Should().Be.TypeOf<int>();
}

Разбира се, заменете Exception с възможно най-конкретното изключение.