SimonG
/
LightweightIocContainer
mirror of https://github.com/SimonG96/LightweightIocContainer.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- fix unit tests

Browse Source
pull/32/head
Simon Gockner 7 years ago
parent 145a64ec5d
commit b6bfc95ace
2 changed files with 100 additions and 89 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      Test.LightweightIocContainer/AssemblyInstallerTest.cs
  2. 174
      Test.LightweightIocContainer/IocContainerTest.cs

15
Test.LightweightIocContainer/AssemblyInstallerTest.cs
Unescape View File

@ -5,6 +5,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection; using System.Reflection;
using JetBrains.Annotations;
using LightweightIocContainer; using LightweightIocContainer;
using LightweightIocContainer.Installers; using LightweightIocContainer.Installers;
using LightweightIocContainer.Interfaces; using LightweightIocContainer.Interfaces;
@ -18,6 +19,8 @@ namespace Test.LightweightIocContainer
[TestFixture] [TestFixture]
public class AssemblyInstallerTest public class AssemblyInstallerTest
{ {
#region TestClasses
private class TestInstaller : IIocInstaller private class TestInstaller : IIocInstaller
{ {
public void Install(IIocContainer container) public void Install(IIocContainer container)
@ -26,6 +29,14 @@ namespace Test.LightweightIocContainer
} }
} }
[UsedImplicitly]
public class AssemblyWrapper : Assembly
{
}
#endregion TestClasses
[Test] [Test]
public void TestInstall() public void TestInstall()
{ {
@ -35,7 +46,7 @@ namespace Test.LightweightIocContainer
typeof(TestInstaller) typeof(TestInstaller)
}; };
Mock<Assembly> assemblyMock = new Mock<Assembly>(); Mock<AssemblyWrapper> assemblyMock = new Mock<AssemblyWrapper>();
assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray); assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray);
Mock<IIocContainer> iocContainerMock = new Mock<IIocContainer>(); Mock<IIocContainer> iocContainerMock = new Mock<IIocContainer>();
@ -62,7 +73,7 @@ namespace Test.LightweightIocContainer
typeof(TestInstaller) typeof(TestInstaller)
}; };
Mock<Assembly> assemblyMock = new Mock<Assembly>(); Mock<AssemblyWrapper> assemblyMock = new Mock<AssemblyWrapper>();
assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray); assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray);
IIocContainer iocContainer = new IocContainer(); IIocContainer iocContainer = new IocContainer();

174
Test.LightweightIocContainer/IocContainerTest.cs
Unescape View File

