public async void Add_WithRecurringPayment()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
var testAccount = new AccountEntity {
Name = "testAccount"
};
var testEntry = new PaymentEntity
{
ChargedAccount = testAccount,
RecurringPayment = new RecurringPaymentEntity
{
ChargedAccount = testAccount,
Recurrence = PaymentRecurrence.Bimonthly,
IsEndless = true
},
IsRecurring = true,
Note = "Testtext"
};
// Act
repository.Add(testEntry);
await unitOfWork.Commit();
// Assert
Assert.NotNull(testEntry.Id);
Assert.NotEqual(0, testEntry.Id);
Assert.NotEqual(0, testEntry.RecurringPayment.Id);
Assert.NotEqual(0, testEntry.RecurringPaymentId);
}
public async void DeleteAccount_RelatedChargedPaymentsRemoved()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var accountRepository = new AccountRepository(dbFactory);
var paymentRepository = new PaymentRepository(dbFactory);
var account = new AccountEntity
{
Name = "Testtext"
};
var payment = new PaymentEntity
{
Note = "Foo",
ChargedAccount = account
};
accountRepository.Add(account);
paymentRepository.Add(payment);
await unitOfWork.Commit();
Assert.Equal(1, await accountRepository.GetAll().CountAsync());
Assert.Equal(1, await paymentRepository.GetAll().CountAsync());
// Act
accountRepository.Delete(account);
await unitOfWork.Commit();
// Assert
Assert.False(await accountRepository.GetAll().AnyAsync());
Assert.False(await paymentRepository.GetAll().AnyAsync());
}
public async void Delete_EntryMatchedFilterDeleted()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var filterText = "Text";
var repository = new PaymentRepository(factory);
var testEntry1 = new PaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = filterText
};
var testEntry2 = new PaymentEntity {
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 GetAll_AllDataReturned()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Act
var resultList = repository.GetAll().ToList();
// Assert
Assert.NotNull(resultList);
Assert.Equal(3, resultList.Count);
}
public async void Get_NothingMatched()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new PaymentEntity {
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 Update_IdUnchanged()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
var testEntry = new PaymentEntity
{
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 Run(IBackgroundTaskInstance taskInstance)
{
var deferral = taskInstance.GetDeferral();
try
{
MapperConfiguration.Setup();
var dbManager = new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWindowsCommonFileStore());
var paymentRepository = new PaymentRepository(dbManager);
var paymentManager = new PaymentManager(paymentRepository,
new AccountRepository(dbManager),
new RecurringPaymentRepository(dbManager),
null);
PaymentRepository.IsCacheMarkedForReload = true;
new RecurringPaymentManager(paymentManager, paymentRepository,
new SettingsManager(new WindowsUwpSettings())).CheckRecurringPayments();
}
finally
{
deferral.Complete();
}
}
protected virtual async Task <Payment> PreparePaymentSwitch(UpdatePaymentMethodParam param, Payment activePayment)
{
//TODO: Remove for now, but we should void (Bug with Moneris when payment is PendingVerification).
await PaymentRepository.RemovePaymentAsync(new VoidOrRemovePaymentParam
{
CartName = param.CartName,
CultureInfo = param.CultureInfo,
CustomerId = param.CustomerId,
PaymentId = activePayment.Id,
Scope = param.Scope
}).ConfigureAwait(false);
var cart = await CartRepository.AddPaymentAsync(new AddPaymentParam
{
BillingAddress = activePayment.BillingAddress.Clone(),
CartName = param.CartName,
CultureInfo = param.CultureInfo,
CustomerId = param.CustomerId,
Scope = param.Scope
});
var newPayment = GetActivePayment(cart);
return(newPayment);
}
public void Load_Payment_DataInitialized()
{
var accountRepositorySetup = new Mock <IAccountRepository>();
accountRepositorySetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Account>());
var dataAccessSetup = new Mock <IDataAccess <Payment> >();
dataAccessSetup.Setup(x => x.LoadList(null)).Returns(new List <Payment> {
new Payment {
Id = 10
},
new Payment {
Id = 15
}
});
var categoryDataAccessSetup = new Mock <IRepository <Category> >();
categoryDataAccessSetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Category>());
var paymentRepository = new PaymentRepository(dataAccessSetup.Object,
new Mock <IDataAccess <RecurringPayment> >().Object,
accountRepositorySetup.Object,
categoryDataAccessSetup.Object,
new Mock <INotificationService>().Object);
paymentRepository.Load();
Assert.IsTrue(paymentRepository.Data.Any(x => x.Id == 10));
Assert.IsTrue(paymentRepository.Data.Any(x => x.Id == 15));
}
public async void Add_AddNewEntryOnEveryCall()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
var testEntry = new PaymentEntity
{
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 CreditCardPage(Repository rs, CustomerRepository rp, PaymentRepository rppay)
{
InitializeComponent();
_repositoryp = rppay;
_reserv_rp = rs;
_repository = rp;
}
public void Save_DifferentPaymentTypes_CorrectlySaved()
{
var accountRepositorySetup = new Mock <IAccountRepository>();
accountRepositorySetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Account>());
var categoryDataAccessSetup = new Mock <IRepository <Category> >();
categoryDataAccessSetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Category>());
var paymentDataAccessMock = new PaymentDataAccessMock();
var repository = new PaymentRepository(paymentDataAccessMock,
new RecurringPaymentDataAccessMock(),
accountRepositorySetup.Object,
categoryDataAccessSetup.Object,
new Mock <INotificationService>().Object);
var account = new Account {
Id = 2,
Name = "TestAccount"
};
var payment = new Payment {
ChargedAccount = account,
TargetAccount = null,
Amount = 20,
Type = (int)PaymentType.Income
};
repository.Save(payment);
Assert.AreSame(payment, paymentDataAccessMock.PaymentTestList[0]);
Assert.AreEqual((int)PaymentType.Income, paymentDataAccessMock.PaymentTestList[0].Type);
}
public async void Delete_AssignedPaymentsSetNull()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var categoryRepository = new CategoryRepository(factory);
var paymentRepository = new PaymentRepository(factory);
var category = new CategoryEntity {
Name = "TestCategory"
};
var payment = new PaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Category = category
};
categoryRepository.Add(category);
paymentRepository.Add(payment);
await unitOfWork.Commit();
// Act
categoryRepository.Delete(category);
await unitOfWork.Commit();
// Assert
Assert.Null(payment.Category);
Assert.Null(paymentRepository.GetById(payment.Id).Result.Category);
}
public UnitOfWork(bbuContext context)
{
_context = context;
Addresses = new AddressRepository(_context);
AppUsers = new AppUserRepository(_context);
Banks = new BankRepository(_context);
BankAccounts = new BankAccountRepository(_context);
Cemeteries = new CemeteryRepository(_context);
Credentials = new CredentialsRepository(_context);
Deceaseds = new DeceasedRepository(_context);
Doctors = new DoctorRepository(_context);
Employees = new EmployeeRepository(_context);
Files = new FileRepository(_context);
Funerals = new FuneralRepository(_context);
FuneralDocuments = new FuneralDocumentRepository(_context);
Genders = new GenderRepository(_context);
HomeAffairsOffices = new HomeAffairsOfficeRepository(_context);
HomeAffairsOfficers = new HomeAffairsOfficerRepository(_context);
Hospitals = new HospitalRepository(_context);
Informants = new InformantRepository(_context);
Members = new MemberRepository(_context);
Months = new MonthRepository(_context);
Mortuaries = new MortuaryRepository(_context);
NextOfKins = new NextOfKinRepository(_context);
NumberConfigurations = new NumberConfigurationRepository(_context);
Payments = new PaymentRepository(_context);
PaymentPeriods = new PaymentPeriodRepository(_context);
People = new PersonRepository(_context);
PurchaseItems = new PurchaseItemRepository(_context);
Settings = new SettingRepository(_context);
States = new StateRepository(_context);
Suppliers = new SupplierRepository(_context);
Tasks = new TaskRepository(_context);
Years = new YearRepository(_context);
}
public async Task ShouldRetrieveBillingUser()
{
var services = new ServiceCollection().AddEntityFrameworkInMemoryDatabase();
services.AddSingleton(_webHostEnvironmentMock.Object);
services.AddDbContext <DataContext>(options =>
{
options.UseInMemoryDatabase("InMemoryDB");
});
// mapper
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile <AutoMapperProfiles>();
});
IMapper mapper = config.CreateMapper();
var serviceProvider = services.BuildServiceProvider();
using (var scope = serviceProvider.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var dataContext = scopedServices.GetRequiredService <DataContext>();
DbContextSeed.SeedAsync(dataContext).Wait();
var paymentRepository = new PaymentRepository(dataContext, mapper);
UserForRegisterDto userDetails = await paymentRepository.GetBillingUser(1).ConfigureAwait(false);
Assert.Equal("Nemo", userDetails.FirstName);
}
}
public async Task Given_AValidPaymentWithCreditCard_When_TryToInsert_Then_IsInsertedWithSuccess()
{
// arrange
var dbContextOptions = new DbContextOptionsBuilder <PaymentGatewayContext>()
.UseInMemoryDatabase(databaseName: "InsertTestDatabase")
.Options;
PaymentMethod paymentMethod = new CreditCard(
new CVV("235"),
"John Doe",
"9568475845123569",
new ExpiryDate(this.futureMonth, this.futureYear)
);
Payment payment = new Payment(542.50D, "USD", paymentMethod);
// act
using (var context = new PaymentGatewayContext(dbContextOptions))
{
var repository = new PaymentRepository(context);
await repository.SaveAsync(payment);
}
// assert
using (var context = new PaymentGatewayContext(dbContextOptions))
{
Assert.Equal(1, context.Payment.Count());
Assert.NotNull(context.Payment.Single());
var paymentFromDatabase = context.Payment.Include(p => p.PaymentMethod).Single();
Assert.Equal(542.50D, paymentFromDatabase.Amount);
}
}
public void GetUnclearedPayments_AccountNull()
{
var accountRepositorySetup = new Mock <IAccountRepository>();
accountRepositorySetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Account>());
var categoryDataAccessSetup = new Mock <IRepository <Category> >();
categoryDataAccessSetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Category>());
var repository = new PaymentRepository(new PaymentDataAccessMock(),
new RecurringPaymentDataAccessMock(),
accountRepositorySetup.Object,
categoryDataAccessSetup.Object,
new Mock <INotificationService>().Object);
repository.Data.Add(new Payment {
Amount = 55,
Date = DateTime.Today.AddDays(-1),
Note = "this is a note!!!",
IsCleared = false
}
);
var payments = repository.GetUnclearedPayments();
Assert.AreEqual(1, payments.Count());
}
public PaymentDataAccess()
{
_lineRepository = new LineRepository();
_paymentRepository = new PaymentRepository();
_packageRepository = new PackageRepository();
_clientRepository = new ClientRepository();
}
public void Save_ExistingEntryUpdated()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
try
{
paymentRepository.Save(testPayment);
paymentRepository.FindById(testPayment.Id).ShouldNotBeNull();
const string updatedNote = "FOOOOOOOOOO";
testPayment.Note = updatedNote;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
paymentRepository.FindById(testPayment.Id).Note.ShouldBe(updatedNote);
}
finally
{
paymentRepository.Delete(testPayment);
}
}
public async void Add_AddMultipleEntries()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
// Act
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
await unitOfWork.Commit();
// Assert
Assert.Equal(3, repository.GetAll().Count());
}
public void AddItemToDataList_SaveAccount_IsAddedToData()
{
var accountRepositorySetup = new Mock <IAccountRepository>();
accountRepositorySetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Account>());
var categoryDataAccessSetup = new Mock <IRepository <Category> >();
categoryDataAccessSetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Category>());
var repository = new PaymentRepository(new PaymentDataAccessMock(),
new RecurringPaymentDataAccessMock(),
accountRepositorySetup.Object,
categoryDataAccessSetup.Object,
new Mock <INotificationService>().Object);
var account = new Account {
Id = 2,
Name = "TestAccount"
};
var payment = new Payment {
ChargedAccount = account,
Amount = 20,
Type = (int)PaymentType.Transfer
};
repository.Save(payment);
Assert.IsTrue(repository.Data.Contains(payment));
}
public BookingPage(CustomerRepository rp, PaymentRepository rppay)
{
InitializeComponent();
_repository = rp;
_repositoryp = rppay;
RefreshListBox();
}
public void PaymentRepository_Delete()
{
var accountRepositorySetup = new Mock <IAccountRepository>();
accountRepositorySetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Account>());
var categoryDataAccessSetup = new Mock <IRepository <Category> >();
categoryDataAccessSetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Category>());
var paymentDataAccessMock = new PaymentDataAccessMock();
var repository = new PaymentRepository(new PaymentDataAccessMock(),
new RecurringPaymentDataAccessMock(),
accountRepositorySetup.Object,
categoryDataAccessSetup.Object,
new Mock <INotificationService>().Object);
var account = new Account {
Id = 2,
Name = "TestAccount"
};
var payment = new Payment {
ChargedAccount = account,
ChargedAccountId = 2,
Amount = 20
};
repository.Save(payment);
Assert.AreSame(payment, repository.Data[0]);
repository.Delete(payment);
Assert.IsFalse(repository.Data.Any());
}
public UpdatePaymentStatusWithBankResponseCommandHandler(IMediator mediator, ILogger <UpdatePaymentStatusWithBankResponseCommandHandler> logger, PaymentService paymentService, PaymentRepository paymentRepository)
{
_logger = logger;
_mediator = mediator;
_paymentService = paymentService;
_paymentRepository = paymentRepository;
}
public async void Delete_EntryNotFound()
{
// Arrange
var paymentRepository = new PaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
var testAccount = new AccountEntity {
Name = "testAccount"
};
using (var dbContextScope = dbContextScopeFactory.Create())
{
accountRepository.Add(testAccount);
await dbContextScope.SaveChangesAsync();
}
var testEntry = new PaymentEntity {
ChargedAccount = testAccount
};
// Act / Assert
using (var dbContextScope = dbContextScopeFactory.Create())
{
paymentRepository.Delete(testEntry);
await Assert.ThrowsAsync <DbUpdateConcurrencyException>(async() => await dbContextScope.SaveChangesAsync());
}
}
public async void GetMany_MatchedDataReturned()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
var filterText = "Text";
repository.Add(new PaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = filterText
});
repository.Add(new PaymentEntity {
ChargedAccount = new AccountEntity {
Name = "testAccount"
}
});
repository.Add(new PaymentEntity {
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 Add_IdSet()
{
// Arrange
var paymentRepository = new PaymentRepository(ambientDbContextLocator);
var accountRepository = new AccountRepository(ambientDbContextLocator);
var account = new AccountEntity {
Name = "testAccount"
};
using (var dbContextScope = dbContextScopeFactory.Create())
{
accountRepository.Add(account);
await dbContextScope.SaveChangesAsync();
}
var testEntry = new PaymentEntity
{
ChargedAccount = account,
Note = "Testtext"
};
// Act
using (var dbContextScope = dbContextScopeFactory.Create())
{
paymentRepository.Add(testEntry);
await dbContextScope.SaveChangesAsync();
}
// Assert
Assert.NotNull(testEntry.Id);
Assert.NotEqual(0, testEntry.Id);
}
public async void Update_NoNewEntryAdded()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
var testEntry = new PaymentEntity
{
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 Task Given_APaymentId_When_ThePaymentExistsOnTheDataBase_Then_ReturnsThePaymentDetails()
{
// arrange
var dbContextOptions = new DbContextOptionsBuilder <PaymentGatewayContext>()
.UseInMemoryDatabase(databaseName: "GetTestDatabase")
.Options;
PaymentMethod paymentMethod = new CreditCard(
new CVV("737"),
"John Doe",
"4168842845189769",
new ExpiryDate(this.futureMonth, this.futureYear)
);
Payment payment = new Payment(850D, "EUR", paymentMethod);
// act
using (var context = new PaymentGatewayContext(dbContextOptions))
{
var repository = new PaymentRepository(context);
await repository.SaveAsync(payment);
}
// assert
using (var context = new PaymentGatewayContext(dbContextOptions))
{
var repository = new PaymentRepository(context);
var paymentFromDatabase = await repository.GetByIdAsync(payment.Id);
Assert.NotNull(paymentFromDatabase);
Assert.Equal(payment.Amount, paymentFromDatabase.Amount);
Assert.Equal(payment.Currency, paymentFromDatabase.Currency);
}
}
public async void Add_AddedAndRead()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
var testEntry = new PaymentEntity
{
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 Update_EntryUpdated()
{
// Arrange
var factory = new DbFactory();
var unitOfWork = new UnitOfWork(factory);
var repository = new PaymentRepository(factory);
var newValue = "newText";
var testEntry = new PaymentEntity
{
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 UnitOfWork()
{
_context = new DataContext();
People = new PersonRepository(_context);
Payments = new PaymentRepository(_context);
PaymentDetails = new PaymentDetailRepository(_context);
}
public void AddPayment()
{
using (CapriconContext context = new CapriconContext())
{
var messageRepository = new MessageRepository(context);
var existingMessage = messageRepository.GetAll().LastOrDefault();
Assert.IsNotNull(existingMessage);
var newPayment = new Payment()
{
PaymentDate = DateTime.Now,
Amount = 750,
Message = existingMessage
};
var paymentRep = new PaymentRepository(context);
paymentRep.Add(newPayment);
try
{
context.SaveChanges();
}
catch (DbEntityValidationException ex)
{
//Retrieve validation errors
ex.EntityValidationErrors.ToList().ForEach
(
v =>
{
v.ValidationErrors.ToList().ForEach
(
e =>
{
System.Diagnostics.Debug.WriteLine(e.ErrorMessage);
}
);
}
);
Assert.Fail("Test failed");
}
//retrieve saved object
var context1 = new CapriconContext();
var repository = new PaymentRepository(context1);
var savedPayments = repository.GetAll().ToList();
Assert.AreEqual(savedPayments.Count(), 3, "returns 20 records");
var savedPaymentsList = savedPayments;
savedPaymentsList.ForEach
(
p =>
{
Debug.WriteLine(p.PaymentId + " - " + p.Amount + " " + p.Message.MessageId);
}
);
};
}
public void ClearPayments()
{
var dbManager = new DatabaseManager(new DroidSqliteConnectionFactory(), new MvxAndroidFileStore());
var paymentRepository = new PaymentRepository(dbManager);
var paymentManager = new PaymentManager(paymentRepository,
new AccountRepository(dbManager),
new RecurringPaymentRepository(dbManager),
null);
paymentManager.ClearPayments();
}
private void CheckRecurringPayments()
{
var dbManager = new DatabaseManager(new DroidSqliteConnectionFactory(), new MvxAndroidFileStore());
var paymentRepository = new PaymentRepository(dbManager);
var paymentManager = new PaymentManager(paymentRepository,
new AccountRepository(dbManager),
new RecurringPaymentRepository(dbManager),
null);
new RecurringPaymentManager(paymentManager, paymentRepository, new SettingsManager(new Settings())).CheckRecurringPayments();
}
public void DeletePayment()
{
using (var uow = new CapriconContext())
{
var paymentRep = new PaymentRepository(uow);
var existingPayment = paymentRep.Find(p => p.PaymentId == 2).FirstOrDefault();
Assert.IsNotNull(existingPayment);
int paymentId;
if (existingPayment != null)
{
paymentId = existingPayment.PaymentId;
//Delete payment
paymentRep.Delete(existingPayment);
try
{
uow.SaveChanges();
}
catch (DbEntityValidationException ex)
{
//Retrieve validation errors
ex.EntityValidationErrors.ToList().ForEach
(
v =>
{
v.ValidationErrors.ToList().ForEach
(
e =>
{
System.Diagnostics.Debug.WriteLine(e.ErrorMessage);
}
);
}
);
Assert.Fail("Test failed");
}
Assert.IsNull(paymentRep.Find(p => p.PaymentId == paymentId).FirstOrDefault());
}
else //no payments were selected
Assert.Fail("No payment was selected");
}
}
public void Save_IdSet()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
try
{
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
testPayment.Id.ShouldBeGreaterThan(0);
}
finally
{
paymentRepository.Delete(testPayment);
}
}
public void Save_WithTargetAccount()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var accountRepository =
new AccountRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var account = new Fixture().Create<AccountViewModel>();
account.Id = 0;
accountRepository.Save(account);
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
testPayment.ChargedAccount = account;
testPayment.TargetAccount = null;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var selected = paymentRepository.FindById(testPayment.Id);
selected.ShouldNotBeNull();
selected.ShouldBeInstanceOf<PaymentViewModel>();
selected.ChargedAccount.ShouldNotBeNull();
selected.ChargedAccount.Id.ShouldBe(selected.ChargedAccountId);
selected.ChargedAccount.Id.ShouldBe(testPayment.ChargedAccount.Id);
paymentRepository.Delete(testPayment);
paymentRepository.FindById(testPayment.Id).ShouldBeNull();
}
public void GetList_WithRecurringPayment_RecPaymentDependenciesLoaded()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var accountRepository =
new AccountRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var fixture = new Fixture();
var account = fixture.Create<AccountViewModel>();
account.Id = 0;
accountRepository.Save(account);
var testPayment = fixture.Create<PaymentViewModel>();
testPayment.Id = 0;
testPayment.RecurringPaymentId = 0;
testPayment.RecurringPayment.Id = 0;
testPayment.IsRecurring = true;
testPayment.ChargedAccount = account;
testPayment.RecurringPayment.ChargedAccount = account;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var selected = paymentRepository.GetList(x => x.Id == testPayment.Id).First();
selected.ShouldNotBeNull();
selected.ShouldBeInstanceOf<PaymentViewModel>();
selected.RecurringPayment.ShouldNotBeNull();
selected.RecurringPayment.Id.ShouldBe(selected.RecurringPaymentId);
selected.RecurringPayment.Id.ShouldBe(testPayment.RecurringPayment.Id);
selected.RecurringPayment.ChargedAccount.ShouldNotBeNull();
paymentRepository.Delete(testPayment);
paymentRepository.FindById(testPayment.Id).ShouldBeNull();
}
public void Save_WithRecurringPayment_IdInCacheSet()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
testPayment.IsRecurring = true;
testPayment.RecurringPayment.Id = 0;
paymentRepository.Save(testPayment);
var selected = paymentRepository.FindById(testPayment.Id);
selected.ShouldNotBeNull();
selected.ShouldBeInstanceOf<PaymentViewModel>();
selected.RecurringPayment.ShouldNotBeNull();
selected.RecurringPayment.ShouldBeInstanceOf<RecurringPaymentViewModel>();
selected.RecurringPayment.Id.ShouldBeGreaterThan(0);
selected.RecurringPaymentId.ShouldBeGreaterThan(0);
}
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 void Save_WithCategory()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var categoryRepository =
new CategoryRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testCategory = new Fixture().Create<CategoryViewModel>();
testCategory.Id = 0;
categoryRepository.Save(testCategory);
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
testPayment.Category = testCategory;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var selected = paymentRepository.FindById(testPayment.Id);
selected.ShouldNotBeNull();
selected.ShouldBeInstanceOf<PaymentViewModel>();
selected.Category.ShouldNotBeNull();
selected.Category.Id.ShouldBe(selected.CategoryId.Value);
selected.Category.Id.ShouldBe(testPayment.Category.Id);
paymentRepository.Delete(testPayment);
paymentRepository.FindById(testPayment.Id).ShouldBeNull();
}
public void GetList_WithChildren()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var categoryRepository =
new CategoryRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var fixture = new Fixture();
var category = fixture.Create<CategoryViewModel>();
category.Id = 0;
categoryRepository.Save(category);
var payment = fixture.Create<PaymentViewModel>();
payment.Id = 0;
payment.Category = category;
paymentRepository.Save(payment);
paymentRepository.ReloadCache();
var selected = paymentRepository.GetList(x => x.Id == payment.Id).First();
selected.ShouldNotBeNull();
selected.Category.ShouldNotBeNull();
}
public void GetList_WithoutFilter()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
try
{
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var selectedAccount = paymentRepository.GetList().First();
selectedAccount.Id.ShouldBe(testPayment.Id);
selectedAccount.Amount.ShouldBe(testPayment.Amount);
}
finally
{
paymentRepository.Delete(testPayment);
}
}
public void UpdatePayment()
{
using (var uow = new CapriconContext())
{
var paymentRep = new PaymentRepository(uow);
var existingPayments = paymentRep.GetAll().ToList();
var existingPayment = existingPayments.Find(p => p.PaymentId == 3);
Assert.IsNotNull(existingPayment);
var messageRepository = new MessageRepository(uow);
var existingMessage = messageRepository.GetAll().FirstOrDefault();
Assert.IsNotNull(existingMessage);
existingPayment.PaymentDate = DateTime.Now;
existingPayment.Amount = 350;
existingPayment.Message = existingMessage;
//check for validation rules
//existingPayment.PaymentDate = DateTime.Now;
paymentRep.Attach(existingPayment);
uow.Entry(existingPayment).State = EntityState.Modified;
try
{
uow.SaveChanges();
}
catch (DbEntityValidationException ex)
{
//Retrieve validation errors
ex.EntityValidationErrors.ToList().ForEach
(
v =>
{
v.ValidationErrors.ToList().ForEach
(
e =>
{
System.Diagnostics.Debug.WriteLine(e.ErrorMessage);
}
);
}
);
Assert.Fail("Test failed");
}
};
//retrieve saved object
var uow1 = new CapriconContext();
var repository = new PaymentRepository(uow1);
var savedPayments = repository.GetAll().ToList();
Assert.AreEqual(savedPayments[0].Amount, 350);
}
public void Save_WithCategory_FkSet()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var categoryRepository =
new CategoryRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var fixture = new Fixture();
var category = fixture.Create<CategoryViewModel>();
categoryRepository.Save(category);
category.Id.ShouldBeGreaterThan(0);
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
testPayment.Category = category;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
paymentRepository.FindById(testPayment.Id).CategoryId.Value.ShouldBeGreaterThan(0);
}
public void Save_WithNoChildrenSet()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testPayment = new PaymentViewModel
{
Amount = 40,
ChargedAccount = new AccountViewModel()
};
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var selected = paymentRepository.FindById(testPayment.Id);
selected.ShouldNotBeNull();
selected.ShouldBeInstanceOf<PaymentViewModel>();
}
public void SaveAndUpdate_WithCategory_NoDuplicates()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var categoryRepository =
new CategoryRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var category = new Fixture().Create<CategoryViewModel>();
category.Id = 0;
categoryRepository.Save(category);
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
testPayment.Category = category;
paymentRepository.Save(testPayment);
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var selected = paymentRepository.FindById(testPayment.Id);
categoryRepository.GetList(x => x.Name == testPayment.Category.Name).Count().ShouldBe(1);
}
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 void FindById_AccountDeleted()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var selected = paymentRepository.FindById(testPayment.Id);
selected.ShouldNotBeNull();
selected.ShouldBeInstanceOf<PaymentViewModel>();
paymentRepository.Delete(testPayment);
paymentRepository.FindById(testPayment.Id).ShouldBeNull();
}
public void Delete_WithChildren_PaymentDeleted()
{
var paymentRepository =
new PaymentRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var categoryRepository =
new CategoryRepository(new DatabaseManager(new WindowsSqliteConnectionFactory(),
new MvxWpfFileStore(FILE_ROOT)));
var category = new Fixture().Create<CategoryViewModel>();
category.Id = 0;
categoryRepository.Save(category);
var testPayment = new Fixture().Create<PaymentViewModel>();
testPayment.Id = 0;
testPayment.Category = category;
paymentRepository.Save(testPayment);
paymentRepository.ReloadCache();
var payment = paymentRepository.FindById(testPayment.Id);
payment.ShouldNotBeNull();
payment.Category.ShouldNotBeNull();
paymentRepository.Delete(testPayment);
paymentRepository.FindById(testPayment.Id).ShouldBeNull();
categoryRepository.FindById(testPayment.Category.Id).ShouldNotBeNull();
}
