public FileLog()
{
IConfigurationUtility configurationUtility = IocFactory.Resolve <IConfigurationUtility>();
this.LogPath = configurationUtility.LogPath;
this.FileName = DateTime.Now.ToString("yyyyMMdd");
}
static CreditCard()
{
IMundipaggSettings settings = IocFactory.Resolve <IMundipaggSettings>();
Authorization = settings.Authorization;
CustomerId = settings.CustomerId;
//ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
}
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 bool Insert(ApplicationLogEntity entity)
{
string query = @"INSERT INTO ApplicationLog (CategoryTypeId, MethodName, LogData)
VALUES (@CategoryTypeId, @MethodName, @LogData);";
IConfigurationUtility utility = IocFactory.Resolve <IConfigurationUtility>();
using (DatabaseConnector databaseConnector = new DatabaseConnector(utility.DatabaseConnection)) {
return(databaseConnector.ExecuteNonQuery(query, entity) > 0);
}
}
public void IocFactory_ResolveContructorParameter_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
);
IConfigurationUtilityMock mock = IocFactory.Resolve <IConfigurationUtilityMock>("connectionString");
Assert.IsNotNull(mock);
}
public bool Save(string methodName, string logData, CategoryType categoryType)
{
IApplicationLogRepository repository = IocFactory.Resolve <IApplicationLogRepository>();
ApplicationLogEntity entity = new ApplicationLogEntity();
entity.CategoryTypeId = (short)categoryType;
entity.LogData = logData;
entity.MethodName = methodName;
return(repository.Insert(entity));
}
public void IocFactory_ResolveWithParameterRegisteredDependency_Test()
{
IocFactory.Register(
Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.ImplementedBy <AnotherMock>()
);
IConfigurationUtilityMock mock = IocFactory.Resolve <IConfigurationUtilityMock>();
Assert.IsNotNull(mock);
}
public List <ChangeData> Calculate(int amountInCents)
{
// Executa a validação dos dados recebidos.
if (this.Validate(amountInCents) == false)
{
throw new ArgumentOutOfRangeException("amountInCents", "Value must be equals or greater than zero.");
}
List <ChangeData> changeDataCollection = new List <ChangeData>();
int[] availableValues = this.AvailableValues();
// Lista ordenada do menor para o maior
int[] orderedCollection = availableValues.OrderByDescending(p => p).ToArray();
IConfigurationUtility configurationUtility = IocFactory.Resolve <IConfigurationUtility>();
ILogger logManager = IocFactory.Resolve <ILogger>(configurationUtility);
logManager.WriteLog(LogSeverityEnum.Information, string.Format("{0}: orderedCollection", this.GetName()), orderedCollection);
// Armazena o menor valor disponível.
int minValue = availableValues.Min();
// Iteração sobre todas as moedas
foreach (int changeItem in orderedCollection)
{
//Enquanto o valor do troco restante for igual ou menor ao valor da moeda, adiciona a lista
while (changeItem <= amountInCents)
{
//Se o troco restante for zero, retorna o valor
if (amountInCents < minValue)
{
return(changeDataCollection);
}
//Recupera o item a ser adicionado na lista, caso já esteja apenas incrementa.
ChangeData changeData = changeDataCollection.SingleOrDefault(o => o.AmountInCents == changeItem);
if (changeData == null)
{
changeDataCollection.Add(new ChangeData(changeItem, this.GetCurrencyName()));
}
else
{
changeData.Quantity++;
}
amountInCents = amountInCents - changeItem;
}
}
return(changeDataCollection);
}
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 override void Write(LogEntry logEntry)
{
ILogEntryRepository logEntryRepository = IocFactory.Resolve <ILogEntryRepository>(this.ConfigurationUtility.ConnectionString);
LogEntryEntity logEntryEntity = MapToDatabase(logEntry);
try
{
logEntryRepository.SaveLog(logEntryEntity);
}
catch (Exception ex)
{
RaiseLogError(ex);
}
}
public static BaseLogUtility CreateLogUtility()
{
// Obtém uma instancia do utilitário de acesso ao arquivo de configuração.
IConfigurationUtility configurationUtility = IocFactory.Resolve <IConfigurationUtility>();
switch (configurationUtility.LogType)
{
case LogUtilityType.File:
return(new FileLogUtility(configurationUtility.LogFilePath, configurationUtility.LogFileName));
case LogUtilityType.Database:
return(new DatabaseLogUtility());
case LogUtilityType.EventLog:
default:
return(new EventLogUtility());
}
}
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 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 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);
}
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 static ILogger Create(LogRepositoryEnum logRepository)
{
IConfigurationUtility configurationUtility = IocFactory.Resolve <IConfigurationUtility>();
return(IocFactory.ResolveSpecific <ILogger>(logRepository.ToString(), configurationUtility));
}
public void AbstractContructorParameter_Test()
{
IocFactory.Register(Component.For <IMyComponent>().ImplementedBy <MyComponent>());
IMyComponent myComponent = IocFactory.Resolve <IMyComponent>(new Dependency());
}
public TestRepository()
{
utility = IocFactory.Resolve <IConfigurationUtility>();
}
