public static void ConfigurationInitialize(TestContext testContext)
{
// Registra as implementações
IocFactory.Register <IConfigurationUtility, ConfigurationUtilityMock>();
configurationUtility = new Mocks.ConfigurationUtilityMock();
}
public TestsFactory()
{
IocFactory.Register(Component.For <ITest>().ImplementedBy <AuthOnlyTest>("1"));
IocFactory.Register(Component.For <ITest>().ImplementedBy <AuthAndCaptureTest>("2"));
IocFactory.Register(Component.For <ITest>().ImplementedBy <CaptureTest>("3"));
IocFactory.Register(Component.For <ITest>().ImplementedBy <VoidTest>("4"));
IocFactory.Register(Component.For <ITest>().ImplementedBy <RefundTest>("5"));
}
public void IocFactory_Register_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.ImplementedBy <AnotherMock>()
);
}
public ChangeCalculator()
{
// Registra o utilitário de configuração a ser utilizado.
IocFactory.Register <IConfigurationUtility, ConfigurationUtility>();
IocFactory.RegisterNamespace("ChangeMachine.Core.Repository");
this.logUtility = LogUtilityFactory.CreateLogUtility();
this.logUtility.OnLogError += logUtility_OnLogError; //logUtility_OnLogError;
}
public ChangeManager()
{
IocFactory.Register <IConfigurationUtility, ConfigurationUtility>();
IocFactory.Register <IApplicationLogCategoryRepository, ApplicationLogCategoryRepository>();
IocFactory.Register <IApplicationLogRepository, ApplicationLogRepository>();
IocFactory.Register <ILogger, FileLogger>(LogRepositoryEnum.File.ToString());
IocFactory.Register <ILogger, DatabaseLogger>(LogRepositoryEnum.Database.ToString());
IocFactory.Register <ILogger, WindowsEventLogger>(LogRepositoryEnum.WindowsEvent.ToString());
}
public void ResolveWithoutConcrete_Test()
{
IocFactory.Reset();
IocFactory.Register(
Component.For <IMultipleParametersConstructor>().ImplementedBy <MultipleParametersConstructor>()
);
IMultipleParametersConstructor person = IocFactory.Resolve <IMultipleParametersConstructor>();
}
public void IocFactory_ResolveConstructorParameter2_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
);
IConfigurationUtilityMock mock = IocFactory.Resolve <IConfigurationUtilityMock>(DateTime.Now);
Assert.IsNotNull(mock);
}
public void IocFactory_MultipleComponentsForSameInterface_Test()
{
IocFactory.Register(Component.For <IPerson>().ImplementedBy <Pedro>("P"));
IocFactory.Register(Component.For <IPerson>().ImplementedBy <Odilon>("O"));
IocFactory.Register(Component.For <IPerson>().ImplementedBy <Guilherme>("G"));
IPerson person = IocFactory.ResolveByName <IPerson>("O");
Assert.IsNotNull(person);
Assert.IsInstanceOfType(person, typeof(Odilon));
}
public void IocFactory_ResolveContructorParameter_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
);
IConfigurationUtilityMock mock = IocFactory.Resolve <IConfigurationUtilityMock>("connectionString");
Assert.IsNotNull(mock);
}
public void TestInit()
{
MundipaggSettingsMock settings = new MundipaggSettingsMock {
Authorization = "", CustomerId = ""
};
IocFactory.Register(
Component.For <IMundipaggSettings>()
.Instance(settings)
);
}
public void IocFactory_ResolveWithParameterRegisteredDependency_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.ImplementedBy <AnotherMock>()
);
IConfigurationUtilityMock mock = IocFactory.Resolve <IConfigurationUtilityMock>();
Assert.IsNotNull(mock);
}
public void IocFactory_ResolvedNamed_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.ImplementedBy <AnotherMock>("Another")
);
IConfigurationUtilityMock mock = IocFactory.ResolveByName <IConfigurationUtilityMock>("Another");
Assert.IsNotNull(mock);
Assert.IsInstanceOfType(mock, typeof(AnotherMock));
}
public void IocFactory_GetDefaultType_Test()
{
IocFactory.Register(
Component.For <IPerson>().ImplementedBy <Pedro>("P"),
Component.For <IPerson>().ImplementedBy <Odilon>("O").IsDefault(),
Component.For <IPerson>().ImplementedBy <Guilherme>("G")
);
IPerson person = IocFactory.Resolve <IPerson>();
Assert.IsNotNull(person);
Assert.IsInstanceOfType(person, typeof(Odilon));
}
public void MultipleParametersConstructors_Test()
{
IocFactory.Reset();
IocFactory.Register(
Component.For <IMultipleParametersConstructor>().ImplementedBy <MultipleParametersConstructor>()
);
IMultipleParametersConstructor constructor = IocFactory.Resolve <IMultipleParametersConstructor>(string.Empty, string.Empty, 66, "Banana");
Assert.IsNotNull(constructor);
Assert.AreEqual("Banana", constructor.Fruta);
}
public static TInterface CreateMock <TInterface>(bool autoRegisterToContainer = false) where TInterface : class
{
TInterface mock = DynamicProxy.NewInstance <TInterface>(new IInterceptor[] { new MockerInterceptor() }, new Type[] { typeof(IMockObject) }) as TInterface;
// Verifica se o mock deve ser registrado no container de injeção de dependencia.
if (autoRegisterToContainer == true)
{
IocFactory.Register(
Component.For <TInterface>().Instance(mock)
);
}
return(mock);
}
public void Intercept_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>(),
Component.For <ILog>()
.ResolveDependencies()
.ImplementedBy <FileLog>()
.ImplementedBy <EventViewerLog>()
.Interceptor <LogInterceptor>()
);
ILog log = IocFactory.Resolve <ILog>();
log.Save("Test", "Test Message");
}
public void IocFactory_Resolve_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
);
IConfigurationUtilityMock mock = IocFactory.Resolve <IConfigurationUtilityMock>();
Assert.IsNotNull(mock);
mock.TestValue = "Banana";
IConfigurationUtilityMock mock2 = IocFactory.Resolve <IConfigurationUtilityMock>();
Assert.IsNotNull(mock2);
Assert.IsNull(mock2.TestValue);
}
public void CalculateChange_NegativeProductAmount()
{
ChangeManager changeManager = new ChangeManager();
IocFactory.Register <IConfigurationUtility, ConfigurationUtilityMock>();
ChangeRequest changeRequest = new ChangeRequest();
changeRequest.PaidAmount = 100;
changeRequest.ProductAmount = -100;
ChangeResponse changeResponse = changeManager.CalculateChange(changeRequest);
Assert.IsNotNull(changeResponse);
Assert.IsNotNull(changeResponse.ErrorReport);
Assert.AreEqual(changeResponse.ErrorReport.Count(), 1);
Assert.AreEqual(changeResponse.ErrorReport[0].Field, "ChangeRequest.ProductAmount");
Assert.AreEqual(changeResponse.ChangeAmount, 0);
}
public void UserTypeAndPrimitiveTypeConstructor_Test()
{
IocFactory.Reset();
IocFactory.Register(
Component.For <IMultipleParametersConstructor>().ImplementedBy <MultipleParametersConstructor>()
);
IUserPrincipal userPrincipal = new UserPrincipal();
userPrincipal.Login = "******";
string accessToken = Guid.NewGuid().ToString();
IMultipleParametersConstructor constructor = IocFactory.Resolve <IMultipleParametersConstructor>(userPrincipal, accessToken);
Assert.IsNotNull(constructor);
Assert.AreEqual("banana", userPrincipal.Login);
}
public void IocFactory_RegisterInstance()
{
IPerson pedro = new Pedro();
pedro.Age = 90;
IocFactory.Register(
Component.For <IPerson>()
.ImplementedBy <Odilon>()
.Instance(pedro).IsDefault()
.ImplementedBy <Guilherme>()
);
IPerson person = IocFactory.Resolve <IPerson>();
Assert.IsNotNull(person);
Assert.IsInstanceOfType(person, typeof(Pedro));
Assert.AreEqual(90, person.Age);
}
/// <summary>
/// Obtém o processador adequado para o valor do troco a ser retornado.
/// </summary>
/// <param name="changeAmount">Valor do troco a ser processado.</param>
/// <returns>Retorna o processador a ser utilizado para o cálculo do troco.</returns>
public static IProcessor Create(ulong changeAmount)
{
IocFactory.Register <IProcessor, BillProcessor>();
IocFactory.Register <IProcessor, CandyProcessor>();
IocFactory.Register <IProcessor, CoinProcessor>();
IocFactory.Register <IProcessor, DilmaProcessor>();
// Lista dos tipos de processadores disponíveis.
IProcessor[] processorCollection = new IProcessor[] {
IocFactory.ResolveSpecific <IProcessor>("ChangeMachine.Core.Processors.BillProcessor"),
IocFactory.ResolveSpecific <IProcessor>("ChangeMachine.Core.Processors.CandyProcessor"),
IocFactory.ResolveSpecific <IProcessor>("ChangeMachine.Core.Processors.CoinProcessor"),
IocFactory.ResolveSpecific <IProcessor>("ChangeMachine.Core.Processors.DilmaProcessor")
};
// Adicione novos processadores acima desta linha.
Nullable <uint> closestValue = null;
BaseProcessor selectedProcessor = null;
// Analisa cada processador e localiza aquele que possui um valor mais próximo possível do troco a ser retornado.
foreach (BaseProcessor processor in processorCollection)
{
// Obtém o valor mais próximo do troco, deste processador.
IEnumerable <uint> currentClosestValue = processor.GetAcceptedValues().Where(v => v <= changeAmount);
if (currentClosestValue.Any() == false)
{
continue;
}
// Se o valor encontrado estiver mais próximo do valor do troco anteriormente encontrado, substitui o valor.
if (closestValue.HasValue == false || currentClosestValue.Max() > closestValue)
{
closestValue = currentClosestValue.Max();
selectedProcessor = processor;
}
}
return(selectedProcessor);
}
public void IocFactory_Interceptor_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.Interceptor <LogInterceptor>()
);
IConfigurationUtilityMock mock = IocFactory.Resolve <IConfigurationUtilityMock>();
Assert.IsNotNull(mock);
mock.TestValue = "Teste";
Assert.AreEqual("Intercepted Teste", mock.TestValue);
string name = mock.GetName("Terra");
Assert.AreEqual("Intercepted Terra Mock 1", name);
string testValue = mock.TestValue;
Assert.AreEqual("Intercepted Teste", testValue);
}
public void Calculate_GetChangeDataWithCoinsOnly_Test()
{
ConfigurationUtilityMock mock = new ConfigurationUtilityMock();
mock.LogPath = "C:\\Logs\\Test";
IocFactory.Register(
Component.For <IConfigurationUtility>().Instance(mock),
Component.For <ILog>().ImplementedBy <FileLog>().IsDefault()
);
CadeMeuTrocoManager manager = new CadeMeuTrocoManager();
CalculateRequest request = new CalculateRequest();
request.ProductAmountInCents = 100;
request.PaidAmountInCents = 140;
CalculateResponse response = manager.Calculate(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Success == true);
Assert.IsTrue(response.ChangeAmount == 40);
Assert.IsTrue(response.ChangeCollection.Count() == 1);
ChangeData changeData = response.ChangeCollection.First();
Assert.IsTrue(changeData.Name == "Coin");
Assert.IsTrue(changeData.ChangeDictionary.Count() == 3);
Assert.IsTrue(changeData.ChangeDictionary.ContainsKey(25) == true);
Assert.IsTrue(changeData.ChangeDictionary.ContainsKey(10) == true);
Assert.IsTrue(changeData.ChangeDictionary.ContainsKey(5) == true);
Assert.AreEqual(1, changeData.ChangeDictionary[25]);
Assert.AreEqual(1, changeData.ChangeDictionary[10]);
Assert.AreEqual(1, changeData.ChangeDictionary[5]);
}
public void Configuration(IAppBuilder app)
{
ConfigureAuth(app);
IocFactory.Register(
Component.For <IConfigurationUtility>().ImplementedBy <ConfigurationUtility>());
}
public void AbstractContructorParameter_Test()
{
IocFactory.Register(Component.For <IMyComponent>().ImplementedBy <MyComponent>());
IMyComponent myComponent = IocFactory.Resolve <IMyComponent>(new Dependency());
}
public static void ClassInitialize(TestContext testContext)
{
IocFactory.Register <IConfigurationUtility, ConfigurationUtilityMock>();
}
