scriptcs/test/ScriptCs.Core.Tests/ScriptPackSessionTests.cs at dev · andmos/scriptcs · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
using System.Collections.Generic;
using System.Linq;
using Moq;
using ScriptCs.Contracts;
using Should;
using Xunit;

namespace ScriptCs.Tests
{
    public class ScriptPackSessionTests
    {
        public class TheConstructor
        {
            private ScriptPackSession _scriptPackSession;
            private Mock<IScriptPack> _scriptPackMock;
            private Mock<IScriptPackContext> _contextMock;

            public TheConstructor()
            {
                _scriptPackMock = new Mock<IScriptPack>();
                _contextMock = new Mock<IScriptPackContext>();
                _scriptPackMock.Setup(p => p.GetContext()).Returns(_contextMock.Object);
                _scriptPackSession = new ScriptPackSession(new List<IScriptPack>{_scriptPackMock.Object}, new string[0]);
            }

            [Fact]
            public void ShouldPopulateContexts()
            {
                _scriptPackSession.Contexts.ShouldContain(_contextMock.Object);
            }

            [Fact]
            public void ShouldInitializeReferences()
            {
                _scriptPackSession.References.ShouldNotBeNull();
            }

            [Fact]
            public void ShouldInitializeNamespaces()
            {
                _scriptPackSession.Namespaces.ShouldNotBeNull();
            }

            [Fact]
            public void ShouldAddContextNamespaces()
            {
                _scriptPackSession.Namespaces.Contains(_contextMock.Object.GetType().Namespace);
            }

            [Fact]
            public void ShouldInitializeState()
            {
                _scriptPackSession.State.ShouldNotBeNull();
            }
        }

        public class TheInitializeMethod
        {
            private ScriptPackSession _scriptPackSession;
            private Mock<IScriptPack> _scriptPackMock1;
            private Mock<IScriptPack> _scriptPackMock2;
            private Mock<IScriptPackContext> _contextMock1;
            private Mock<IScriptPackContext> _contextMock2;

            public TheInitializeMethod()
            {
                _contextMock1 = new Mock<IScriptPackContext>();
                _contextMock2 = new Mock<IScriptPackContext>();
                _scriptPackMock1 = new Mock<IScriptPack>();
                _scriptPackMock1.Setup(p => p.GetContext()).Returns(_contextMock1.Object);
                _scriptPackMock2 = new Mock<IScriptPack>();
                _scriptPackMock2.Setup(p => p.GetContext()).Returns(_contextMock2.Object);
                _scriptPackSession = new ScriptPackSession(new List<IScriptPack> { _scriptPackMock1.Object, _scriptPackMock2.Object }, new string[0]);
                _scriptPackSession.InitializePacks();
            }

            [Fact]
            public void ShouldCallInitializeOnAllScriptPacks()
            {
                _scriptPackMock1.Verify(p => p.Initialize(_scriptPackSession));
                _scriptPackMock2.Verify(p => p.Initialize(_scriptPackSession));
            }
        }

        public class TheTerminateMethod
        {
            private ScriptPackSession _scriptPackSession;
            private Mock<IScriptPack> _scriptPackMock1;
            private Mock<IScriptPack> _scriptPackMock2;
            private Mock<IScriptPackContext> _contextMock1;
            private Mock<IScriptPackContext> _contextMock2;

            public TheTerminateMethod()
            {
                _contextMock1 = new Mock<IScriptPackContext>();
                _contextMock2 = new Mock<IScriptPackContext>();
                _scriptPackMock1 = new Mock<IScriptPack>();
                _scriptPackMock1.Setup(p => p.GetContext()).Returns(_contextMock1.Object);
                _scriptPackMock2 = new Mock<IScriptPack>();
                _scriptPackMock2.Setup(p => p.GetContext()).Returns(_contextMock2.Object);
                _scriptPackSession = new ScriptPackSession(new List<IScriptPack> { _scriptPackMock1.Object, _scriptPackMock2.Object }, new string[0]);
                _scriptPackSession.TerminatePacks();
            }

            [Fact]
            public void ShouldCallTerminateOnAllScriptPacks()
            {
                _scriptPackMock1.Verify(p => p.Terminate());
                _scriptPackMock2.Verify(p => p.Terminate());
            }
        }

        public class TheAddReferenceMethod
        {
            private ScriptPackSession _scriptPackSession = new ScriptPackSession(Enumerable.Empty<IScriptPack>(), new string[0]);

            public TheAddReferenceMethod()
            {
                ((IScriptPackSession)_scriptPackSession).AddReference("ref");
            }

            [Fact]
            public void ShouldAddTheReference()
            {
                _scriptPackSession.References.ShouldContain("ref");
            }
        }

        public class TheImportNamespaceMethod
        {
            private ScriptPackSession _scriptPackSession = new ScriptPackSession(Enumerable.Empty<IScriptPack>(), new string[0]);

            public TheImportNamespaceMethod()
            {
                ((IScriptPackSession)_scriptPackSession).ImportNamespace("ns");
            }

            public void ShouldAddTheNamespace()
            {
                _scriptPackSession.Namespaces.ShouldContain("ns");
            }
        }
    }
}