Skip to content

Commit a5b996c

Browse files
7bitcoder7bitcoder
committed
add factory tests
1 parent 20ca766 commit a5b996c

19 files changed

+502
-28
lines changed

‎Tests/Integration/BasicFactoryTest.cpp‎

Lines changed: 228 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,228 @@
1+
#include <gtest/gtest.h>
2+
#include <memory>
3+
4+
#include "../Helpers/Classes/Basic.hpp"
5+
#include "../Helpers/Classes/CirularDependency.hpp"
6+
#include "SevenBit/DI/Exceptions.hpp"
7+
#include "SevenBit/DI/ServiceCollection.hpp"
8+
9+
class BasicFactoryTest : public testing::Test
10+
{
11+
protected:
12+
static void SetUpTestSuite() {}
13+
14+
BasicFactoryTest() {}
15+
16+
void SetUp() override {}
17+
18+
void TearDown() override {}
19+
20+
~BasicFactoryTest() override = default;
21+
22+
static void TearDownTestSuite() {}
23+
};
24+
25+
// buildServiceProvider Tests
26+
27+
TEST_F(BasicFactoryTest, ShouldFailGetServiceDueToAlreadyRegisteredService)
28+
{
29+
sb::di::ServiceCollection collection;
30+
31+
collection.addSingleton([] { return TestClass1{}; });
32+
collection.addSingleton([] { return TestClass1{}; });
33+
collection.addSingleton([] { return TestClass2{}; });
34+
35+
sb::di::ServiceProviderOptions options;
36+
options.checkServiceGlobalUniqueness = true;
37+
EXPECT_THROW(collection.buildServiceProvider(options), sb::di::ServiceAlreadyRegisteredException);
38+
}
39+
40+
TEST_F(BasicFactoryTest, ShouldNotFailGetServiceDueToAlreadyRegisteredService)
41+
{
42+
sb::di::ServiceCollection collection;
43+
44+
collection.addSingleton([] { return TestClass1{}; });
45+
collection.addSingleton([] { return TestClass1{}; });
46+
collection.addSingleton([] { return TestClass2{}; });
47+
48+
sb::di::ServiceProviderOptions options;
49+
options.checkServiceGlobalUniqueness = false;
50+
EXPECT_NO_THROW(collection.buildServiceProvider(options));
51+
}
52+
53+
// tryGetService Tests
54+
55+
TEST_F(BasicFactoryTest, ShouldTryGetService)
56+
{
57+
auto provider = sb::di::ServiceCollection{}
58+
.addSingleton([] { return TestClass1{}; })
59+
.addScoped([] { return TestClass2{}; })
60+
.addTransient([] { return TestClass3{}; })
61+
.buildServiceProvider();
62+
63+
EXPECT_TRUE(provider.tryGetService<TestClass1>());
64+
EXPECT_TRUE(provider.tryGetService<TestClass2>());
65+
EXPECT_FALSE(provider.tryGetService<TestClass3>());
66+
EXPECT_FALSE(provider.tryGetService<TestClass4>());
67+
}
68+
69+
TEST_F(BasicFactoryTest, ShouldFailTryGetServiceDueToCircularDependency)
70+
{
71+
auto provider = sb::di::ServiceCollection{}
72+
.addSingleton([](CircularDependencyB *b) { return CircularDependencyA{b}; })
73+
.addScoped([](CircularDependencyA *a) { return CircularDependencyB{a}; })
74+
.buildServiceProvider();
75+
76+
EXPECT_THROW(provider.tryGetService<CircularDependencyA>(), sb::di::CircularDependencyException);
77+
}
78+
79+
// getService Tests
80+
81+
TEST_F(BasicFactoryTest, ShouldGetService)
82+
{
83+
auto provider = sb::di::ServiceCollection{}
84+
.addSingleton([] { return TestClass1{}; })
85+
.addScoped([] { return TestClass2{}; })
86+
.addTransient([] { return TestClass3{}; })
87+
.buildServiceProvider();
88+
89+
EXPECT_NO_THROW(provider.getService<TestClass1>());
90+
EXPECT_NO_THROW(provider.getService<TestClass2>());
91+
EXPECT_THROW(provider.getService<TestClass3>(), sb::di::ServiceNotFoundException);
92+
EXPECT_THROW(provider.getService<TestClass4>(), sb::di::ServiceNotFoundException);
93+
}
94+
TEST_F(BasicFactoryTest, ShouldFailGetServiceDueToCircularDependency)
95+
{
96+
97+
auto provider = sb::di::ServiceCollection{}
98+
.addSingleton([](CircularDependencyB *b) { return CircularDependencyA{b}; })
99+
.addScoped([](CircularDependencyA *a) { return CircularDependencyB{a}; })
100+
.buildServiceProvider();
101+
102+
EXPECT_THROW(provider.getService<CircularDependencyA>(), sb::di::CircularDependencyException);
103+
}
104+
105+
// getServices Tests
106+
107+
TEST_F(BasicFactoryTest, ShouldFailGetServicesDueToCircularDependency)
108+
{
109+
auto provider = sb::di::ServiceCollection{}
110+
.addSingleton([](CircularDependencyB *b) { return CircularDependencyA{b}; })
111+
.addScoped([](CircularDependencyA *a) { return CircularDependencyB{a}; })
112+
.buildServiceProvider();
113+
114+
EXPECT_THROW(provider.getServices<CircularDependencyA>(), sb::di::CircularDependencyException);
115+
}
116+
117+
// tryCreateService Tests
118+
119+
TEST_F(BasicFactoryTest, ShouldTryCreateService)
120+
{
121+
auto provider = sb::di::ServiceCollection{}
122+
.addSingleton([] { return TestClass1{}; })
123+
.addScoped([] { return TestClass2{}; })
124+
.addTransient([] { return TestClass3{}; })
125+
.buildServiceProvider();
126+
127+
EXPECT_FALSE(provider.tryCreateService<TestClass1>());
128+
EXPECT_FALSE(provider.tryCreateService<TestClass2>());
129+
EXPECT_TRUE(provider.tryCreateService<TestClass3>());
130+
EXPECT_FALSE(provider.tryCreateService<TestClass4>());
131+
}
132+
133+
TEST_F(BasicFactoryTest, ShouldFailTryCreateServiceDueToCircularDependency)
134+
{
135+
auto provider = sb::di::ServiceCollection{}
136+
.addTransient([](std::unique_ptr<CircularDependencyUniqueB> b) {
137+
return CircularDependencyUniqueA{std::move(b)};
138+
})
139+
.addTransient([](std::unique_ptr<CircularDependencyUniqueA> a) {
140+
return CircularDependencyUniqueB{std::move(a)};
141+
})
142+
.buildServiceProvider();
143+
144+
EXPECT_THROW(provider.tryCreateService<CircularDependencyUniqueA>(), sb::di::CircularDependencyException);
145+
}
146+
147+
// createService Tests
148+
149+
TEST_F(BasicFactoryTest, ShouldCreateService)
150+
{
151+
auto provider = sb::di::ServiceCollection{}
152+
.addSingleton([] { return TestClass1{}; })
153+
.addScoped([] { return TestClass2{}; })
154+
.addTransient([] { return TestClass3{}; })
155+
.buildServiceProvider();
156+
157+
EXPECT_THROW(provider.createService<TestClass1>(), sb::di::ServiceNotFoundException);
158+
EXPECT_THROW(provider.createService<TestClass2>(), sb::di::ServiceNotFoundException);
159+
EXPECT_NO_THROW(provider.createService<TestClass3>());
160+
EXPECT_THROW(provider.createService<TestClass4>(), sb::di::ServiceNotFoundException);
161+
}
162+
163+
TEST_F(BasicFactoryTest, ShouldFailCreateServiceDueToCircularDependency)
164+
{
165+
auto provider = sb::di::ServiceCollection{}
166+
.addTransient([](std::unique_ptr<CircularDependencyUniqueB> b) {
167+
return CircularDependencyUniqueA{std::move(b)};
168+
})
169+
.addTransient([](std::unique_ptr<CircularDependencyUniqueA> a) {
170+
return CircularDependencyUniqueB{std::move(a)};
171+
})
172+
.buildServiceProvider();
173+
174+
EXPECT_THROW(provider.createService<CircularDependencyUniqueA>(), sb::di::CircularDependencyException);
175+
}
176+
177+
TEST_F(BasicFactoryTest, ShouldNotCreateSelfService)
178+
{
179+
auto provider = sb::di::ServiceCollection{}.buildServiceProvider();
180+
181+
EXPECT_THROW(provider.createService<sb::di::ServiceProvider>(), sb::di::ServiceNotFoundException);
182+
}
183+
184+
// createServiceInPlace Tests
185+
186+
TEST_F(BasicFactoryTest, ShouldCreateServiceInPlace)
187+
{
188+
auto provider = sb::di::ServiceCollection{}
189+
.addSingleton([] { return TestClass1{}; })
190+
.addScoped([] { return TestClass2{}; })
191+
.addTransient([] { return TestClass3{}; })
192+
.buildServiceProvider();
193+
194+
EXPECT_THROW(provider.createServiceInPlace<TestClass1>(), sb::di::ServiceNotFoundException);
195+
EXPECT_THROW(provider.createServiceInPlace<TestClass2>(), sb::di::ServiceNotFoundException);
196+
EXPECT_NO_THROW(provider.createServiceInPlace<TestClass3>());
197+
EXPECT_THROW(provider.createServiceInPlace<TestClass4>(), sb::di::ServiceNotFoundException);
198+
}
199+
200+
TEST_F(BasicFactoryTest, ShouldFailCreateServiceInPlaceDueToCircularDependency)
201+
{
202+
auto provider = sb::di::ServiceCollection{}
203+
.addTransient([](std::unique_ptr<CircularDependencyUniqueB> b) {
204+
return CircularDependencyUniqueA{std::move(b)};
205+
})
206+
.addTransient([](std::unique_ptr<CircularDependencyUniqueA> a) {
207+
return CircularDependencyUniqueB{std::move(a)};
208+
})
209+
.buildServiceProvider();
210+
211+
EXPECT_THROW(provider.createServiceInPlace<CircularDependencyUniqueA>(), sb::di::CircularDependencyException);
212+
}
213+
214+
// createServices Tests
215+
216+
TEST_F(BasicFactoryTest, ShouldFaildCreateServicesDueToCircularDependency)
217+
{
218+
auto provider = sb::di::ServiceCollection{}
219+
.addTransient([](std::unique_ptr<CircularDependencyUniqueB> b) {
220+
return CircularDependencyUniqueA{std::move(b)};
221+
})
222+
.addTransient([](std::unique_ptr<CircularDependencyUniqueA> a) {
223+
return CircularDependencyUniqueB{std::move(a)};
224+
})
225+
.buildServiceProvider();
226+
227+
EXPECT_THROW(provider.createServices<CircularDependencyUniqueA>(), sb::di::CircularDependencyException);
228+
}

0 commit comments

Comments
 (0)