public async void Update_NoNewEntryAdded()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = "Testtext"
};
// Act
repository.Add(testEntry);
await unitOfWork.Commit();
repository.Update(testEntry);
await unitOfWork.Commit();
// Assert
Assert.Equal(1, repository.GetAll().Count());
}
public async void Update_EntryUpdated()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
var newValue = "newText";
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = "Testtext"
};
// Act
repository.Add(testEntry);
await unitOfWork.Commit();
testEntry.Note = newValue;
repository.Update(testEntry);
await unitOfWork.Commit();
// Assert
var loadedEntry = await repository.GetById(testEntry.Id);
Assert.Equal(newValue, loadedEntry.Note);
}
public async void Update_IdUnchanged()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = "Testtext"
};
// Act
repository.Add(testEntry);
await unitOfWork.Commit();
var idBeforeUpdate = testEntry.Id;
repository.Update(testEntry);
await unitOfWork.Commit();
// Assert
Assert.Equal(idBeforeUpdate, testEntry.Id);
}
public void Save_WithRecurringPayment_FkSet()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var recurringPaymentRepository =
new RecurringPaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var fixture = new Fixture();
var recurringPayment = fixture.Create <RecurringPaymentViewModel>();
recurringPaymentRepository.Save(recurringPayment);
recurringPayment.Id.ShouldBeGreaterThan(0);
var testPayment = new Fixture().Create <PaymentViewModel>();
testPayment.Id = 0;
testPayment.RecurringPayment = recurringPayment;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
paymentRepository.FindById(testPayment.Id).RecurringPaymentId.ShouldBe(recurringPayment.Id);
}
public async void Add_AddNewEntryOnEveryCall()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = "Testtext"
};
// Act
repository.Add(testEntry);
await unitOfWork.Commit();
testEntry.Id = 0;
repository.Add(testEntry);
await unitOfWork.Commit();
// Assert
Assert.Equal(2, repository.GetAll().Count());
}
public void SaveAndUpdate_WithRecurringPayment_NoDuplicates()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var recurringPaymentRepository =
new RecurringPaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var recurringPayment = new Fixture().Create <RecurringPaymentViewModel>();
recurringPayment.Id = 0;
recurringPaymentRepository.Save(recurringPayment);
paymentRepository.ReloadCache();
var testPayment = new Fixture().Create <PaymentViewModel>();
testPayment.Id = 0;
testPayment.RecurringPayment = recurringPayment;
paymentRepository.Save(testPayment);
paymentRepository.Save(testPayment);
var selected = paymentRepository.FindById(testPayment.Id);
recurringPaymentRepository.GetList(x => x.Note == testPayment.RecurringPayment.Note).Count().ShouldBe(1);
}
public async void GetMany_MatchedDataReturned()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new RecurringPaymentRepository(factory);
var filterText = "Text";
repository.Add(new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = filterText
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Act
var resultList = repository.GetMany(x => x.Note == filterText).ToList();
// Assert
Assert.NotNull(resultList);
Assert.Equal(1, resultList.Count);
}
public async void GetMany_NothingMatched()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new RecurringPaymentRepository(factory);
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Act
var resultList = repository.GetMany(x => x.Note == "text").ToList();
// Assert
Assert.NotNull(resultList);
Assert.False(resultList.Any());
}
public async void Delete_RelatedPaymentSetNull()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var recurringPaymentRepository = new RecurringPaymentRepository(dbFactory);
var paymentRepository = new PaymentRepository(dbFactory);
var recurringPaymentEntity = new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
};
var payment = new PaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
RecurringPayment = recurringPaymentEntity
};
paymentRepository.Add(payment);
await unitOfWork.Commit();
// Act
recurringPaymentRepository.Delete(recurringPaymentEntity);
await unitOfWork.Commit();
// Assert
Assert.Null(payment.RecurringPayment);
Assert.Null(paymentRepository.GetById(payment.Id).Result.RecurringPayment);
}
public async void Delete_EntryMatchedFilterDeleted()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var filterText = "Text";
var repository = new RecurringPaymentRepository(dbFactory);
var testEntry1 = new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = filterText
};
var testEntry2 = new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
};
repository.Add(testEntry1);
repository.Add(testEntry2);
await unitOfWork.Commit();
// Act
repository.Delete(x => x.Note == filterText);
await unitOfWork.Commit();
// Assert
Assert.Equal(1, repository.GetAll().Count());
}
public async void Add_IdSet()
{
// Arrange
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = testAccount,
Note = "Testtext"
};
// Act
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Add(testEntry);
await dbContextScope.SaveChangesAsync();
}
// Assert
Assert.NotNull(testEntry.Id);
Assert.NotEqual(0, testEntry.Id);
}
public async void Delete_EntryNotFound()
{
// Arrange
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var testEntry = new RecurringPaymentEntity {
ChargedAccount = testAccount
};
// Act / Assert
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Delete(testEntry);
await Assert.ThrowsAsync <DbUpdateConcurrencyException>(async() => await dbContextScope.SaveChangesAsync());
}
}
public async void Get_NothingMatched()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Act
var result = await repository.Get(x => x.Note == "text");
// Assert
Assert.Null(result);
}
public async void Get_MatchedDataReturned()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
var filterText = "Text";
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = filterText
};
repository.Add(testEntry);
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Act
var result = await repository.Get(x => x.Note == filterText);
// Assert
Assert.NotNull(result);
Assert.Equal(testEntry.Id, result.Id);
}
public void Save_ExistingEntryUpdated()
{
var recPaymentRepository =
new RecurringPaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testRecurringPayment = new Fixture().Create <RecurringPaymentViewModel>();
testRecurringPayment.Id = 0;
try
{
recPaymentRepository.Save(testRecurringPayment);
recPaymentRepository.FindById(testRecurringPayment.Id).ShouldNotBeNull();
const string updatedNote = "FOOOOOOOOOO";
testRecurringPayment.Note = updatedNote;
recPaymentRepository.Save(testRecurringPayment);
recPaymentRepository.FindById(testRecurringPayment.Id).Note.ShouldBe(updatedNote);
}
finally
{
recPaymentRepository.Delete(testRecurringPayment);
}
}
public async void Add_AddMultipleEntries()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
// Act
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Assert
Assert.Equal(3, repository.GetAll().Count());
}
public async void Add_AddedAndRead()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new RecurringPaymentRepository(factory);
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = "Testtext"
};
// Act
repository.Add(testEntry);
await unitOfWork.Commit();
// Assert
var loadedEntry = await repository.GetById(testEntry.Id);
Assert.Equal(testEntry.Note, loadedEntry.Note);
}
public async void GetAll_AllDataReturned()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Act
var resultList = repository.GetAll().ToList();
// Assert
Assert.NotNull(resultList);
Assert.Equal(3, resultList.Count);
}
public void GetAll_NoData()
{
// Arrange
var repository = new RecurringPaymentRepository(dbFactory);
// Act
var emptyList = repository.GetAll().ToList();
// Assert
Assert.NotNull(emptyList);
Assert.False(emptyList.Any());
}
public async void GetMany_MatchedDataReturned()
{
// Arrange
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var filterText = "Text";
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Add(new RecurringPaymentEntity
{
ChargedAccount = testAccount,
Note = filterText
});
await dbContextScope.SaveChangesAsync();
}
List <RecurringPaymentEntity> resultList;
// Act
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Add(new RecurringPaymentEntity {
ChargedAccount = testAccount
});
recurringPaymentRepository.Add(new RecurringPaymentEntity {
ChargedAccount = testAccount
});
await dbContextScope.SaveChangesAsync();
resultList = recurringPaymentRepository.GetMany(x => x.Note == filterText).ToList();
}
// Assert
Assert.NotNull(resultList);
Assert.Equal(1, resultList.Count);
}
public void Delete_PaymentDeleted()
{
var recurringPaymentRepository =
new RecurringPaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testRecurringPayment = new Fixture().Create <RecurringPaymentViewModel>();
testRecurringPayment.Id = 0;
recurringPaymentRepository.Save(testRecurringPayment);
recurringPaymentRepository.FindById(testRecurringPayment.Id).ShouldNotBeNull();
recurringPaymentRepository.Delete(testRecurringPayment);
recurringPaymentRepository.FindById(testRecurringPayment.Id).ShouldBeNull();
}
public void GetAll_NoData()
{
// Arrange
var repository = new RecurringPaymentRepository(ambientDbContextLocator);
List <RecurringPaymentEntity> resultList;
// Act
using (dbContextScopeFactory.CreateReadOnly())
{
resultList = repository.GetAll().ToList();
}
// Assert
Assert.NotNull(resultList);
Assert.False(resultList.Any());
}
public async void Delete_RelatedPaymentSetNull()
{
// Arrange
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var paymentRepository = new PaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var recurringPaymentEntity = new RecurringPaymentEntity {
ChargedAccount = testAccount
};
var payment = new PaymentEntity
{
ChargedAccount = testAccount,
RecurringPayment = recurringPaymentEntity
};
using (var dbContextScope = dbContextScopeFactory.Create())
{
paymentRepository.Add(payment);
await dbContextScope.SaveChangesAsync();
}
// Act
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Delete(recurringPaymentEntity);
await dbContextScope.SaveChangesAsync();
}
// Assert
using (dbContextScopeFactory.CreateReadOnly())
{
Assert.Null(payment.RecurringPayment);
Assert.Null(paymentRepository.GetById(payment.Id).Result.RecurringPayment);
}
}
public async void Delete_EntryMatchedFilterDeleted()
{
// Arrange
var filterText = "Text";
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var testEntry1 = new RecurringPaymentEntity
{
ChargedAccount = testAccount,
Note = filterText
};
using (var dbContextScope = dbContextScopeFactory.Create())
{
var testEntry2 = new RecurringPaymentEntity {
ChargedAccount = testAccount
};
recurringPaymentRepository.Add(testEntry1);
recurringPaymentRepository.Add(testEntry2);
await dbContextScope.SaveChangesAsync();
}
// Act
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Delete(x => x.Note == filterText);
await dbContextScope.SaveChangesAsync();
}
// Assert
using (dbContextScopeFactory.CreateReadOnly())
{
Assert.Equal(1, recurringPaymentRepository.GetAll().Count());
}
}
public async void Update_EntryUpdated()
{
// Arrange
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var newValue = "newText";
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = testAccount,
Note = "Testtext"
};
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Add(testEntry);
await dbContextScope.SaveChangesAsync();
}
// Act
using (var dbContextScope = dbContextScopeFactory.Create())
{
testEntry.Note = newValue;
recurringPaymentRepository.Update(testEntry);
await dbContextScope.SaveChangesAsync();
}
// Assert
using (dbContextScopeFactory.CreateReadOnly())
{
var loadedEntry = await recurringPaymentRepository.GetById(testEntry.Id);
Assert.Equal(newValue, loadedEntry.Note);
}
}
public async void Add_WithoutAccount()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new RecurringPaymentRepository(factory);
var testEntry = new RecurringPaymentEntity()
{
Note = "Testtext"
};
// Act / Assert
repository.Add(testEntry);
await Assert.ThrowsAsync <DbUpdateException>(async() => await unitOfWork.Commit());
}
public async void Save_WithRecurringPayment_GetRecurringPaymentFromHelper()
{
// Arrange
var paymentRepository = new PaymentRepository(ambientDbContextLocator);
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var testEntry = new PaymentViewModel(new Payment
{
Data =
{
ChargedAccount = testAccount,
Date = DateTime.Now,
IsRecurring = true,
Note = "Testtext"
}
});
testEntry.RecurringPayment = new RecurringPaymentViewModel(
RecurringPaymentHelper.GetRecurringFromPayment(testEntry.Payment,
true,
PaymentRecurrence.Bimonthly,
DateTime.Now));
var paymentService = new PaymentService(dbContextScopeFactory, paymentRepository, recurringPaymentRepository, accountRepository);
// Act
await paymentService.SavePayment(testEntry.Payment);
var payment = await paymentService.GetById(testEntry.Payment.Data.Id);
// Assert
Assert.NotNull(payment);
}
public async void Delete_EntryNotFound()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new RecurringPaymentRepository(dbFactory);
var testEntry = new RecurringPaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
};
// Act
repository.Delete(testEntry);
// Assert
await Assert.ThrowsAsync <DbUpdateConcurrencyException>(async() => await unitOfWork.Commit());
}
public void Save_IdSet()
{
var recurringPaymentRepository =
new RecurringPaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testRecurringPayment = new Fixture().Create <RecurringPaymentViewModel>();
testRecurringPayment.Id = 0;
try
{
recurringPaymentRepository.Save(testRecurringPayment);
testRecurringPayment.Id.ShouldBeGreaterThan(0);
}
finally
{
recurringPaymentRepository.Delete(testRecurringPayment);
}
}
public async void Add_AddNewEntryOnEveryCall()
{
// Arrange
var recurringPaymentRepository = new RecurringPaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
AccountEntity testAccount;
using (var dbContextScope = dbContextScopeFactory.Create())
{
testAccount = new AccountEntity {
Name = "testAccount"
};
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var testEntry = new RecurringPaymentEntity
{
ChargedAccount = testAccount,
Note = "Testtext"
};
using (var dbContextScope = dbContextScopeFactory.Create())
{
recurringPaymentRepository.Add(testEntry);
await dbContextScope.SaveChangesAsync();
}
// Act
using (var dbContextScope = dbContextScopeFactory.Create())
{
testEntry.Id = 0;
recurringPaymentRepository.Add(testEntry);
await dbContextScope.SaveChangesAsync();
}
// Assert
using (dbContextScopeFactory.CreateReadOnly())
{
Assert.Equal(2, recurringPaymentRepository.GetAll().Count());
}
}
