public void EditExpenseType_EditAnExistingExpenseType_ShouldUpdateAnExistingExpenseType()
{
// Arrange
var types = DummyExpenses();
// set-up Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
// get expense type to update
mockExpenseTypeRepo.Setup(e => e.GetExpenseTypeByName(It.IsAny <string>()))
.Returns((string s) => types.Find(x => x.Type == s));
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureCreated();
}
// Act
using (var context = new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
var et = service.GetExpenseTypeByName("Groceries");
et.Type = "Power";
service.EditExpenseType(et);
Assert.AreEqual("Power", service.GetExpenseTypeByName("Power").Type);
}
}
public void CreateExpenseType_AddANewExpenseType_ShouldAddAnExpense()
{
// arrange
// Setup-list
var types = DummyExpenses();
// Setup Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
mockExpenseTypeRepo.Setup(e => e.AddExpenseType(It.IsAny <ExpenseType>()))
.Callback((ExpenseType expenseType) => types.Add(expenseType));
mockExpenseTypeRepo.Setup(e => e.GetAllExpenses()).Returns(types);
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
// context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
//// Assert
//// Use a clean instance of the context to run the test
using (var context = new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
service.CreateExpenseType(new ExpenseType()
{
Id = Guid.NewGuid(),
Type = "Rajivs",
AddedOn = DateTime.Now,
LastModifiedOn = DateTime.Now
});
context.SaveChanges();
var result = _mockExpenseTypeRepository.GetAllExpenses().Count();
var newRecord = types.Find(t => t.Type == "Rajivs");
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual(3, result);
Assert.AreEqual("Rajivs", newRecord.Type);
});
}
}
public ExpenseService(IExpenseRepository ExpenseRepository, IBankAccountRepository bankAccountRepository, IAtmWithdrawRepository atmWithdrawRepository, IIncomeRepository incomeRepository,
IHistoricMovementRepository historicMovementRepository, IExpenseTypeRepository ExpenseTypeRepository, ISavingRepository savingRepository)
{
this._ExpenseRepository = ExpenseRepository;
this._bankAccountRepository = bankAccountRepository;
this._atmWithdrawRepository = atmWithdrawRepository;
this._incomeRepository = incomeRepository;
this._historicMovementRepository = historicMovementRepository;
this._ExpenseTypeRepository = ExpenseTypeRepository;
this._savingRepository = savingRepository;
}
public CreateExpenseRequestHandler(
IClaimsIdentityService claimsIdentityService,
IExpenseTypeRepository expenseTypeRepository,
IExpenseRepository expenseRepository,
IMapper mapper)
: base(claimsIdentityService)
{
fExpenseTypeRepository = expenseTypeRepository;
fExpenseRepository = expenseRepository;
fMapper = mapper;
}
public BudgetPlanService(IBudgetPlanRepository budgetPlanRepository, IBudgetByExpenseTypeRepository budgetByExpenseTypeRepository, IBankAccountRepository bankAccountRepository,
IExpenseRepository ExpenseRepository, IExpenseTypeRepository ExpenseTypeRepository, IIncomeRepository incomeRepository,
ISavingRepository savingRepository)
{
this._budgetPlanRepository = budgetPlanRepository;
this._budgetByExpenseTypeRepository = budgetByExpenseTypeRepository;
this._bankAccountRepository = bankAccountRepository;
this._ExpenseRepository = ExpenseRepository;
this._ExpenseTypeRepository = ExpenseTypeRepository;
this._incomeRepository = incomeRepository;
this._savingRepository = savingRepository;
}
public UpdateExpenseRequestHandler(
IClaimsIdentityService claimsIdentityService,
IExpenseTypeRepository expenseTypeRepository,
IExpenseRepository expenseRepository,
IDbTransactionService dbTransactionService,
IMapper mapper)
: base(claimsIdentityService)
{
fExpenseTypeRepository = expenseTypeRepository;
fExpenseRepository = expenseRepository;
fDbTransactionService = dbTransactionService;
fMapper = mapper;
}
public void RemoveExpenseType_ProvideInvalidExpenseType_ShouldThrowAnException()
{
// Arrange
var types = DummyExpenses();
// set up repos
// set-up Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
// get expense type to delete
//mockExpenseTypeRepo.Setup(e => e.GetExpenseTypeByName(It.IsAny<string>()))
// .Returns((string s) => types.Find(x => x.Type == s));
mockExpenseTypeRepo.Setup(x => x.Find(It.IsAny <Guid>()))
.Returns((Guid id) => types.Find(x => x.Id == id));
// To Remove item based on the given GUID.
// Setup mock for remove item based on GUID
// In the callback, 1st Find the item based on the Id and then remove it from the list
mockExpenseTypeRepo.Setup(r => r.RemoveExpenseType(It.IsAny <Guid>()))
.Callback((Guid id) => types.Remove(types.Find(x => x.Id == id)));
// get all expenses
mockExpenseTypeRepo.Setup(x => x.GetAllExpenses()).Returns(types);
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// set up db context
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureCreated();
}
// Act
using (var context = new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
var item = Guid.Parse("0df4ec64-6c4c-4085-8dac-0ee98943d8a7");
//service.RemoveExpenseType(item.Id);
Assert.Throws <InvalidOperationException>(() => service.RemoveExpenseType(item));
}
}
public void GetExpenseTypeById_GetsExpensesBasedOnType_ShouldReturnExpenseTypeByName(string expenseTypeName, string expectedTypeName)
{
// arrange
// Setup Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
mockExpenseTypeRepo.Setup(e => e.GetExpenseTypeByName(It.IsAny <string>()))
.Returns((string s) => DummyExpenses().Find(x => x.Type == s));
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureDeleted();
}
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureCreated();
}
// Act
// Insert seed data into the database using one instance of the context
using (var context = new AppDbContext(options))
{
var dummyExpenses = DummyExpenses();
foreach (var dummyExpenseType in dummyExpenses)
{
context.ExpenseTypes.Add(dummyExpenseType);
}
context.SaveChanges();
}
// Assert
// Use a clean instance of the context to run the test
using (new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
var result = service.GetExpenseTypeByName(expenseTypeName);
Assert.AreEqual(expectedTypeName, result.Type);
}
}
public void RemoveExpenseType_RemovestheSpecifiedExpenType_ShouldRemoveExpenseTypeFromList(string typeName)
{
// Arrange
var types = DummyExpenses();
// set up repos
// set-up Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
// get expense type to delete
mockExpenseTypeRepo.Setup(e => e.GetExpenseTypeByName(It.IsAny <string>()))
.Returns((string s) => types.Find(x => x.Type == s));
// To Remove item based on the given GUID.
// Setup mock for remove item based on GUID
// In the callback, 1st Find the item based on the Id and then remove it from the list
mockExpenseTypeRepo.Setup(r => r.RemoveExpenseType(It.IsAny <Guid>()))
.Callback((Guid id) => types.Remove(types.Find(x => x.Id == id)));
// get all expenses
mockExpenseTypeRepo.Setup(x => x.GetAllExpenses()).Returns(types);
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// set up db context
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureCreated();
}
// Act
using (var context = new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
var item = service.GetExpenseTypeByName(typeName);
service.RemoveExpenseType(item.Id);
Assert.AreEqual(1, types.Count);
}
}
public void GetExpensesTypeByName_PassInvalidExpenseType_ShouldThrowAnInvalidOperationException()
{
// arrange
// Setup Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
mockExpenseTypeRepo.Setup(e => e.GetExpenseTypeByName(It.IsAny <string>()))
.Throws <InvalidOperationException>();
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureDeleted();
}
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureCreated();
}
// Act
// Insert seed data into the database using one instance of the context
using (var context = new AppDbContext(options))
{
var dummyExpenses = DummyExpenses();
foreach (var dummyExpenseType in dummyExpenses)
{
context.ExpenseTypes.Add(dummyExpenseType);
}
context.SaveChanges();
}
// Assert
// Use a clean instance of the context to run the test
using (new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
Assert.Throws <InvalidOperationException>(() => service.GetExpenseTypeByName("Intern"));
}
}
public void CreateExpenseType_AddAnExistingExpenseType_ShouldThrowException()
{
//Arrange
// Setup-list
var types = DummyExpenses();
// Setup Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
mockExpenseTypeRepo.Setup(e => e.AddExpenseType(It.IsAny <ExpenseType>()))
.Callback((ExpenseType expenseType) => types.Add(expenseType));
mockExpenseTypeRepo.Setup(e => e.GetAllExpenses()).Returns(types);
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
//context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
//// Assert
//// Use a clean instance of the context to run the test
using (var context = new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
Assert.Throws <Exception>(() => service.CreateExpenseType(new ExpenseType()
{
Id = Guid.NewGuid(),
Type = "Groceries",
AddedOn = DateTime.Now,
LastModifiedOn = DateTime.Now
}));
}
}
public void GetExpensesTypes_GetsAllTheExpenses_ShouldReturnAllExpenses()
{
// arrange
// Setup-list
var types = DummyExpenses();
// Setup Repository
var mockExpenseTypeRepo = new Mock <IExpenseTypeRepository>();
mockExpenseTypeRepo.Setup(e => e.AddExpenseType(It.IsAny <ExpenseType>()))
.Callback((ExpenseType expenseType) => types.Add(expenseType));
mockExpenseTypeRepo.Setup(e => e.GetAllExpenses()).Returns(types);
_mockExpenseTypeRepository = mockExpenseTypeRepo.Object;
// Setup DbContext to use inMemory SQLite database
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseSqlite("DataSource=:memory:")
.Options;
// Create the schema in the database
using (var context = new AppDbContext(options))
{
context.Database.EnsureCreated();
}
// Act and Assert
// Use a clean instance of the context to run the test
using (new AppDbContext(options))
{
var service = new ExpenseTypeService(_mockExpenseTypeRepository);
var result = service.GetAllExpenses();
Assert.AreEqual(2, result.Count());
}
}
public ExpenseTypeService(IExpenseTypeRepository expenseTypeRepository, IExpenseRepository expenseRepository)
{
this.expenseTypeRepository = expenseTypeRepository;
this.expenseRepository = expenseRepository;
}
public RepositoryWrapper(
FactoryManagementContext dbContext,
IAddressRepository Address,
ICustomerRepository Customer,
IDepartmentRepository Department,
IEquipmentRepository Equipment,
IEquipmentCategoryRepository EquipmentCategory,
IExpenseRepository Expense,
IExpenseTypeRepository ExpenseType,
IFactoryRepository Factory,
IIncomeRepository Income,
IIncomeTypeRepository IncomeType,
IInvoiceRepository Invoice,
IInvoiceTypeRepository InvoiceType,
IItemRepository Item,
IItemCategoryRepository ItemCategory,
IItemStatusRepository ItemStatus,
IPayableRepository Payable,
IPaymentStatusRepository PaymentStatus,
IPhoneRepository Phone,
IProductionRepository Production,
IPurchaseRepository Purchase,
IPurchaseTypeRepository PurchaseType,
IRecievableRepository Recievable,
IRoleRepository Role,
ISalesRepository Sales,
IStaffRepository Staff,
IStockRepository Stock,
IStockInRepository StockIn,
IStockOutRepository StockOut,
ISupplierRepository Supplier,
ITransactionRepository Transaction,
ITransactionTypeRepository TransactionType,
IUserAuthInfoRepository UserAuthInfo,
IUserRoleRepository UserRole,
IUtilService util,
IApiResourceMappingRepository ApiResourceMappingRepository)
{
this.dbContext = dbContext;
this._Address = Address;
this._Customer = Customer;
this._Department = Department;
this._Equipment = Equipment;
this._EquipmentCategory = EquipmentCategory;
this._Expense = Expense;
this._ExpenseType = ExpenseType;
this._Income = Income;
this._IncomeType = IncomeType;
this._Invoice = Invoice;
this._InvoiceType = InvoiceType;
this._Item = Item;
this._ItemCategory = ItemCategory;
this._ItemStatus = ItemStatus;
this._Payable = Payable;
this._PaymentStatus = PaymentStatus;
this._Phone = Phone;
this._Production = Production;
this._Purchase = Purchase;
this._PurchaseType = PurchaseType;
this._Recievable = Recievable;
this._Role = Role;
this._Sales = Sales;
this._Staff = Staff;
this._Stock = Stock;
this._StockIn = StockIn;
this._StockOut = StockOut;
this._Supplier = Supplier;
this._Transaction = Transaction;
this._TransactionType = TransactionType;
this._UserAuthInfo = UserAuthInfo;
this._UserRole = UserRole;
this._util = util;
this._ApiResourceMappingRepository = ApiResourceMappingRepository;
}
public ExpenseTypeService(IExpenseTypeRepository repository)
{
_repository = repository;
}
public ExpenseTypeCommandHandler(IExpenseTypeRepository types)
{
_types = types;
}
public DeleteExpenseTypeRequestHandler(IExpenseTypeRepository expenseTypeRepository, IMapper mapper)
{
fExpenseTypeRepository = expenseTypeRepository;
fMapper = mapper;
}
public ExpenseBusinessLogic(IExpenseRepository expenseRepo, IExpenseTypeRepository typeRepo, IUserRepository userRepository)
{
_expenseRepo = expenseRepo;
_typeRepo = typeRepo;
_userRepository = userRepository;
}
