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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
namespace System.Data.Entity.Config
{
using Moq;
using Xunit;
public class InternalConfigurationTests
{
public class AddAppConfigResolver
{
[Fact]
public void AddAppConfigResolver_adds_a_resolver_to_the_app_config_chain()
{
var mockAppConfigChain = new Mock<ResolverChain>();
var resolver = new Mock<IDbDependencyResolver>().Object;
new InternalConfiguration(
mockAppConfigChain.Object, new Mock<ResolverChain>().Object,
new RootDependencyResolver()).
AddAppConfigResolver(resolver);
mockAppConfigChain.Verify(m => m.Add(resolver));
}
}
public class RegisterSingleton
{
[Fact]
public void Adds_a_singleton_resolver()
{
var mockNormalChain = new Mock<ResolverChain>();
new InternalConfiguration(
new Mock<ResolverChain>().Object, mockNormalChain.Object,
new RootDependencyResolver()).RegisterSingleton(new object(), null);
mockNormalChain.Verify(m => m.Add(It.IsAny<SingletonDependencyResolver<object>>()));
}
}
public class GetService
{
[Fact]
public void Queries_resolvers_for_service()
{
var mockNormalChain = new Mock<ResolverChain>();
new InternalConfiguration(
new Mock<ResolverChain>().Object, mockNormalChain.Object,
new RootDependencyResolver()).GetService<object>(42);
mockNormalChain.Verify(m => m.GetService(typeof(object), 42));
}
}
public class AddDependencyResolver
{
[Fact]
public void AddDependencyResolver_adds_a_resolver_to_the_normal_chain()
{
var mockNormalChain = new Mock<ResolverChain>();
var resolver = new Mock<IDbDependencyResolver>().Object;
new InternalConfiguration(
new Mock<ResolverChain>().Object, mockNormalChain.Object,
new RootDependencyResolver()).AddDependencyResolver(resolver);
mockNormalChain.Verify(m => m.Add(resolver));
}
[Fact]
public void AddDependencyResolver_adds_a_resolver_to_the_app_config_chain_when_override_flag_is_used()
{
var mockAppConfigChain = new Mock<ResolverChain>();
var resolver = new Mock<IDbDependencyResolver>().Object;
new InternalConfiguration(
mockAppConfigChain.Object, new Mock<ResolverChain>().Object,
new RootDependencyResolver()).AddDependencyResolver(resolver, overrideConfigFile: true);
mockAppConfigChain.Verify(m => m.Add(resolver));
}
}
public class DependencyResolver
{
[Fact]
public void DependencyResolver_returns_the_dependency_resolver_in_use()
{
var mockAppConfigChain = new Mock<ResolverChain>();
var mockNormalChain = new Mock<ResolverChain>();
var config = new InternalConfiguration(
mockAppConfigChain.Object, mockNormalChain.Object,
new RootDependencyResolver());
var resolver = (CompositeResolver<ResolverChain, ResolverChain>)config.DependencyResolver;
Assert.Same(mockAppConfigChain.Object, resolver.First);
Assert.Same(mockNormalChain.Object, resolver.Second);
}
}
public class RootResolver
{
[Fact]
public void RootResolver_returns_the_root_resolver()
{
var rootResolver = new RootDependencyResolver();
var config = new InternalConfiguration(new Mock<ResolverChain>().Object, new Mock<ResolverChain>().Object, rootResolver);
Assert.Same(rootResolver, config.RootResolver);
}
[Fact]
public void RootResolver_is_added_to_the_non_app_config_resolver_chain()
{
var normalChain = new ResolverChain();
var mockRootResolver = new Mock<RootDependencyResolver>();
new InternalConfiguration(new Mock<ResolverChain>().Object, normalChain, mockRootResolver.Object);
normalChain.GetService<object>("Foo");
mockRootResolver.Verify(m => m.GetService(typeof(object), "Foo"));
}
}
public class SwitchInRootResolver
{
[Fact]
public void SwitchInRootResolver_swicthes_in_given_root_resolver()
{
var configuration = new DbConfiguration().InternalConfiguration;
var mockRootResolver = new Mock<RootDependencyResolver>();
configuration.SwitchInRootResolver(mockRootResolver.Object);
Assert.Same(mockRootResolver.Object, configuration.RootResolver);
configuration.DependencyResolver.GetService<object>("Foo");
mockRootResolver.Verify(m => m.GetService(typeof(object), "Foo"));
}
[Fact]
public void SwitchInRootResolver_leaves_other_resolvers_intact()
{
var configuration = new DbConfiguration().InternalConfiguration;
var mockResolver = new Mock<IDbDependencyResolver>();
configuration.AddDependencyResolver(mockResolver.Object);
configuration.SwitchInRootResolver(new Mock<RootDependencyResolver>().Object);
configuration.DependencyResolver.GetService<object>("Foo");
mockResolver.Verify(m => m.GetService(typeof(object), "Foo"));
}
}
public class ResolverSnapshot
{
[Fact]
public void ResolverSnapshot_returns_copy_of_resolver_chain()
{
var configuration = new DbConfiguration().InternalConfiguration;
var resolver1 = new Mock<IDbDependencyResolver>();
configuration.AddDependencyResolver(resolver1.Object);
var snapshot = configuration.ResolverSnapshot;
var resolver2 = new Mock<IDbDependencyResolver>();
configuration.AddDependencyResolver(resolver2.Object);
snapshot.GetService<object>("Foo");
resolver1.Verify(m => m.GetService(typeof(object), "Foo"), Times.Once());
resolver2.Verify(m => m.GetService(typeof(object), "Foo"), Times.Never());
}
[Fact]
public void ResolverSnapshot_returns_resolvers_in_correct_order()
{
var callOrder = "";
var configResolver = new Mock<IDbDependencyResolver>();
configResolver.Setup(m => m.GetService(typeof(object), "Foo")).Callback(() => callOrder += " Config");
var configChain = new ResolverChain();
configChain.Add(configResolver.Object);
var rootResolver = new Mock<RootDependencyResolver>();
rootResolver.Setup(m => m.GetService(typeof(object), "Foo")).Callback(() => callOrder += " Root");
var configuration = new DbConfiguration(new InternalConfiguration(configChain, new ResolverChain(), rootResolver.Object)).InternalConfiguration;
var normalResolver = new Mock<IDbDependencyResolver>();
normalResolver.Setup(m => m.GetService(typeof(object), "Foo")).Callback(() => callOrder += " Normal");
configuration.AddDependencyResolver(normalResolver.Object);
var overrideResolver = new Mock<IDbDependencyResolver>();
overrideResolver.Setup(m => m.GetService(typeof(object), "Foo")).Callback(() => callOrder += " Override");
configuration.AddDependencyResolver(overrideResolver.Object, overrideConfigFile: true);
configuration.ResolverSnapshot.GetService<object>("Foo");
Assert.Equal(" Override Config Normal Root", callOrder);
}
}
}
}
|