@ -26,7 +26,7 @@ namespace Test.LightweightIocContainer
ITest Create(); ITest Create();
ITest Create(string name); ITest Create(string name);
ITest Create(MultitonScope scope); ITest Create(MultitonScope scope);
ITest Create(bool someBool, string name = null); ITest CreateTest(string name = null);
void ClearMultitonInstance<T>(); void ClearMultitonInstance<T>();
} }
@ -56,7 +56,7 @@ namespace Test.LightweightIocContainer
} }
public TestConstructor(bool someBool, Test test, string name) public TestConstructor(Test test, string name = null)
{ {
} }
@ -67,20 +67,34 @@ namespace Test.LightweightIocContainer
} }
#endregion #endregion TestClasses
private IIocContainer _iocContainer;
[SetUp]
public void SetUp()
{
_iocContainer = new IocContainer();
}
[TearDown]
public void TearDown()
{
_iocContainer.Dispose();
}
[Test] [Test]
public void TestInstall() public void TestInstall()
{ {
Mock<IIocInstaller> installerMock = new Mock<IIocInstaller>(); Mock<IIocInstaller> installerMock = new Mock<IIocInstaller>();
IIocContainer returnedContainer = _iocContainer.Install(installerMock.Object);
IIocContainer iocContainer = new IocContainer();
IIocContainer returnedContainer = iocContainer.Install(installerMock.Object);
installerMock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once); installerMock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once);
Assert.AreEqual(iocContainer, returnedContainer); Assert.AreEqual(_iocContainer, returnedContainer);
} }
[Test] [Test]
@ -90,67 +104,55 @@ namespace Test.LightweightIocContainer
Mock<IIocInstaller> installer2Mock = new Mock<IIocInstaller>(); Mock<IIocInstaller> installer2Mock = new Mock<IIocInstaller>();
Mock<IIocInstaller> installer3Mock = new Mock<IIocInstaller>(); Mock<IIocInstaller> installer3Mock = new Mock<IIocInstaller>();
IIocContainer iocContainer = new IocContainer(); IIocContainer returnedContainer = _iocContainer.Install(installer1Mock.Object, installer2Mock.Object, installer3Mock.Object);
IIocContainer returnedContainer = iocContainer.Install(installer1Mock.Object, installer2Mock.Object, installer3Mock.Object);
installer1Mock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once); installer1Mock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once);
installer2Mock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once); installer2Mock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once);
installer3Mock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once); installer3Mock.Verify(m => m.Install(It.IsAny<IIocContainer>()), Times.Once);
Assert.AreEqual(iocContainer, returnedContainer); Assert.AreEqual(_iocContainer, returnedContainer);
} }
[Test] [Test]
public void TestRegister() public void TestRegister()
{ {
IIocContainer iocContainer = new IocContainer(); Assert.DoesNotThrow(() => _iocContainer.Register(RegistrationFactory.Register(typeof(ITest), typeof(Test))));
Assert.DoesNotThrow(() => _iocContainer.Register(RegistrationFactory.RegisterFactory(typeof(ITestFactory), _iocContainer)));
Assert.DoesNotThrow(() => iocContainer.Register(RegistrationFactory.Register(typeof(ITest), typeof(Test))));
Assert.DoesNotThrow(() => iocContainer.Register(RegistrationFactory.RegisterFactory(typeof(ITestFactory), iocContainer)));
} }
[Test] [Test]
public void TestRegisterMultiple() public void TestRegisterMultiple()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
MultipleRegistrationException exception = Assert.Throws<MultipleRegistrationException>(() => _iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>()));
iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
MultipleRegistrationException exception = Assert.Throws<MultipleRegistrationException>(() => iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>()));
Assert.AreEqual(typeof(ITest), exception.Type); Assert.AreEqual(typeof(ITest), exception.Type);
} }
[Test] [Test]
public void TestRegisterFactoryWithoutCreate() public void TestRegisterFactoryWithoutCreate()
{ {
IIocContainer iocContainer = new IocContainer(); Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactoryNoCreate>(_iocContainer)));
Assert.Throws<InvalidFactoryRegistrationException>(() => iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactoryNoCreate>(iocContainer)));
} }
[Test] [Test]
public void TestRegisterFactoryClearMultitonsNonGeneric() public void TestRegisterFactoryClearMultitonsNonGeneric()
{ {
IIocContainer iocContainer = new IocContainer(); Assert.Throws<IllegalAbstractMethodCreationException>(() => _iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactoryNonGenericClear>(_iocContainer)));
Assert.Throws<IllegalAbstractMethodCreationException>(() => iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactoryNonGenericClear>(iocContainer)));
} }
[Test] [Test]
public void TestResolveNotRegistered() public void TestResolveNotRegistered()
{ {
IIocContainer iocContainer = new IocContainer(); TypeNotRegisteredException exception = Assert.Throws<TypeNotRegisteredException>(() => _iocContainer.Resolve<ITest>());
TypeNotRegisteredException exception = Assert.Throws<TypeNotRegisteredException>(() => iocContainer.Resolve<ITest>());
Assert.AreEqual(typeof(ITest), exception.Type); Assert.AreEqual(typeof(ITest), exception.Type);
} }
[Test] [Test]
public void TestResolve() public void TestResolve()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
ITest resolvedTest = iocContainer.Resolve<ITest>(); ITest resolvedTest = _iocContainer.Resolve<ITest>();
Assert.IsInstanceOf<Test>(resolvedTest); Assert.IsInstanceOf<Test>(resolvedTest);
} }
@ -158,10 +160,9 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveWithParams() public void TestResolveWithParams()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>());
iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>());
ITest resolvedTest = iocContainer.Resolve<ITest>("Test", new Test()); ITest resolvedTest = _iocContainer.Resolve<ITest>("Test", new Test());
Assert.IsInstanceOf<TestConstructor>(resolvedTest); Assert.IsInstanceOf<TestConstructor>(resolvedTest);
} }
@ -169,11 +170,10 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveWithMissingParam() public void TestResolveWithMissingParam()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>());
iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>()); _iocContainer.Register(RegistrationFactory.Register<Test, Test>()); //this registration is abnormal and should only be used in unit tests
iocContainer.Register(RegistrationFactory.Register<Test, Test>()); //this registration is abnormal and should only be used in unit tests
ITest resolvedTest = iocContainer.Resolve<ITest>("Test"); ITest resolvedTest = _iocContainer.Resolve<ITest>("Test");
Assert.IsInstanceOf<TestConstructor>(resolvedTest); Assert.IsInstanceOf<TestConstructor>(resolvedTest);
} }
@ -181,10 +181,9 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveReflection() public void TestResolveReflection()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
object resolvedTest = iocContainer.Resolve(typeof(ITest), null); object resolvedTest = _iocContainer.Resolve(typeof(ITest), null);
Assert.IsInstanceOf<Test>(resolvedTest); Assert.IsInstanceOf<Test>(resolvedTest);
} }
@ -192,11 +191,10 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveSingleton() public void TestResolveSingleton()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test>(Lifestyle.Singleton));
iocContainer.Register(RegistrationFactory.Register<ITest, Test>(Lifestyle.Singleton));
ITest resolvedTest = iocContainer.Resolve<ITest>(); ITest resolvedTest = _iocContainer.Resolve<ITest>();
ITest secondResolvedTest = iocContainer.Resolve<ITest>(); ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
Assert.AreEqual(resolvedTest, secondResolvedTest); Assert.AreEqual(resolvedTest, secondResolvedTest);
} }
@ -204,15 +202,14 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveMultiton() public void TestResolveMultiton()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
MultitonScope scope1 = new MultitonScope(); MultitonScope scope1 = new MultitonScope();
MultitonScope scope2 = new MultitonScope(); MultitonScope scope2 = new MultitonScope();
ITest resolvedTest1 = iocContainer.Resolve<ITest>(scope1); ITest resolvedTest1 = _iocContainer.Resolve<ITest>(scope1);
ITest resolvedTest2 = iocContainer.Resolve<ITest>(scope1); ITest resolvedTest2 = _iocContainer.Resolve<ITest>(scope1);
ITest resolvedTest3 = iocContainer.Resolve<ITest>(scope2); ITest resolvedTest3 = _iocContainer.Resolve<ITest>(scope2);
Assert.AreSame(resolvedTest1, resolvedTest2); Assert.AreSame(resolvedTest1, resolvedTest2);
Assert.AreNotSame(resolvedTest1, resolvedTest3); Assert.AreNotSame(resolvedTest1, resolvedTest3);
@ -222,31 +219,28 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveMultitonNoArgs() public void TestResolveMultitonNoArgs()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => iocContainer.Resolve<ITest>()); MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>());
Assert.AreEqual(typeof(ITest), exception.Type); Assert.AreEqual(typeof(ITest), exception.Type);
} }
[Test] [Test]
public void TestResolveMultitonWrongArgs() public void TestResolveMultitonWrongArgs()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => iocContainer.Resolve<ITest>(new object())); MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>(new object()));
Assert.AreEqual(typeof(ITest), exception.Type); Assert.AreEqual(typeof(ITest), exception.Type);
} }
[Test] [Test]
public void TestResolveTransient() public void TestResolveTransient()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
ITest resolvedTest = iocContainer.Resolve<ITest>(); ITest resolvedTest = _iocContainer.Resolve<ITest>();
ITest secondResolvedTest = iocContainer.Resolve<ITest>(); ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
Assert.AreNotEqual(resolvedTest, secondResolvedTest); Assert.AreNotEqual(resolvedTest, secondResolvedTest);
} }
@ -254,11 +248,10 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveFactory() public void TestResolveFactory()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test>()); _iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(_iocContainer));
iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(iocContainer));
ITestFactory testFactory = iocContainer.Resolve<ITestFactory>(); ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
Assert.IsInstanceOf<ITestFactory>(testFactory); Assert.IsInstanceOf<ITestFactory>(testFactory);
} }
@ -266,11 +259,10 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveFromFactory() public void TestResolveFromFactory()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test>()); _iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(_iocContainer));
iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(iocContainer));
ITestFactory testFactory = iocContainer.Resolve<ITestFactory>(); ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
ITest createdTest = testFactory.Create(); ITest createdTest = testFactory.Create();
Assert.IsInstanceOf<Test>(createdTest); Assert.IsInstanceOf<Test>(createdTest);
@ -279,12 +271,11 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveFromFactoryWithParams() public void TestResolveFromFactoryWithParams()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>());
iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>()); _iocContainer.Register(RegistrationFactory.Register<Test, Test>()); //this registration is abnormal and should only be used in unit tests
iocContainer.Register(RegistrationFactory.Register<Test, Test>()); //this registration is abnormal and should only be used in unit tests _iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(_iocContainer));
iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(iocContainer));
ITestFactory testFactory = iocContainer.Resolve<ITestFactory>(); ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
ITest createdTest = testFactory.Create("Test"); ITest createdTest = testFactory.Create("Test");
Assert.IsInstanceOf<TestConstructor>(createdTest); Assert.IsInstanceOf<TestConstructor>(createdTest);
@ -293,13 +284,25 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveFromFactoryWithDefaultParamCreate() public void TestResolveFromFactoryWithDefaultParamCreate()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>());
iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>()); _iocContainer.Register(RegistrationFactory.Register<Test, Test>()); //this registration is abnormal and should only be used in unit tests
iocContainer.Register(RegistrationFactory.Register<Test, Test>()); //this registration is abnormal and should only be used in unit tests _iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(_iocContainer));
iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(iocContainer));
ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
ITest createdTest = testFactory.CreateTest();
Assert.IsInstanceOf<TestConstructor>(createdTest);
}
[Test]
public void TestResolveFromFactoryWithDefaultParamCtor()
{
_iocContainer.Register(RegistrationFactory.Register<ITest, TestConstructor>());
_iocContainer.Register(RegistrationFactory.Register<Test, Test>()); //this registration is abnormal and should only be used in unit tests
_iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(_iocContainer));
ITestFactory testFactory = iocContainer.Resolve<ITestFactory>(); ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
ITest createdTest = testFactory.Create(true); ITest createdTest = testFactory.Create();
Assert.IsInstanceOf<TestConstructor>(createdTest); Assert.IsInstanceOf<TestConstructor>(createdTest);
} }
@ -307,14 +310,13 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveMultitonFromFactory() public void TestResolveMultitonFromFactory()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>()); _iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(_iocContainer));
iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(iocContainer));
MultitonScope scope1 = new MultitonScope(); MultitonScope scope1 = new MultitonScope();
MultitonScope scope2 = new MultitonScope(); MultitonScope scope2 = new MultitonScope();
ITestFactory testFactory = iocContainer.Resolve<ITestFactory>(); ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
ITest resolvedTest1 = testFactory.Create(scope1); ITest resolvedTest1 = testFactory.Create(scope1);
ITest resolvedTest2 = testFactory.Create(scope1); ITest resolvedTest2 = testFactory.Create(scope1);
@ -328,15 +330,13 @@ namespace Test.LightweightIocContainer
[Test] [Test]
public void TestResolveMultitonFromFactoryClearInstances() public void TestResolveMultitonFromFactoryClearInstances()
{ {
IIocContainer iocContainer = new IocContainer(); _iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
_iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(_iocContainer));
iocContainer.Register(RegistrationFactory.Register<ITest, Test, MultitonScope>());
iocContainer.Register(RegistrationFactory.RegisterFactory<ITestFactory>(iocContainer));
MultitonScope scope1 = new MultitonScope(); MultitonScope scope1 = new MultitonScope();
MultitonScope scope2 = new MultitonScope(); MultitonScope scope2 = new MultitonScope();
ITestFactory testFactory = iocContainer.Resolve<ITestFactory>(); ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
ITest resolvedTest1 = testFactory.Create(scope1); ITest resolvedTest1 = testFactory.Create(scope1);
ITest resolvedTest2 = testFactory.Create(scope1); ITest resolvedTest2 = testFactory.Create(scope1);

Write Preview
Loading…
Cancel
Save