public async Task Delete_ByIdTransactionType_Valido()
{
Guid id = new Guid("5E210F4F-D12B-4F85-8464-6F8740920FAA");
var service = new TransactionTypeService(_httpClient);
var result = await service.DeleteByIdTransactionType(requestUri, id);
// Assert
if (result.Status == HttpStatusCode.OK)
{
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
else
{
List <string> listError = new List <string>();
foreach (string error in result.Data)
{
listError.Add(error);
}
Assert.Collection(listError,
item => Assert.Equal("The Guid is empty", item),
item => Assert.Equal("The Guid is invalid and contains 00000000", item),
item => Assert.Equal("Registro não encontrado", item)
);
}
}
public async Task Post_TransactionType_The_Guid_is_empty()
{
TransactionType transactionType = new TransactionType
{
Id = Guid.Empty,
Name = "1"
};
var service = new TransactionTypeService(_httpClient);
var result = await service.PostTransactionType(requestUri, transactionType);
if (result.Status == HttpStatusCode.OK)
{
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
else
{
List <string> listError = new List <string>();
foreach (string error in result.Data)
{
listError.Add(error);
}
Assert.Collection(listError,
item => Assert.Equal("The Name is Required", item),
item => Assert.Equal("The Name must have between 2 and 30 characters", item),
item => Assert.Equal("The Guid is empty", item),
item => Assert.Equal("The Guid is invalid and contains 00000000", item),
item => Assert.Equal("The transaction type id has already been taken.", item),
item => Assert.Equal("The transaction type name has already been taken.", item)
);
}
}
public async Task Put_TransactionType_Valido()
{
Guid guid = new Guid("5E210F4F-D12B-4F85-8464-6F8740920FAA");
TransactionType transactionType = new TransactionType
{
Id = guid,
Name = "ALTERADO..."
};
var service = new TransactionTypeService(_httpClient);
var result = await service.PutTransactionType(requestUri, transactionType);
if (result.Status == HttpStatusCode.OK)
{
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
else
{
List <string> listError = new List <string>();
foreach (string error in result.Data)
{
listError.Add(error);
}
Assert.Collection(listError,
item => Assert.Equal("The Name is Required", item),
item => Assert.Equal("The Name must have between 2 and 30 characters", item),
item => Assert.Equal("The Guid is empty", item),
item => Assert.Equal("The Guid is invalid and contains 00000000", item),
item => Assert.Equal("The transaction type name has already been taken.", item)
);
}
}
public async Task Put_TransactionType_The_Name_must_have_between_2_and_30_characters()
{
Guid guid = new Guid("1BF784F8-7B94-47EC-9FD9-5257D83E8E7D");
TransactionType transactionType = new TransactionType
{
Id = guid,
Name = "o"
};
var service = new TransactionTypeService(_httpClient);
var result = await service.PutTransactionType(requestUri, transactionType);
if (result.Status == HttpStatusCode.OK)
{
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
else
{
List <string> listError = new List <string>();
foreach (string error in result.Data)
{
listError.Add(error);
}
Assert.Collection(listError,
item => Assert.Equal("The Name is Required", item),
item => Assert.Equal("The Name must have between 2 and 30 characters", item),
item => Assert.Equal("The Guid is empty", item),
item => Assert.Equal("The Guid is invalid and contains 00000000", item),
item => Assert.Equal("The transaction type name has already been taken.", item)
);
}
}
public void GetByKey_ReturnsIncomeAndExpense()
{
string expectedTransactionTypesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"TransactionTypes.json");
var expectedTransactionTypes = JsonConvert.DeserializeObject <List <TransactionType> >(expectedTransactionTypesJson);
var expectedIncome = expectedTransactionTypes
.First(t => t.Name == TransactionType.Options.Income.ToString());
var expectedExpense = expectedTransactionTypes
.First(t => t.Name == TransactionType.Options.Expense.ToString());
TransactionTypeRepository
.Setup(r => r.GetByKey(TransactionType.Options.Income.ToString())).Returns(expectedIncome);
TransactionTypeRepository
.Setup(r => r.GetByKey(TransactionType.Options.Expense.ToString())).Returns(expectedExpense);
var actualIncome = TransactionTypeService.GetByKey(TransactionType.Options.Income.ToString());
var actualExpense = TransactionTypeService.GetByKey(TransactionType.Options.Expense.ToString());
Assert.NotNull(actualIncome);
Assert.NotNull(actualExpense);
Assert.Equal(actualIncome.Name, expectedIncome.Name);
Assert.Equal(actualIncome.IconUrl, expectedIncome.IconUrl);
Assert.Equal(actualExpense.Name, expectedExpense.Name);
Assert.Equal(actualExpense.IconUrl, expectedExpense.IconUrl);
}
public async Task Delete_ThrowsException()
{
await Assert.ThrowsAsync <CashSchedulerException>(() =>
TransactionTypeService.Delete(TransactionType.Options.Income.ToString()));
await Assert.ThrowsAsync <CashSchedulerException>(() =>
TransactionTypeService.Delete(TransactionType.Options.Expense.ToString()));
}
public async void GetTransactions()
{
#region Get Id Transaction Type
var serviceTransactionType = new TransactionTypeService(_httpClient);
var resultTransactionType = await serviceTransactionType.GetAllTransactionTypes(requestUri + "TransactionType-management/");
#endregion
}
public async Task Get_AllTransactionType()
{
var service = new TransactionTypeService(_httpClient);
var result = await service.GetAllTransactionTypes(requestUri);
// Assert
Assert.False(result.Status == HttpStatusCode.BadRequest, "ERROR");
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
public async Task Create_ThrowsException()
{
var sampleTransactionType = new TransactionType
{
Name = "Debt",
IconUrl = "/static/icons/transactiontypes/debt.png"
};
await Assert.ThrowsAsync <CashSchedulerException>(() => TransactionTypeService.Create(sampleTransactionType));
}
public TransactionController(TransactionTypeService transactionTypeService,
TransactionService transactionService,
AccountService accountService,
ILogger <TransactionController> logger)
{
_transactionTypeService = transactionTypeService;
_transactionService = transactionService;
_accountService = accountService;
_logger = logger;
}
public ActionResult Index()
{
var adjustmentReasons = TransactionService.GetAllAdjustmentReasons();
var transactionTypes = TransactionTypeService.GetTransactionTypes();
var cancellation = CaseService.GetAllCancellation();
var model = new IndexViewModel();
return(View(model.Rebuild(model, adjustmentReasons, transactionTypes, cancellation)));
}
public async Task Update_ThrowsException()
{
var sampleTransactionType = new TransactionType
{
Name = "Income",
IconUrl = "/static/icons/transactiontypes/income-new.png"
};
await Assert.ThrowsAsync <CashSchedulerException>(() => TransactionTypeService.Update(sampleTransactionType));
}
public AccountController(AccountService accountService,
ProviderService providerService,
AccountTypeService accountTypeService,
TransactionTypeService transactionTypeService,
ILogger <AccountController> logger)
{
_accountService = accountService;
_providerService = providerService;
_accountTypeService = accountTypeService;
_logger = logger;
}
public async Task Get_ByNameTransactionType()
{
string info = "ALTERADO...";
var service = new TransactionTypeService(_httpClient);
var result = await service.GetByNameTransactionType(requestUri, info);
// Assert
Assert.False(result.Status == HttpStatusCode.BadRequest, "ERROR");
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
public TransactionTypeServiceTest()
{
ContextProvider = new Mock <IContextProvider>();
TransactionTypeRepository = new Mock <ITransactionTypeRepository>();
ContextProvider
.Setup(c => c.GetRepository <ITransactionTypeRepository>())
.Returns(TransactionTypeRepository.Object);
TransactionTypeService = new TransactionTypeService(ContextProvider.Object);
}
public async Task Get_HistorycByIdTransactionType()
{
string info = "5E210F4F-D12B-4F85-8464-6F8740920FAA";
var service = new TransactionTypeService(_httpClient);
var result = await service.GetHistorycByIdTransactionType(requestUri, info);
// Assert
Assert.False(result.Status == HttpStatusCode.BadRequest, "ERROR");
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
public async Task GetTransactionTypeAsync_Returns_Null()
{
//Arrange
var id = 1001;
var service = new TransactionTypeService(_myRestaurantContext);
//Act
var result = await service.GetTransactionTypeAsync(d => d.Id == id);
//Assert
result.Should().BeNull();
}
public async Task GetTransactionTypesAsync_Returns_TransactionTypes()
{
//Arrange
var service = new TransactionTypeService(_myRestaurantContext);
//Act
var result = await service.GetTransactionTypesAsync();
//Assert
result.Should().BeAssignableTo <IEnumerable <TransactionType> >();
result.Should().HaveCount(17);
}
public async Task GetTransactionTypeAsync_Returns_TransactionType()
{
//Arrange
var id = 1;
var service = new TransactionTypeService(_myRestaurantContext);
//Act
var result = await service.GetTransactionTypeAsync(d => d.Id == id);
//Assert
result.Should().BeAssignableTo <TransactionType>();
result !.Id.Should().Be(id);
result.Type.Should().Be("Food");
}
public void GetAll_ReturnsAll()
{
string expectedTransactionTypesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"TransactionTypes.json");
var expectedTransactionTypes = JsonConvert.DeserializeObject <List <TransactionType> >(expectedTransactionTypesJson);
TransactionTypeRepository.Setup(r => r.GetAll()).Returns(expectedTransactionTypes);
var actualTransactionTypes = TransactionTypeService.GetAll();
Assert.NotNull(actualTransactionTypes);
Assert.Equal(expectedTransactionTypes.Count, actualTransactionTypes.Count());
}
public static async Task <dynamic> Information()
{
var serviceTransactionType = new TransactionTypeService(_httpClient);
var resultTransactionType = await serviceTransactionType.GetAllTransactionTypes(requestUri);
List <TransactionType> statusTrans = new List <TransactionType>();
foreach (var item in resultTransactionType.Data)
{
statusTrans.Add(new TransactionType {
Id = item.Id, Name = item.Name
});
}
return(statusTrans);
}
public async Task DeleteTransactionTypeAsync_Successfully_Deleted()
{
//Arrange
var id = 1;
var service = new TransactionTypeService(_myRestaurantContext);
//Act
var dbTransactionType = await service.GetTransactionTypeAsync(d => d.Id == id);
await service.DeleteTransactionTypeAsync(dbTransactionType !);
var result = await service.GetTransactionTypeAsync(d => d.Id == id);
//Assert
result.Should().BeNull();
}
public async Task AddTransactionTypeAsync_Returns_New_TransactionType()
{
//Arrange
var service = new TransactionTypeService(_myRestaurantContext);
//Act
var result = await service.AddTransactionTypeAsync(new TransactionType { Type = "Salary" });
//Assert
result.Should().BeAssignableTo <TransactionType>();
result.Type.Should().Be("Salary");
//Act
var transactionTypes = await service.GetTransactionTypesAsync();
//Assert
transactionTypes.Should().HaveCount(18);
}
public async Task Post_TransactionType_Seed()
{
List <TransactionType> listTransactionType = new List <TransactionType>();
listTransactionType.Add(new TransactionType
{
Id = Guid.NewGuid(),
Name = "Crédito"
});
listTransactionType.Add(new TransactionType
{
Id = Guid.NewGuid(),
Name = "Débito"
});
foreach (TransactionType cardType in listTransactionType)
{
var service = new TransactionTypeService(_httpClient);
var result = await service.PostTransactionType(requestUri, cardType);
if (result.Status == HttpStatusCode.OK)
{
Assert.True(result.Status == HttpStatusCode.OK, "OK");
}
else
{
List <string> listError = new List <string>();
foreach (string error in result.Data)
{
listError.Add(error);
}
Assert.Collection(listError,
item => Assert.Equal("The Name is Required", item),
item => Assert.Equal("The Name must have between 2 and 30 characters", item),
item => Assert.Equal("The Guid is empty", item),
item => Assert.Equal("The Guid is invalid and contains 00000000", item),
item => Assert.Equal("The card type id has already been taken.", item),
item => Assert.Equal("The card type name has already been taken.", item)
);
}
}
}
public async Task UpdateTransactionTypeAsync_Successfully_Updated()
{
//Arrange
var id = 4;
var service = new TransactionTypeService(_myRestaurantContext);
//Act
var dbTransactionType = await service.GetTransactionTypeAsync(d => d.Id == id);
dbTransactionType !.Type = "Mortgage/Rent";
await service.UpdateTransactionTypeAsync(dbTransactionType);
var result = await service.GetTransactionTypeAsync(d => d.Id == id);
//Assert
result.Should().BeAssignableTo <TransactionType>();
result !.Id.Should().Be(id);
result.Type.Should().Be("Mortgage/Rent");
}
// GET: transaction/Create
public ActionResult Create()
{
#region Account list
var accountService = new AccountService();
#endregion
#region Customer List
var customerService = new CustomerService();
#endregion
#region TransactionType List
var transactionTypeService = new TransactionTypeService();
#endregion
var model = new TransactionModel()
{
AccountList = accountService.GetSelectList(),
CustomerList = customerService.GetSelectList(),
TransactionTypeList = transactionTypeService.GetSelectList(),
};
return(View(model));
}
public static async Task <List <string> > InformationCombo()
{
List <string> typesTrans = new List <string>();
try
{
var serviceTransactionType = new TransactionTypeService(_httpClient);
var resultTransactionType = await serviceTransactionType.GetAllTransactionTypes(requestUri);
typesTrans.Add("CRÉDITO / DÉBITO");
foreach (var item in resultTransactionType.Data)
{
typesTrans.Add(item.Name);
}
}
catch (Exception ex)
{
Console.WriteLine("Erro servidor - " + ex.Message);
}
return(typesTrans);
}
// GET: Account/Edit/5
public ActionResult Edit(int id)
{
#region Account list
var accountService = new AccountService();
#endregion
#region Customer List
var customerService = new CustomerService();
#endregion
#region TransactionType List
var transactionTypeService = new TransactionTypeService();
#endregion
var model = new TransactionModel()
{
Transaction = _service.GetDetails(id),
AccountList = accountService.GetSelectList(),
CustomerList = customerService.GetSelectList(),
TransactionTypeList = transactionTypeService.GetSelectList(),
};
return(View(model));
}
public TransactionTypeController(ILogger <TransactionTypeController> logger, TransactionTypeService transactionTypeService)
{
_logger = logger;
_transactionTypeService = transactionTypeService;
}
public TransactionTypesController()
: base()
{
entityService = new TransactionTypeService(base.db);
}
