public async Task SavePayment_ResultSucceeded_CorrectMethodCalls()
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default))
.ReturnsAsync(() => new Account("as"));
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
mediatorMock.Verify(x => x.Send(It.IsAny <CreatePaymentCommand>(), default), Times.Once);
dialogServiceMock.Verify(x => x.ShowMessageAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
navigationServiceMock.Verify(x => x.GoBack(), Times.Once);
}
public async Task <ActionResult> Add(AddPaymentViewModel model)
{
Payment payment = new Payment
{
CreatedAt = DateTime.Now,
DebId = model.DebId,
Id = model.Id,
Quantity = model.Quantity
};
if (ModelState.IsValid && model.Quantity > 0 && _debService.Get(payment.DebId).Deleted != Model.Enums.Deleted.yes)
{
if (await _paymentService.Add(payment))
{
TempData["response"] = "Pago realizado con exito";
TempData["icon"] = "success";
}
else
{
TempData["response"] = "Lo sentimos, no puede hacer un abono";
TempData["icon"] = "error";
}
}
else
{
TempData["response"] = "Lo sentimos, ha ocurrido un error";
TempData["icon"] = "error";
}
return(RedirectToAction("Detail", "AccountClient", new { id = model.AccountId }));
}
public async Task AmountCorrectlyFormattedOnSave(string cultureString, string amountString, decimal expectedAmount)
{
// Arrange
var cultureInfo = new CultureInfo(cultureString);
Thread.CurrentThread.CurrentCulture = cultureInfo;
Thread.CurrentThread.CurrentUICulture = cultureInfo;
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default))
.ReturnsAsync(() => new Account("as"));
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
// Act
addPaymentVm.AmountString = amountString;
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
addPaymentVm.SelectedPayment.Amount.ShouldEqual(expectedAmount);
}
public async Task SavePayment_ResultFailedWithBackup_CorrectMethodCalls()
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <CreatePaymentCommand>(), default))
.Callback(() => throw new Exception());
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default))
.ReturnsAsync(() => new Account("as"));
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
// Act
await Assert.ThrowsAsync <Exception>(async() => await addPaymentVm.SaveCommand.ExecuteAsync());
// Assert
mediatorMock.Verify(x => x.Send(It.IsAny <CreatePaymentCommand>(), default), Times.Once);
mediatorMock.Verify(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default), Times.Once);
navigationServiceMock.Verify(x => x.GoBack(), Times.Never);
backupServiceMock.Verify(x => x.UploadBackupAsync(BackupMode.Manual), Times.Never);
}
public async Task SavePayment_ResultSucceeded_CorrectMethodCalls()
{
// Arrange
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
paymentServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
mediatorMock.Verify(x => x.Send(It.IsAny <CreatePaymentCommand>(), default), Times.Once);
dialogServiceMock.Verify(x => x.ShowMessage(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
navigationServiceMock.Verify(x => x.GoBack(), Times.Once);
settingsFacadeMock.VerifySet(x => x.LastExecutionTimeStampSyncBackup = It.IsAny <DateTime>(), Times.Once);
backupServiceMock.Verify(x => x.EnqueueBackupTaskAsync(0), Times.Never);
}
public async Task SavePayment_ResultSucceededWithBackup_CorrectMethodCalls()
{
// Arrange
paymentServiceMock.Setup(x => x.SavePayment(It.IsAny <PaymentViewModel>()))
.Returns(Task.CompletedTask);
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapperMock.Object,
paymentServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel();
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
paymentServiceMock.Verify(x => x.SavePayment(It.IsAny <PaymentViewModel>()), Times.Once);
dialogServiceMock.Verify(x => x.ShowMessage(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
navigationServiceMock.Verify(x => x.GoBack(), Times.Once);
settingsFacadeMock.VerifySet(x => x.LastExecutionTimeStampSyncBackup = It.IsAny <DateTime>(), Times.Once);
backupServiceMock.Verify(x => x.EnqueueBackupTask(0), Times.Once);
}
public object AddPaymentMethod([FromBody] AddPaymentViewModel addPaymentViewModel)
{
try
{
_financeRepository.AddPaymentMethod(addPaymentViewModel);
return(new SingleResponse <PaymentMethod>
{
Message = "Payment Method added successfully",
DidError = false,
ErrorMessage = string.Empty,
Token = string.Empty,
Model = new PaymentMethod()
});
}
catch (Exception ex)
{
return(new SingleResponse <PaymentMethod>
{
Message = ex.Message,
DidError = true,
ErrorMessage = ex.InnerException.ToString(),
Token = string.Empty,
Model = new PaymentMethod()
});
}
}
public async Task SavePayment_NoAccount_DialogShown()
{
// Arrange
paymentServiceMock.Setup(x => x.SavePayment(It.IsAny <PaymentViewModel>()))
.Returns(Task.CompletedTask);
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapperMock.Object,
paymentServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
paymentServiceMock.Verify(x => x.SavePayment(It.IsAny <PaymentViewModel>()), Times.Never);
dialogServiceMock.Verify(x => x.ShowMessage(Strings.MandatoryFieldEmptyTitle, Strings.AccountRequiredMessage), Times.Once);
navigationServiceMock.Verify(x => x.GoBack(), Times.Never);
settingsFacadeMock.VerifySet(x => x.LastExecutionTimeStampSyncBackup = It.IsAny <DateTime>(), Times.Never);
backupServiceMock.Verify(x => x.EnqueueBackupTask(0), Times.Never);
}
public async Task Initialize_IncomeExpense_PaymentChargedAccountNotNull(PaymentType type)
{
// Arrange
paymentServiceMock.Setup(x => x.SavePayment(It.IsAny <PaymentViewModel>()))
.Returns(Task.CompletedTask);
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountsQuery>(), default))
.ReturnsAsync(new List <Account> {
new Account("dfasdf")
});
mapperMock.Setup(x => x.Map <List <AccountViewModel> >(It.IsAny <List <Account> >()))
.Returns(new List <AccountViewModel> {
new AccountViewModel()
});
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapperMock.Object,
paymentServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
addPaymentVm.PaymentType = type;
// Act
await addPaymentVm.InitializeCommand.ExecuteAsync();
// Assert
addPaymentVm.SelectedPayment.ChargedAccount.ShouldNotBeNull();
addPaymentVm.SelectedPayment.TargetAccount.ShouldBeNull();
}
public async Task Initialize_IncomeExpense_PaymentChargedAccountNotNull(PaymentType type)
{
// Arrange
paymentServiceMock.Setup(x => x.SavePayment(It.IsAny <PaymentViewModel>()))
.Returns(Task.CompletedTask);
crudServiceMock.Setup(x => x.ReadManyNoTracked <AccountViewModel>())
.Returns(new List <AccountViewModel> {
new AccountViewModel()
}.AsQueryable().BuildMock().Object);
var addPaymentVm = new AddPaymentViewModel(paymentServiceMock.Object,
crudServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
addPaymentVm.SelectedPayment.Type = type;
// Act
await addPaymentVm.InitializeCommand.ExecuteAsync();
// Assert
addPaymentVm.SelectedPayment.ChargedAccount.ShouldNotBeNull();
addPaymentVm.SelectedPayment.TargetAccount.ShouldBeNull();
}
public async Task SavePayment_ResultFailedWithBackup_CorrectMethodCalls()
{
// Arrange
paymentServiceMock.Setup(x => x.SavePayment(It.IsAny <PaymentViewModel>()))
.Callback(() => throw new Exception());
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapperMock.Object,
paymentServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel();
// Act
await Assert.ThrowsAsync <Exception>(async() => await addPaymentVm.SaveCommand.ExecuteAsync());
// Assert
paymentServiceMock.Verify(x => x.SavePayment(It.IsAny <PaymentViewModel>()), Times.Once);
navigationServiceMock.Verify(x => x.GoBack(), Times.Never);
backupServiceMock.Verify(x => x.EnqueueBackupTask(0), Times.Never);
}
public void SavePayment_ResultFailed_CorrectMethodCalls()
{
// Arrange
paymentServiceMock.Setup(x => x.SavePayment(It.IsAny <PaymentViewModel>()))
.ReturnsAsync(OperationResult.Failed(""));
var addPaymentVm = new AddPaymentViewModel(paymentServiceMock.Object,
crudServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
new Mock <IMvxMessenger>().Object,
backupServiceMock.Object,
new Mock <IMvxLogProvider>().Object,
navigationServiceMock.Object);
addPaymentVm.Prepare(new ModifyPaymentParameter());
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel();
// Act
addPaymentVm.SaveCommand.Execute();
// Assert
paymentServiceMock.Verify(x => x.SavePayment(It.IsAny <PaymentViewModel>()), Times.Once);
dialogServiceMock.Verify(x => x.ShowMessage(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
navigationServiceMock.Verify(x => x.Close(It.IsAny <MvxViewModel>(), CancellationToken.None), Times.Never);
settingsFacadeMock.VerifySet(x => x.LastExecutionTimeStampSyncBackup = It.IsAny <DateTime>(), Times.Once);
backupServiceMock.Verify(x => x.EnqueueBackupTask(0), Times.Once);
}
public async Task ShowMessageIfAmountIsNegativeOnSave()
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default))
.ReturnsAsync(() => new Account("as"));
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
addPaymentVm.AmountString = "-2";
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
dialogServiceMock.Verify(x => x.ShowMessageAsync(Strings.AmountMayNotBeNegativeTitle, Strings.AmountMayNotBeNegativeMessage),
Times.Once);
navigationServiceMock.Verify(x => x.GoBack(), Times.Never);
settingsFacadeMock.VerifySet(x => x.LastExecutionTimeStampSyncBackup = It.IsAny <DateTime>(), Times.Never);
backupServiceMock.Verify(x => x.UploadBackupAsync(BackupMode.Manual), Times.Never);
}
public async Task Initialize_Transfer_PaymentChargedAccountNotNull()
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountsQuery>(), default))
.ReturnsAsync(new List <Account> {
new Account("dfasdf"), new Account("Foo")
});
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
paymentServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
addPaymentVm.PaymentType = PaymentType.Transfer;
// Act
await addPaymentVm.InitializeCommand.ExecuteAsync();
// Assert
addPaymentVm.SelectedPayment.ChargedAccount.ShouldNotBeNull();
addPaymentVm.SelectedPayment.TargetAccount.ShouldNotBeNull();
}
public void SavePayment_NoAccount_DialogShown()
{
// Arrange
paymentServiceMock.Setup(x => x.SavePayment(It.IsAny <PaymentViewModel>()))
.ReturnsAsync(OperationResult.Succeeded());
var addPaymentVm = new AddPaymentViewModel(paymentServiceMock.Object,
crudServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
new Mock <IMvxMessenger>().Object,
backupServiceMock.Object,
new Mock <IMvxLogProvider>().Object,
navigationServiceMock.Object);
addPaymentVm.Prepare(new ModifyPaymentParameter());
// Act
addPaymentVm.SaveCommand.Execute();
// Assert
paymentServiceMock.Verify(x => x.SavePayment(It.IsAny <PaymentViewModel>()), Times.Never);
dialogServiceMock.Verify(x => x.ShowMessage(Strings.MandatoryFieldEmptyTitle, Strings.AccountRequiredMessage), Times.Once);
navigationServiceMock.Verify(x => x.Close(It.IsAny <MvxViewModel>(), CancellationToken.None), Times.Never);
settingsFacadeMock.VerifySet(x => x.LastExecutionTimeStampSyncBackup = It.IsAny <DateTime>(), Times.Never);
backupServiceMock.Verify(x => x.EnqueueBackupTask(0), Times.Never);
}
public async Task ShowNoMessageIfAmountIsPositiveOnSave(string amountString)
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default))
.ReturnsAsync(() => new Account("as"));
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
addPaymentVm.AmountString = amountString;
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
dialogServiceMock.Verify(x => x.ShowMessageAsync(Strings.AmountMayNotBeNegativeTitle, Strings.AmountMayNotBeNegativeMessage),
Times.Never);
}
public async Task SavePayment_ResultSucceededWithBackup_CorrectMethodCalls()
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default))
.ReturnsAsync(() => new Account("as"));
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
mediatorMock.Verify(x => x.Send(It.IsAny <CreatePaymentCommand>(), default), Times.Once);
dialogServiceMock.Verify(x => x.ShowMessageAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
navigationServiceMock.Verify(x => x.GoBack(), Times.Once);
settingsFacadeMock.VerifySet(x => x.LastExecutionTimeStampSyncBackup = It.IsAny <DateTime>(), Times.Once);
backupServiceMock.Verify(x => x.UploadBackupAsync(BackupMode.Automatic), Times.Once);
}
public async Task <IActionResult> AddPaycheckPayment(AddPaymentViewModel model)
{
if (!ModelState.IsValid)
{
var errorMessage = ViewData.ModelState.Values.FirstOrDefault(v => v.Errors.Any()).Errors.FirstOrDefault().ErrorMessage;
return(RedirectToHomePayrollWithMessage(errorMessage, employeeId: model.EmployeeId));
}
var paycheck = await this.PayrollService.FindEmployeePaycheck(model.EmployeeId, model.PaycheckId);
if (paycheck == null)
{
return(RedirectToHomePayrollWithMessage("Paycheck not found."));
}
if (paycheck.Total < paycheck.GetPaidAmount() + model.Payment.Amount)
{
var errorMessage = string.Format("Maximum amount that can be payed is {0}", paycheck.Total - paycheck.GetPaidAmount());
return(RedirectToHomePayrollWithMessage(errorMessage, employeeId: model.EmployeeId));
}
if (model.Payment.Amount < 0)
{
return(RedirectToHomePayrollWithMessage("Amount can't be negative number.", employeeId: model.EmployeeId));
}
await this.PayrollService.AddPayment(paycheck, DateTime.Today, model.Payment.Amount);
return(RedirectToHomePayrollWithMessage(string.Empty));
}
public async Task SavePayment_ResultFailed_CorrectMethodCalls()
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <CreatePaymentCommand>(), default))
.Callback(() => throw new Exception());
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
paymentServiceMock.Object,
dialogServiceMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
addPaymentVm.SelectedPayment.ChargedAccount = new AccountViewModel {
Name = "asdf"
};
// Act
await Assert.ThrowsAsync <Exception>(async() => await addPaymentVm.SaveCommand.ExecuteAsync());
// Assert
mediatorMock.Verify(x => x.Send(It.IsAny <CreatePaymentCommand>(), default), Times.Once);
navigationServiceMock.Verify(x => x.GoBack(), Times.Never);
backupServiceMock.Verify(x => x.EnqueueBackupTaskAsync(0), Times.Never);
}
public async Task <JsonResult> AddPayment(AddPaymentViewModel model)
{
if (!ModelState.IsValid)
{
return(JsonModelStateErrors());
}
return(await JsonAsync(_paymentService.AddPaymentAsync(model)));
}
public IActionResult Add(int AppointmentId, bool isDeposit = false)
{
var viewModel = new AddPaymentViewModel
{
Appointment = context.Appointments.Include(x => x.Payments).Single(x => x.Id == AppointmentId),
IsDeposit = isDeposit
};
return(View(viewModel));
}
/// <summary>
/// verified exist payment
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private async Task <bool> ExistPaymentAsync(AddPaymentViewModel model)
{
var payment = await _context.PaymentMappers
.Include(i => i.Payment)
.FirstOrDefaultAsync(x => x.Payment.DateTransaction == model.DateTransaction &&
x.Payment.TotalPrice == model.TotalPrice &&
x.OrganizationId == model.OrganizationId &&
x.ProductId == model.ProductId &&
x.Payment.DocumentNumber == model.DocumentNumber);
return(payment != null);
}
public BillingViewModel()
{
LoadCommand = new DelegateCommand(new Action(LoadBillings));
ArchiveCommand = new DelegateCommand(new Action(Archive));
UnarchiveCommand = new DelegateCommand(new Action(Unarchive));
DeleteCommand = new DelegateCommand(new Action(DeleteBilling));
AddCommand = new DelegateCommand(new Action(GotoAddBilling));
EditCommand = new DelegateCommand(new Action(GotoEditBilling));
AddPaymentViewModel = new AddPaymentViewModel();
AddPaymentCommand = new DelegateCommand(new Action(AddPayment));
PaymentViewModel = new PaymentViewModel();
PatientViewModel = new PatientViewModel();
PatientViewModel.LoadPatients();
}
public async Task AmountStringSetOnInit()
{
// Arrange
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
navigationServiceMock.Object);
// Act
await addPaymentVm.InitializeCommand.ExecuteAsync();
// Assert
addPaymentVm.AmountString.ShouldEqual("0.00");
}
public ViewModelLocator()
{
if (!DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
MainViewModel = new MainViewModel();
HomeViewModel = new HomeViewModel();
PaymentsViewModel = new PaymentsViewModel();
InvoiceViewModel = new InvoicesViewModel();
AddPaymentViewModel = new AddPaymentViewModel();
AddInvoiceViewModel = new AddInvoiceViewModel();
InvoiceDetailsViewModel = new InvoiceDetailsViewModel();
PaymentDetailsViewModel = new PaymentDetailsViewModel();
BalanceStatementViewModel = new BalanceStatementViewModel();
}
}
public void Prepare_PaymentCreated()
{
// Arrange
var addPaymentVm = new AddPaymentViewModel(null,
crudServiceMock.Object,
null, null,
new Mock <IMvxMessenger>().Object,
null, null, null);
// Act
addPaymentVm.Prepare(new ModifyPaymentParameter());
// Assert
addPaymentVm.SelectedPayment.ShouldNotBeNull();
}
public void Prepare_Title_Set()
{
// Arrange
var addPaymentVm = new AddPaymentViewModel(null,
crudServiceMock.Object,
null, null,
new Mock <IMvxMessenger>().Object,
null, null, null);
// Act
addPaymentVm.Prepare(new ModifyPaymentParameter());
// Assert
addPaymentVm.Title.Contains(Strings.AddTitle);
}
public async Task Initialize_PaymentHasCorrectType(PaymentType type)
{
// Arrange
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
navigationServiceMock.Object);
addPaymentVm.PaymentType = type;
// Act
await addPaymentVm.InitializeCommand.ExecuteAsync();
// Assert
addPaymentVm.SelectedPayment.Type.ShouldEqual(type);
}
public PaymentMethod AddPaymentMethod(AddPaymentViewModel addPaymentViewModel)
{
try
{
PaymentMethod paymentMethod = new PaymentMethod();
var query = $"EXEC AddPaymentMethod'{addPaymentViewModel.UserId}', '{addPaymentViewModel.FirstName}','{addPaymentViewModel.LastName}','{addPaymentViewModel.CardNumber}','{addPaymentViewModel.Expiry}','{addPaymentViewModel.CVV}','{addPaymentViewModel.IsDefault}','{addPaymentViewModel.IsDelete}','{addPaymentViewModel.Timestamp}';";
paymentMethod = _context.PaymentMethod.FromSql(query).FirstOrDefault();
return(paymentMethod);
}
catch (Exception ex)
{
return(null);
}
}
public async Task SavePayment_NoAccount_DialogShown()
{
// Arrange
var addPaymentVm = new AddPaymentViewModel(mediatorMock.Object,
mapper,
dialogServiceMock.Object,
navigationServiceMock.Object);
await addPaymentVm.InitializeCommand.ExecuteAsync();
// Act
await addPaymentVm.SaveCommand.ExecuteAsync();
// Assert
dialogServiceMock.Verify(x => x.ShowMessageAsync(Strings.MandatoryFieldEmptyTitle, Strings.AccountRequiredMessage), Times.Once);
navigationServiceMock.Verify(x => x.GoBack(), Times.Never);
}
