public async Task InsertBenefitAsync()
{
var newItem = A.New <Benefit>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
newItem.BenefitId = items.Max(product => product.BenefitId) + 1;
newItem.Name = $"{newItem.Name} ({items.Count})";
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.BenefitId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void InsertPaymentAsync()
{
_logger.LogInformation("InsertPaymentAsync...");
var newItem = A.New <Payment>();
newItem.Identifier = Guid.NewGuid().ToString();
newItem.CurrencyAlpha3 = "EUR";
newItem.ObjectDocument = $"{{\"Test\": \"{newItem.Identifier} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})\"}}";
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.PaymentId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void GetRequestsForTypeAsync()
{
var newItem = A.New <Request>();
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.RequestId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
//using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
//{
// var result = await _dbContext.GetAsync(dbConnection, newItem.Type);
// Assert.NotNull(result);
//}
}
public async void UpdatePolicyAsync()
{
var newItem = A.New <Policy>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var insertedItem = await _dbContext.InsertAsync(dbTransaction, newItem);
Assert.NotNull(insertedItem);
Assert.NotEqual(0, insertedItem.PolicyId);
var result = await _dbContext.UpdateAsync(dbTransaction, insertedItem);
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void InsertCompanyAsync()
{
_logger.LogInformation("InsertCompanyAsync...");
var newItem = A.New <Company>();
newItem.Name = $"{newItem.Name} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})";
newItem.ObjectDocument = $"{{\"Test\": \"{newItem.Name}\"}}";
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.CompanyId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void UpdateRequestAsync()
{
var newItem = A.New <Request>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
newItem.Type = $"{newItem.Type} ({items.Count})";
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var insertedItem = await _dbContext.InsertAsync(dbTransaction, newItem);
insertedItem.Type = $"{insertedItem.Type} ({DateTime.Now})";
if (32 < insertedItem.Type.Length)
{
insertedItem.Type = insertedItem.Type.Substring(0, 31);
}
Assert.NotNull(insertedItem);
Assert.NotEqual(0, insertedItem.RequestId);
var result = await _dbContext.UpdateAsync(dbTransaction, insertedItem);
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void InsertClaimAsync()
{
_logger.LogInformation("InsertClaimAsync...");
var newItem = A.New <Claim>();
var policy = _policiesFixture.Items[A.Random.Next(0, _policiesFixture.Items.Count - 1)];
newItem.PolicyId = policy.PolicyId;
newItem.ObjectDocument = $"{{\"Test\": \"{newItem.PolicyId} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})\"}}";
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.ClaimId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void InsertQuoteAsync()
{
var newItem = A.New <Quote>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.QuoteId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void UpdateInvoiceAsync()
{
var newItem = A.New <Invoice>();
newItem.Identifier = Guid.NewGuid().ToString();
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var insertedItem = await _dbContext.InsertAsync(dbTransaction, newItem);
Assert.NotNull(insertedItem);
Assert.NotEqual(0, insertedItem.InvoiceId);
var result = await _dbContext.UpdateAsync(dbTransaction, insertedItem);
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void UpdateQuestionAsync()
{
var newItem = A.New <Question>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
newItem.Text = $"{newItem.Text} ({items.Count})";
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var insertedItem = await _dbContext.InsertAsync(dbTransaction, newItem);
insertedItem.Text = $"{insertedItem.Text} ({DateTime.Now})";
Assert.NotNull(insertedItem);
Assert.NotEqual(0, insertedItem.QuestionId);
var result = await _dbContext.UpdateAsync(dbTransaction, insertedItem);
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
public async void DeleteInvoiceAsync()
{
var newItem = A.New <Invoice>();
newItem.Identifier = Guid.NewGuid().ToString();
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.InvoiceId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
Invoice existingInvoice;
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var pageRequest = new PageRequest()
{
PageIndex = 0,
PageSize = 1,
SortBy = "InvoiceId",
SortOrder = SortOrders.DESC
};
existingInvoice = (await _dbContext.GetPageAsync(dbConnection, pageRequest)).Items.First();
}
using (var transaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
await _dbContext.DeleteAsync(transaction, existingInvoice);
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var result = await _dbContext.GetAsync(dbConnection, existingInvoice.InvoiceId);
Assert.Null(result);
}
}
public async void GetClaimsAsync_DbTransaction()
{
_logger.LogInformation("GetClaimsAsync...");
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
var result = await _dbContext.GetAllAsync(dbTransaction.Connection, dbTransaction);
Assert.NotNull(result);
}
}
public async void UpdateCompanyAsync()
{
_logger.LogInformation("UpdateCompanyAsync...");
var newItem = A.New <Company>();
newItem.Name = $"{newItem.Name} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})";
newItem.ObjectDocument = $"{{\"Test\": \"{newItem.Name}\"}}";
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
newItem = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(newItem);
Assert.NotEqual(0, newItem.CompanyId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var itemToUpdate = A.New <Company>();
itemToUpdate.CompanyId = newItem.CompanyId;
itemToUpdate.Name = $"{itemToUpdate.Name} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})";
itemToUpdate.ObjectDocument = $"{{\"Test\": \"{itemToUpdate.Name}\"}}";
var result = await _dbContext.UpdateAsync(dbTransaction, itemToUpdate);
dbTransaction.Commit();
Assert.True(result);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var updatedItem = await _dbContext.GetAsync(dbConnection, newItem.CompanyId);
Assert.NotNull(updatedItem);
Assert.NotEqual(updatedItem.Name, newItem.Name);
}
}
public async void DeleteProductAsync()
{
var newItem = A.New <Product>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
newItem.ProductId = items.Max(product => product.ProductId) + 1;
newItem.Name = $"{newItem.Name} ({items.Count})";
}
Product existingProduct;
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var pageRequest = new PageRequest()
{
PageIndex = 0,
PageSize = 1,
SortBy = "ProductId",
SortOrder = SortOrders.DESC
};
existingProduct = (await _dbContext.GetPageAsync(dbConnection, pageRequest)).Items.First();
}
using (var transaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
await _dbContext.DeleteAsync(transaction, existingProduct);
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var result = await _dbContext.GetAsync(dbConnection, existingProduct.ProductId);
Assert.Null(result);
}
}
public async void GetPaymentAsync()
{
var newItem = A.New <Payment>();
newItem.Identifier = Guid.NewGuid().ToString();
newItem.CurrencyAlpha3 = "EUR";
newItem.ObjectDocument = $"{{\"Test\": \"{newItem.Identifier} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})\"}}";
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.PaymentId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
_logger.LogInformation("GetPaymentAsync...");
var pageRequest = new PageRequest
{
SortBy = "PaymentId",
SortOrder = SortOrders.DESC,
PageIndex = 0,
PageSize = 50
};
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var result = await _dbContext.GetPageAsync(dbConnection, pageRequest);
Assert.NotNull(result);
var first = result.Items.First();
var firstItem = await _dbContext.GetAsync(dbConnection, first.PaymentId);
Assert.NotNull(firstItem);
}
}
public async void DeleteBenefitAsync()
{
await InsertBenefitAsync();
Benefit existingBenefit;
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var pageRequest = new PageRequest()
{
PageIndex = 0,
PageSize = 1,
SortBy = "BenefitId",
SortOrder = SortOrders.DESC
};
existingBenefit = (await _dbContext.GetPageAsync(dbConnection, pageRequest)).Items.First();
}
using (var transaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
await _dbContext.DeleteAsync(transaction, existingBenefit);
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var result = await _dbContext.GetAsync(dbConnection, existingBenefit.BenefitId);
Assert.Null(result);
}
}
public async void InsertClaimAsync_Multiple(int count)
{
_logger.LogInformation($"InsertClaimAsync_Multiple '{count}'...");
var objectHash = count;
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
objectHash += await _dbContext.GetCountAsync(dbConnection);
}
var newItems = A.ListOf <Claim>(count);
foreach (var newItem in newItems)
{
var policy = _policiesFixture.Items[A.Random.Next(0, _policiesFixture.Items.Count - 1)];
newItem.PolicyId = policy.PolicyId;
newItem.ObjectDocument = $"{{\"Test\": \"{newItem.PolicyId} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})\"}}";
newItem.ObjectHash = objectHash++;
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.ClaimId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
}
public async void InsertLeadAsync_Multiple(int count)
{
_logger.LogInformation($"InsertLeadAsync_Multiple '{count}'...");
var objectHash = count;
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
objectHash += await _dbContext.GetCountAsync(dbConnection);
}
var newItems = A.ListOf <Lead>(count);
foreach (var newItem in newItems)
{
newItem.Name = $"{newItem.Name} ({DateTime.Now:yyyyMMddHHmmssfff} - {Guid.NewGuid()})";
newItem.ObjectDocument = $"{{\"Test\": \"{newItem.Name}\"}}";
newItem.ObjectHash = objectHash++;
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.LeadId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
}
}
public async void DeleteQuestionAsync()
{
var newItem = A.New <Question>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
newItem.Text = $"{newItem.Text} ({items.Count})";
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.QuestionId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
Question existingQuestion;
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var pageRequest = new PageRequest()
{
PageIndex = 0,
PageSize = 1,
SortBy = "QuestionId",
SortOrder = SortOrders.DESC
};
existingQuestion = (await _dbContext.GetPageAsync(dbConnection, pageRequest)).Items.First();
}
using (var transaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
await _dbContext.DeleteAsync(transaction, existingQuestion);
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var result = await _dbContext.GetAsync(dbConnection, existingQuestion.QuestionId);
Assert.Null(result);
}
}
public async void DeleteAgentAsync()
{
var newItem = A.New <Agent>();
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var items = (await _dbContext.GetAllAsync(dbConnection)).ToList();
newItem.Name = $"{newItem.Name} ({items.Count})";
newItem.ObjectDocument = JsonConvert.SerializeObject(new { Identifier = Guid.NewGuid() });
newItem.ObjectHash = newItem.ObjectDocument.GetHashCode();
}
using (var dbTransaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
var result = await _dbContext.InsertAsync(dbTransaction, newItem);
dbTransaction.Commit();
Assert.NotNull(result);
Assert.NotEqual(0, result.AgentId);
}
catch
{
dbTransaction.Rollback();
throw;
}
}
Agent existingAgent;
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var pageRequest = new PageRequest()
{
PageIndex = 0,
PageSize = 1,
SortBy = "AgentId",
SortOrder = SortOrders.DESC
};
existingAgent = (await _dbContext.GetPageAsync(dbConnection, pageRequest)).Items.First();
}
using (var transaction = await DbConnectionFactory.BeginUserTransactionAsync(UserId))
{
try
{
await _dbContext.DeleteAsync(transaction, existingAgent);
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
using (var dbConnection = await DbConnectionFactory.OpenUserConnectionAsync(UserId))
{
var result = await _dbContext.GetAsync(dbConnection, existingAgent.AgentId);
Assert.Null(result);
}
}
