public BaseApiResponse InsertUpdatePayment(PaymentEntity model)
{
var response = new BaseApiResponse();
try
{
SqlParameter[] param =
{
new SqlParameter("PmtNo", (object)model.PmtNo ?? (object)DBNull.Value)
, new SqlParameter("PaidBy", (object)model.PaidBy ?? (object)DBNull.Value)
, new SqlParameter("ChkNo", (object)model.ChkNo ?? (object)DBNull.Value)
, new SqlParameter("PmtDate", (object)model.PmtNo ?? (object)DBNull.Value)
, new SqlParameter("ChkAmt", (object)model.ChkAmt ?? (object)DBNull.Value)
};
var result = _repository.ExecuteSQL <int>("InsertUpdatePayment", param).FirstOrDefault();
if (result > 0)
{
response.Success = true;
}
}
catch (Exception ex)
{
response.Message.Add(ex.Message);
}
return(response);
}
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 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 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 void Test_Mapping_Functional()
{
//Arrange
Db.Recreate();
var payment = new PaymentEntity()
{
Id = 1, SourceAccountId = "1", TransactionSuccessful = true, Amount = 1, From = "1", To = "2"
};
//Act
using (AppDbContext ctx1 = Db.GetAdminContext())
{
ctx1.Set <PaymentEntity>().Add(payment);
ctx1.SaveChanges();
}
//Assert
using AppDbContext ctx2 = Db.GetAdminContext();
PaymentEntity savedPayment = ctx2.Set <PaymentEntity>().Find(payment.Id);
Assert.AreEqual(payment.Id, savedPayment.Id);
Assert.AreEqual(payment.SourceAccountId, savedPayment.SourceAccountId);
Assert.AreEqual(payment.To, savedPayment.To);
Assert.AreEqual(payment.From, savedPayment.From);
Assert.AreEqual(payment.Amount, savedPayment.Amount);
Assert.AreEqual(payment.TransactionSuccessful, savedPayment.TransactionSuccessful);
}
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 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 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 DataResultArgs <PaymentEntity> SetPaymentAmount(string id, string encryptStudentId, string year, string month,
string currentAmount, string paymentType)
{
PaymentEntity paymentEntity = new PaymentEntity
{
EncryptStudentId = encryptStudentId,
StudentId = GeneralFunctions.GetData <int>(Cipher.Decrypt(encryptStudentId)),
Year = GeneralFunctions.GetData <short>(year),
Month = GeneralFunctions.GetData <short>(month),
Amount = GeneralFunctions.GetData <decimal>(currentAmount),
Id = GeneralFunctions.GetData <int>(id)
};
paymentEntity.DatabaseProcess = (paymentEntity.Id > 0) ? DatabaseProcess.Update : DatabaseProcess.Add;
paymentEntity.IsActive = true;
paymentEntity.IsDeleted = false;
paymentEntity.PaymentDate = DateTime.Now;
paymentEntity.IsPayment = null;
paymentEntity.PaymentType = GeneralFunctions.GetData <short>(paymentType);
DataResultArgs <string> resultSet = new PaymentBusiness().Set_Payment(paymentEntity);
paymentEntity.Id = GeneralFunctions.GetData <int>(resultSet.Result);
DataResultArgs <PaymentEntity> returnResultSet = new DataResultArgs <PaymentEntity>
{
ErrorCode = resultSet.ErrorCode,
ErrorDescription = resultSet.ErrorDescription,
HasError = resultSet.HasError,
Result = paymentEntity
};
return(returnResultSet);
}
private void CreateTestObject()
{
_paymentRequest = new PaymentRequest()
{
Amount = 900,
Currency = "EUR",
CardInformation = new CardInformation()
{
CardNumber = "1111222233334444",
ExpiryMonth = 12,
ExpiryYear = 2021,
Cvv = 123
}
};
_paymentRequest2 = new PaymentRequest()
{
Amount = 1500,
Currency = "EUR",
CardInformation = new CardInformation()
{
CardNumber = "1111222233334444",
ExpiryMonth = 12,
ExpiryYear = 2021,
Cvv = 123
}
};
_successfulPaymentResponse = new PaymentResponse()
{
PaymentId = new Guid("10013B70-6182-48E7-8222-1E14EBF86000"),
Message = "Successful",
Status = true
};
_unsuccessfulPaymentResponse = new PaymentResponse()
{
PaymentId = new Guid("10013B70-6182-48E7-8222-1E14EBF86111"),
Message = "Unsuccessful",
Status = false
};
_paymentResponseFromRepo = new PaymentEntity()
{
Amount = 899,
CardId = 1,
Code = new Guid("10013B70-6182-48E7-8222-1E14EBF866CF"),
Currency = "EUR",
Message = "Successful",
Status = true
};
_cardInformation = new CardInformationEntity()
{
CardNumber = "1111222233334444",
Cvv = 123,
ExpiryMonth = 12,
ExpiryYear = 2022
};
}
public TransactionEntity Create(PaymentEntity payment)
{
TransactionEntity transaction = new TransactionEntity();
bool processingError = false;
_DownPayment = Company.GetBusinessObject(BoObjectTypes.oVendorPayments);
_PaymentEntity = payment;
_CreatePaymentHeading();
_AssignPaymentType();
foreach (var document in payment.Documents)
{
TransactionEntity payTransaction = null;
TransactionEntity creditNoteTransaction = null;
if (document.PayAmount > 0)
{
payTransaction = _PayDocument(payment, document);
if (!payTransaction.Success)
{
transaction.Message = payTransaction.Message;
processingError = true;
break;
}
}
if (document.CreditNote.Amount > 0)
{
creditNoteTransaction = _AddCreditNote(payment, document);
if (!creditNoteTransaction.Success)
{
transaction.Message = creditNoteTransaction.Message;
processingError = true;
break;
}
}
}
if (!processingError)
{
if (_DownPayment.Add() != 0)
{
transaction.Message = ErrorMessage;
}
else
{
string newEntityId;
Company.GetNewObjectCode(out newEntityId);
transaction.Successfull(newEntityId);
}
}
else
{
_DownPayment.Cancel();
}
Company.Disconnect();
return(transaction);
}
public void TestAddAttachment()
{
DateTime dueDate = new DateTime(2010, 10, 10);
decimal dueAmount = 100m;
APartyEntity payee = new SupplierEntity(SupplierType.Cruise, "", "Galasam");
APartyEntity payer = new CustomerEntity(CustomerType.Bureau, "", "Lonely Tree");
PaymentType type = PaymentType.Full;
string sale = "SR Josef";
int booking = 59;
PaymentEntity paymentEntity = new PaymentEntity(dueDate, dueAmount, payer,
payee, type, sale, booking);
List <string> expectedAttachments = new List <string>();
expectedAttachments.Add("attachment1");
expectedAttachments.Add("attachment2");
expectedAttachments.Add("attachment3");
paymentEntity.AddAttachment("attachment1");
paymentEntity.AddAttachment("attachment2");
paymentEntity.AddAttachment("attachment3");
List <string> actualAttachments = new List <string>();
foreach (string attachment in paymentEntity.Attachments)
{
actualAttachments.Add(attachment);
}
CollectionAssert.AreEqual(expectedAttachments, actualAttachments);
}
public void TestConstructorSetsAllProperties()
{
DateTime dueDate = new DateTime(2010, 10, 10);
decimal dueAmount = 100m;
APartyEntity payee = new SupplierEntity(SupplierType.Cruise, "", "Galasam");
APartyEntity payer = new CustomerEntity(CustomerType.Bureau, "", "Lonely Tree");
PaymentType type = PaymentType.Full;
string sale = "VF March";
int booking = 128;
PaymentEntity paymentEntity = new PaymentEntity(dueDate, dueAmount, payer,
payee, type, sale, booking);
DateTime expectedPaidDate = new DateTime(1900, 01, 01);
decimal expectedPaidAmount = 0m;
bool expectedPaid = false;
bool expectedArchived = false;
int expectedAttachmentsCount = 0;
Assert.AreEqual(dueDate, paymentEntity.DueDate);
Assert.AreEqual(dueAmount, paymentEntity.DueAmount);
Assert.AreEqual(payee, paymentEntity.Payee);
Assert.AreEqual(payer, paymentEntity.Payer);
Assert.AreEqual(expectedPaidDate, paymentEntity.PaidDate);
Assert.AreEqual(expectedPaidAmount, paymentEntity.PaidAmount);
Assert.AreEqual(expectedPaid, paymentEntity.Paid);
Assert.AreEqual(expectedArchived, paymentEntity.Archived);
Assert.AreEqual(expectedAttachmentsCount, paymentEntity.Attachments.Count);
}
public override CryptoPaymentData GetCryptoPaymentData(PaymentEntity paymentEntity)
{
#pragma warning disable CS0618
BitcoinLikePaymentData paymentData;
if (string.IsNullOrEmpty(paymentEntity.CryptoPaymentDataType))
{
// For invoices created when CryptoPaymentDataType was not existing, we just consider that it is a RBFed payment for safety
paymentData = new BitcoinLikePaymentData();
paymentData.Outpoint = paymentEntity.Outpoint;
paymentData.Output = paymentEntity.Output;
paymentData.RBF = true;
paymentData.ConfirmationCount = 0;
paymentData.Legacy = true;
return(paymentData);
}
paymentData =
JsonConvert.DeserializeObject <BitcoinLikePaymentData>(paymentEntity.CryptoPaymentData);
// legacy
paymentData.Output = paymentEntity.Output;
paymentData.Outpoint = paymentEntity.Outpoint;
#pragma warning restore CS0618
return(paymentData);
}
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 ActionResult GetPayment2(int id)
{
if (id == 0)
{
return(BadRequest(new MessageResponse("Thiếu param id", "param request")));
}
try
{
PaymentEntity paymentEntity = this.paymentDAO.getPayment(id);
paymentEntity = paymentEntity.querry(httpClient);
paymentEntity = this.paymentDAO.UpdatePayment(paymentEntity);
string urlReturn = paymentEntity.UrlReturn;
if (urlReturn.LastIndexOf("?") > 0)
{
urlReturn = urlReturn.Substring(0, urlReturn.LastIndexOf("?"));
}
urlReturn += "?" + paymentEntity.ParamsUrlStatus;
return(Redirect(urlReturn));
//return Redirect("https://localhost:5001/test");
//return Ok(paymentEntity);
}
catch (Exception e)
{
return(BadRequest(new { err = e.Message }));
}
}
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 async Task <PaymentDto> UpdatePayment(PaymentDto payment)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (payment != null)
{
PaymentEntity entity = payment.ToModel();
entity.PaymentId = payment.PaymentId;
db.Payment.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "PaymentId")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
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());
}
private static List <PaymentEntity> GetList(DataResultArgs <SqlDataReader> result)
{
DataProcess.ControlAdminAuthorization();
SqlDataReader dr = result.Result;
List <PaymentEntity> lst = new List <PaymentEntity>();
while (dr.Read())
{
var paymentEntity = new PaymentEntity
{
Id = GeneralFunctions.GetData <Int32>(dr["id"]),
StudentId = GeneralFunctions.GetData <Int32?>(dr["studentId"]),
Year = GeneralFunctions.GetData <Int16?>(dr["year"]),
Month = GeneralFunctions.GetData <Int16?>(dr["month"]),
Amount = GeneralFunctions.GetData <Decimal?>(dr["amount"]),
IsPayment = GeneralFunctions.GetData <Boolean?>(dr["isPayment"]),
PaymentDate = GeneralFunctions.GetData <DateTime?>(dr["paymentDate"]),
PaymentType = GeneralFunctions.GetData <Int32?>(dr["paymentType"]),
IsActive = GeneralFunctions.GetData <Boolean?>(dr["isActive"]),
IsNotPayable = GeneralFunctions.GetData <Boolean>(dr["isNotPayable"])
};
lst.Add(paymentEntity);
}
dr.Close();
return(lst);
}
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 Task UpdateAsync(PaymentEntity payment)
{
Guard.IsNotNull(payment, nameof(payment));
const string query = @"
UPDATE payments
SET
status = @Status,
response_code = @ResponseCode,
acquirer_payment_id = @AcquirerPaymentId,
acquirer_status = @AcquirerStatus,
acquirer_response_code = @AcquirerResponseCode
WHERE id = @Id
";
var parameters = new
{
Id = payment.PaymentId.ToString(),
payment.Status,
payment.ResponseCode,
payment.AcquirerPaymentId,
payment.AcquirerStatus,
payment.AcquirerResponseCode
};
using (var connection = new NpgsqlConnection(_databaseOptions.GatewayDatabaseConnectionString))
{
var affectedRows = await connection.ExecuteAsync(query, parameters);
if (affectedRows < 1)
{
throw new GatewayException("Update payment failed.");
}
}
}
public bool ValidateRequest(PaymentEntity request, out string errmsg)
{
errmsg = string.Empty;
// Validate Credit Card number
if (!CreditCardValidator.IsValid(request.CreditCardNumber))
{
errmsg = "Invalid Credit Card number";
}
//Check if Expiration date is not a past date
if (request.ExpirationDate < DateTime.Now)
{
errmsg = errmsg.Length > 0 ? errmsg + ";" + "Invalid Expiration Date" : "Invalid Expiration Date";
}
//Check if Amount is positive
if (request.Amount < 0)
{
errmsg = errmsg.Length > 0 ? errmsg + ";" + "Invalid Amount" : "Invalid Amount";
}
if (!string.IsNullOrEmpty(errmsg))
{
return(false);
}
return(true);
}
public override CryptoPaymentData GetCryptoPaymentData(PaymentEntity paymentEntity)
{
#pragma warning disable CS0618
return(JsonConvert.DeserializeObject <LightningLikePaymentData>(paymentEntity.CryptoPaymentData));
#pragma warning restore CS0618
}
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);
}
private void Pay()
{
PaymentEntity entity = new PaymentEntity();
entity.IOC_Class_Alias = ConfigurationManager.AppSettings["PaymentGatewayForAdmin"];
entity.Gateway = entity.IOC_Class_Alias;
//if (Request.QueryString.Count > 1)
//{
// entity.Website = Request.QueryString["website"];
// entity.Amount = decimal.Parse(TxtTotal_fee.Text.Trim());
// entity.Title = Request.QueryString["title"];
// entity.Description = Request.QueryString["desc"];
// entity.Payer = Request.QueryString["payer"];
// entity.OrderID_Salve = Request.QueryString["OrderID_Salve"];
// entity.URL_Return_Slave = Request.QueryString["URL_Return_Slave"];
// entity.URL_Callback_Slave = Request.QueryString["URL_Callback_Slave"];
// entity.OrderId = Payment.CreateOrder(entity);
//}
//else
{
entity.Website = Request.Url.Host;
entity.Amount = decimal.Parse(TxtTotal_fee.Text.Trim());
entity.Title = TxtSubject.Text.Trim();
entity.Description = TxtBody.Text.Trim();
entity.Payer = User.Identity.Name;
entity.OrderId = Payment.CreateOrder(entity);
}
//if (Request.Url.Host == Common.PaymentDomainName)
Payment.Transfer(entity);
//else
// Payment.TransferByMasterSite(entity);
}
public PaymentResponse SetPayment(Payment payment)
{
// Generate id for the payment
Guid paymentId = Guid.NewGuid();
// 5% chance of payment failure to make it more interesting
PaymentStatus paymentStatus = PaymentStatus.Success;
if (GetRandomInteger(0, 100) < 5)
{
paymentStatus = PaymentStatus.Failure;
}
PaymentEntity paymentEntity = new PaymentEntity()
{
Id = paymentId,
PaymentStatus = paymentStatus,
CardNumber = payment.CardNumber,
ExpiryYear = payment.ExpiryYear,
ExpiryMonth = payment.ExpiryMonth,
Amount = payment.Amount,
CurrencyCode = payment.CurrencyCode,
CVV = payment.CVV
};
payments.TryAdd(paymentId, paymentEntity);
PaymentResponse paymentResponse = new PaymentResponse()
{
Id = paymentEntity.Id,
PaymentStatus = paymentEntity.PaymentStatus
};
return(paymentResponse);
}
public async Task <IActionResult> Edit(int id, PaymentEntity paymentEntity)
{
if (id != paymentEntity.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(paymentEntity);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaymentEntityExists(paymentEntity.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(paymentEntity));
}
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 Get_MatchedDataReturned()
{
// Arrange
var unitOfWork = new UnitOfWork(dbFactory);
var repository = new PaymentRepository(dbFactory);
var filterText = "Text";
var testEntry = new PaymentEntity
{
ChargedAccount = new AccountEntity {
Name = "testAccount"
},
Note = filterText
};
repository.Add(testEntry);
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 == filterText);
// Assert
Assert.NotNull(result);
Assert.Equal(testEntry.Id, result.Id);
}
