How to use it_skips_contexts_that_were_not_included method of NSpec.Tests.Formatters.liveconsole_sample_spec class

1using System.Collections.Generic;
2using System.Reflection;
3using NSpec.Domain;
4using NSpec.Domain.Formatters;
5using NUnit.Framework;
6using FluentAssertions;
7
8namespace NSpec.Tests.Formatters
9{
10    [TestFixture]
11    public class describe_LiveFormatter_with_context_filter
12    {
13        class liveconsole_sample_spec : nspec
14        {
15            void a_context_with_a_pending_example()
16            {
17                it["pending example"] = todo;
18            }
19
20            void a_context_with_a_grandchild_example()
21            {
22                context["a context with an example"] = () =>
23                {
24                    it["liveconsole: 1 is 1"] = () => Assert.That(true, Is.True);
25                };
26            }
27
28            void a_context_without_an_example() { }
29        }
30
31        [SetUp]
32        public void Setup()
33        {
34            formatter = new FormatterStub();
35
36            var invocation = new RunnerInvocation(
37                dll: typeof(describe_LiveFormatter_with_context_filter).GetTypeInfo().Assembly.Location,
38                tags: typeof(liveconsole_sample_spec).Name,
39                formatter: formatter,
40                failFast: false);
41
42            contexts = invocation.Run();
43        }
44
45        [Test]
46        public void it_writes_the_example()
47        {
48            formatter.WrittenExamples.Should().Contain(e => e.Spec == "liveconsole: 1 is 1");
49        }
50
51        [Test]
52        public void it_writes_contexts_with_examples()
53        {
54            formatter.WrittenContexts.Should().Contain(c => c.Name == "a context with an example");
55        }
56
57        [Test]
58        public void it_writes_context_with_grandchild_examples()
59        {
60            formatter.WrittenContexts.Should().Contain(c => c.Name == "a context with a grandchild example");
61        }
62
63        [Test]
64        public void it_skips_contexts_without_examples()
65        {
66            formatter.WrittenContexts.Should().NotContain(c => c.Name == "a context without an example");
67        }
68
69        [Test]
70        public void it_skips_contexts_that_were_not_included()
71        {
72            formatter.WrittenContexts.Should().NotContain(c => c.Name == "SampleSpec");
73        }
74
75        [Test]
76        public void it_skips_examples_whose_contexts_were_not_included()
77        {
78            formatter.WrittenExamples.Should().NotContain(e => e.Spec == "an excluded example by ancestry");
79        }
80
81        [Test]
82        public void it_writes_the_pending_example()
83        {
84            formatter.WrittenExamples.Should().Contain(e => e.Spec == "pending example");
85        }
86
87        FormatterStub formatter;
88        ContextCollection contexts;
89    }
90}

Source: describe_LiveFormatter_with_context_filter.cs

using System.Collections.Generic;
using System.Reflection;
using NSpec.Domain;
using NSpec.Domain.Formatters;
using NUnit.Framework;
using FluentAssertions;

namespace NSpec.Tests.Formatters
{
    [TestFixture]
    public class describe_LiveFormatter_with_context_filter
    {
        class liveconsole_sample_spec : nspec
        {
            void a_context_with_a_pending_example()
            {
                it["pending example"] = todo;
            }

            void a_context_with_a_grandchild_example()
            {
                context["a context with an example"] = () =>
                {
                    it["liveconsole: 1 is 1"] = () => Assert.That(true, Is.True);
                };
            }

            void a_context_without_an_example() { }
        }

        [SetUp]
        public void Setup()
        {
            formatter = new FormatterStub();

            var invocation = new RunnerInvocation(
                dll: typeof(describe_LiveFormatter_with_context_filter).GetTypeInfo().Assembly.Location,
                tags: typeof(liveconsole_sample_spec).Name,
                formatter: formatter,
                failFast: false);

            contexts = invocation.Run();
        }

        [Test]
        public void it_writes_the_example()
        {
            formatter.WrittenExamples.Should().Contain(e => e.Spec == "liveconsole: 1 is 1");
        }

        [Test]
        public void it_writes_contexts_with_examples()
        {
            formatter.WrittenContexts.Should().Contain(c => c.Name == "a context with an example");
        }

        [Test]
        public void it_writes_context_with_grandchild_examples()
        {
            formatter.WrittenContexts.Should().Contain(c => c.Name == "a context with a grandchild example");
        }

        [Test]
        public void it_skips_contexts_without_examples()
        {
            formatter.WrittenContexts.Should().NotContain(c => c.Name == "a context without an example");
        }

        [Test]
        public void it_skips_contexts_that_were_not_included()
        {
            formatter.WrittenContexts.Should().NotContain(c => c.Name == "SampleSpec");
        }

        [Test]
        public void it_skips_examples_whose_contexts_were_not_included()
        {
            formatter.WrittenExamples.Should().NotContain(e => e.Spec == "an excluded example by ancestry");
        }

        [Test]
        public void it_writes_the_pending_example()
        {
            formatter.WrittenExamples.Should().Contain(e => e.Spec == "pending example");
        }

        FormatterStub formatter;
        ContextCollection contexts;
    }
}