How to use examples_should_fail_for_formatter method of NSpec.Tests.WhenRunningSpecs.Exceptions.BeforeThrowsSpecClass class

1using NSpec.Domain;
2using NUnit.Framework;
3using FluentAssertions;
4using System.Collections.Generic;
5using System.Linq;
6
7namespace NSpec.Tests.WhenRunningSpecs.Exceptions
8{
9    [TestFixture]
10    [Category("RunningSpecs")]
11    public class when_before_contains_exception : when_running_specs
12    {
13        class BeforeThrowsSpecClass : nspec
14        {
15            void method_level_context()
16            {
17                before = () => { throw new BeforeException(); };
18
19                it["should fail this example because of before"] = () =>
20                {
21                    ExamplesRun.Add("should fail this example because of before");
22                    Assert.That(true, Is.True);
23                };
24
25                it["should also fail this example because of before"] = () =>
26                {
27                    ExamplesRun.Add("should also fail this example because of before");
28                    Assert.That(true, Is.True);
29                };
30
31                it["overrides exception from same level it"] = () =>
32                {
33                    ExamplesRun.Add("overrides exception from same level it");
34                    throw new ItException();
35                };
36
37                context["exception thrown by both before and nested before"] = () =>
38                {
39                    before = () => { throw new NestedBeforeException(); };
40
41                    it["overrides exception from nested before"] = () =>
42                    {
43                        ExamplesRun.Add("overrides exception from nested before");
44                        Assert.That(true, Is.True);
45                    };
46                };
47
48                context["exception thrown by both before and nested act"] = () =>
49                {
50                    act = () => { throw new ActException(); };
51
52                    it["overrides exception from nested act"] = () =>
53                    {
54                        ExamplesRun.Add("overrides exception from nested act");
55                        Assert.That(true, Is.True);
56                    };
57                };
58
59                context["exception thrown by both before and nested it"] = () =>
60                {
61                    it["overrides exception from nested it"] = () =>
62                    {
63                        ExamplesRun.Add("overrides exception from nested it");
64                        throw new ItException();
65                    };
66                };
67
68                context["exception thrown by both before and nested after"] = () =>
69                {
70                    it["overrides exception from nested after"] = () =>
71                    {
72                        ExamplesRun.Add("overrides exception from nested after");
73                        Assert.That(true, Is.True);
74                    };
75
76                    after = () => { throw new AfterException(); };
77                };
78            }
79
80            public static List<string> ExamplesRun = new List<string>();
81        }
82
83        [SetUp]
84        public void setup()
85        {
86            Run(typeof(BeforeThrowsSpecClass));
87        }
88
89        [Test]
90        public void the_example_level_failure_should_indicate_a_context_failure()
91        {
92            classContext.AllExamples().Should().OnlyContain(e => e.Exception is ExampleFailureException);
93        }
94
95        [Test]
96        public void examples_with_only_before_failure_should_fail_because_of_before()
97        {
98            classContext.AllExamples()
99                .Where(e => new []
100                {
101                    "should fail this example because of before",
102                    "should also fail this example because of before",
103                }.Contains(e.Spec))
104                .Should().OnlyContain(e => e.Exception.InnerException is BeforeException);
105        }
106
107        [Test]
108        public void it_should_throw_exception_from_before_not_from_same_level_it()
109        {
110            TheExample("overrides exception from same level it")
111                .Exception.InnerException.Should().BeOfType<BeforeException>();
112        }
113
114        [Test]
115        public void it_should_throw_exception_from_before_not_from_nested_before()
116        {
117            TheExample("overrides exception from nested before")
118                .Exception.InnerException.Should().BeOfType<BeforeException>();
119        }
120
121        [Test]
122        public void it_should_throw_exception_from_before_not_from_nested_act()
123        {
124            TheExample("overrides exception from nested act")
125                .Exception.InnerException.Should().BeOfType<BeforeException>();
126        }
127
128        [Test]
129        public void it_should_throw_exception_from_before_not_from_nested_it()
130        {
131            TheExample("overrides exception from nested it")
132                .Exception.InnerException.Should().BeOfType<BeforeException>();
133        }
134
135        [Test]
136        public void it_should_throw_exception_from_before_not_from_nested_after()
137        {
138            TheExample("overrides exception from nested after")
139                .Exception.InnerException.Should().BeOfType<BeforeException>();
140        }
141
142        [Test]
143        public void examples_should_fail_for_formatter()
144        {
145            formatter.WrittenExamples.Should().OnlyContain(e => e.Failed);
146        }
147
148        [Test]
149        public void examples_body_should_not_run()
150        {
151            BeforeThrowsSpecClass.ExamplesRun.Should().BeEmpty();
152        }
153    }
154}
155

