How to use it_should_set_method_level_after method of NSpec.Tests.WhenRunningSpecs.SpecClass class

1using System;
2using System.Linq;
3using NUnit.Framework;
4using System.Threading.Tasks;
5using FluentAssertions;
6
7namespace NSpec.Tests.WhenRunningSpecs
8{
9    [TestFixture]
10    [Category("RunningSpecs")]
11    public class describe_method_level_afters : when_running_specs
12    {
13        class SpecClass : nspec
14        {
15            public static Action ContextLevelAfter = () => { };
16            public static Action SubContextAfter = () => { };
17            public static Func<Task> AsyncSubContextAfter = async () => { await Task.Delay(0); };
18
19            // method- (or class-) level after
20            void after_each()
21            {
22            }
23
24            void method_level_context()
25            {
26                after = ContextLevelAfter;
27
28                context["sub context"] = () =>
29                {
30                    after = SubContextAfter;
31
32                    it["needs an example or it gets filtered"] = todo;
33                };
34
35                context["sub context with async after"] = () =>
36                {
37                    afterAsync = AsyncSubContextAfter;
38
39                    it["needs another example or it gets filtered"] = todo;
40                };
41            }
42        }
43
44        [SetUp]
45        public void setup()
46        {
47            Run(typeof(SpecClass));
48        }
49
50        [Test]
51        public void it_should_set_method_level_after()
52        {
53            // Could not find a way to actually verify that deep inside
54            // 'AfterInstance' there is a reference to 'SpecClass.after_each()'
55
56            classContext.AfterInstance.Should().NotBeNull();
57        }
58
59        [Test]
60        [Category("Async")]
61        public void it_should_not_set_async_method_level_after()
62        {
63            classContext.AfterInstanceAsync.Should().BeNull();
64        }
65
66        [Test]
67        public void it_should_set_after_on_method_level_context()
68        {
69            methodContext.After.Should().Be(SpecClass.ContextLevelAfter);
70        }
71
72        [Test]
73        public void it_should_set_after_on_sub_context()
74        {
75            methodContext.Contexts.First().After.Should().Be(SpecClass.SubContextAfter);
76        }
77
78        [Test]
79        [Category("Async")]
80        public void it_should_set_async_after_on_sub_context()
81        {
82            methodContext.Contexts.Last().AfterAsync.Should().Be(SpecClass.AsyncSubContextAfter);
83        }
84    }
85}
86

Source: describe_method_level_afters.cs

using System;
using System.Linq;
using NUnit.Framework;
using System.Threading.Tasks;
using FluentAssertions;

namespace NSpec.Tests.WhenRunningSpecs
{
    [TestFixture]
    [Category("RunningSpecs")]
    public class describe_method_level_afters : when_running_specs
    {
        class SpecClass : nspec
        {
            public static Action ContextLevelAfter = () => { };
            public static Action SubContextAfter = () => { };
            public static Func<Task> AsyncSubContextAfter = async () => { await Task.Delay(0); };

            // method- (or class-) level after
            void after_each()
            {
            }

            void method_level_context()
            {
                after = ContextLevelAfter;

                context["sub context"] = () =>
                {
                    after = SubContextAfter;

                    it["needs an example or it gets filtered"] = todo;
                };

                context["sub context with async after"] = () =>
                {
                    afterAsync = AsyncSubContextAfter;

                    it["needs another example or it gets filtered"] = todo;
                };
            }
        }

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

        [Test]
        public void it_should_set_method_level_after()
        {
            // Could not find a way to actually verify that deep inside
            // 'AfterInstance' there is a reference to 'SpecClass.after_each()'

            classContext.AfterInstance.Should().NotBeNull();
        }

        [Test]
        [Category("Async")]
        public void it_should_not_set_async_method_level_after()
        {
            classContext.AfterInstanceAsync.Should().BeNull();
        }

        [Test]
        public void it_should_set_after_on_method_level_context()
        {
            methodContext.After.Should().Be(SpecClass.ContextLevelAfter);
        }

        [Test]
        public void it_should_set_after_on_sub_context()
        {
            methodContext.Contexts.First().After.Should().Be(SpecClass.SubContextAfter);
        }

        [Test]
        [Category("Async")]
        public void it_should_set_async_after_on_sub_context()
        {
            methodContext.Contexts.Last().AfterAsync.Should().Be(SpecClass.AsyncSubContextAfter);
        }
    }
}