Source: when_before_contains_exception.cs

using NSpec.Domain;
using NUnit.Framework;
using FluentAssertions;
using System.Collections.Generic;
using System.Linq;

namespace NSpec.Tests.WhenRunningSpecs.Exceptions
{
    [TestFixture]
    [Category("RunningSpecs")]
    public class when_before_contains_exception : when_running_specs
    {
        class BeforeThrowsSpecClass : nspec
        {
            void method_level_context()
            {
                before = () => { throw new BeforeException(); };

                it["should fail this example because of before"] = () =>
                {
                    ExamplesRun.Add("should fail this example because of before");
                    Assert.That(true, Is.True);
                };

                it["should also fail this example because of before"] = () =>
                {
                    ExamplesRun.Add("should also fail this example because of before");
                    Assert.That(true, Is.True);
                };

                it["overrides exception from same level it"] = () =>
                {
                    ExamplesRun.Add("overrides exception from same level it");
                    throw new ItException();
                };

                context["exception thrown by both before and nested before"] = () =>
                {
                    before = () => { throw new NestedBeforeException(); };

                    it["overrides exception from nested before"] = () =>
                    {
                        ExamplesRun.Add("overrides exception from nested before");
                        Assert.That(true, Is.True);
                    };
                };

                context["exception thrown by both before and nested act"] = () =>
                {
                    act = () => { throw new ActException(); };

                    it["overrides exception from nested act"] = () =>
                    {
                        ExamplesRun.Add("overrides exception from nested act");
                        Assert.That(true, Is.True);
                    };
                };

                context["exception thrown by both before and nested it"] = () =>
                {
                    it["overrides exception from nested it"] = () =>
                    {
                        ExamplesRun.Add("overrides exception from nested it");
                        throw new ItException();
                    };
                };

                context["exception thrown by both before and nested after"] = () =>
                {
                    it["overrides exception from nested after"] = () =>
                    {
                        ExamplesRun.Add("overrides exception from nested after");
                        Assert.That(true, Is.True);
                    };

                    after = () => { throw new AfterException(); };
                };
            }

            public static List<string> ExamplesRun = new List<string>();
        }

        [SetUp]
        public void setup()
        {
            Run(typeof(BeforeThrowsSpecClass));
        }

        [Test]
        public void the_example_level_failure_should_indicate_a_context_failure()
        {
            classContext.AllExamples().Should().OnlyContain(e => e.Exception is ExampleFailureException);
        }

        [Test]
        public void examples_with_only_before_failure_should_fail_because_of_before()
        {
            classContext.AllExamples()
                .Where(e => new []
                {
                    "should fail this example because of before",
                    "should also fail this example because of before",
                }.Contains(e.Spec))
                .Should().OnlyContain(e => e.Exception.InnerException is BeforeException);
        }

        [Test]
        public void it_should_throw_exception_from_before_not_from_same_level_it()
        {
            TheExample("overrides exception from same level it")
                .Exception.InnerException.Should().BeOfType<BeforeException>();
        }

        [Test]
        public void it_should_throw_exception_from_before_not_from_nested_before()
        {
            TheExample("overrides exception from nested before")
                .Exception.InnerException.Should().BeOfType<BeforeException>();
        }

        [Test]
        public void it_should_throw_exception_from_before_not_from_nested_act()
        {
            TheExample("overrides exception from nested act")
                .Exception.InnerException.Should().BeOfType<BeforeException>();
        }

        [Test]
        public void it_should_throw_exception_from_before_not_from_nested_it()
        {
            TheExample("overrides exception from nested it")
                .Exception.InnerException.Should().BeOfType<BeforeException>();
        }

        [Test]
        public void it_should_throw_exception_from_before_not_from_nested_after()
        {
            TheExample("overrides exception from nested after")
                .Exception.InnerException.Should().BeOfType<BeforeException>();
        }

        [Test]
        public void examples_should_fail_for_formatter()
        {
            formatter.WrittenExamples.Should().OnlyContain(e => e.Failed);
        }

        [Test]
        public void examples_body_should_not_run()
        {
            BeforeThrowsSpecClass.ExamplesRun.Should().BeEmpty();
        }
    }
}