//Would be revisiting to modify the actual way of call method.
public void TestTransactionHistoryRepositoryTest_Success()
{
// Arrange
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
IOptions <DataContext> optionsAccessor = Substitute.For <IOptions <DataContext> >();
IDatabaseConnectionFactory connectionFactory = Substitute.For <IDatabaseConnectionFactory>();
ITransactionHistoryRepository mockRepo = Substitute.For <ITransactionHistoryRepository>();
mockRepo.GetTransactionHistoryAsync(terminalId, page).ReturnsForAnyArgs(expectedResult.Result);
// Act
var terminalList = mockRepo.GetTransactionHistoryAsync(terminalId, page).Result;
var actualRecord = (IList <TransactionHistory>)terminalList.ReturnedRecords;
string merchInfo = actualRecord.Where(x => x.REQ_TRAN_TYPE == transactionType).FirstOrDefault().REQ_AMT;
//// Assert
Assert.Equal(((IList <TransactionHistory>)actualRecord).Count, 1);
Assert.Equal(merchInfo, "589587");
}
public async Task TransactionHistoryApiTest_GetAnException()
{
// Arrange
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
IOptions <Settings> optionsAccessor = Substitute.For <IOptions <Settings> >();
ITransactionHistoryRepository mockRepo = Substitute.For <ITransactionHistoryRepository>();
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
ITransactionHistoryApi terminalListApi = Substitute.For <ITransactionHistoryApi>();
terminalListApi.WhenForAnyArgs(x => x.GetTransactionHistoryAsync(Arg.Any <string>(), Arg.Any <PaginationTransactionHistory>())).DoNotCallBase();
mockRepo.GetTransactionHistoryAsync(terminalId, page).Throws(new Exception());
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
terminalListApi = new TransactionHistoryApi(optionsAccessor, mockRepo, loggingFacade);
// Assert
await Assert.ThrowsAsync <Exception>(() => terminalListApi.GetTransactionHistoryAsync(terminalId, page));
}
public PaginationTransactionHistory GetPagination()
{
PaginationTransactionHistory page = new PaginationTransactionHistory();
page.FilterByNetworkCD = "MerchantID";
page.FilterByLast4 = "1234";
return(page);
}
public async Task TransactionHistoryControllerTest_NoDataFound()
{
// Arrange
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
TransactionHistoryInput pageinput = new TransactionHistoryInput();
pageinput.LIDValue = terminalId;
pageinput.lidTypeEnum = Wp.CIS.LynkSystems.Model.Enums.LidTypeEnum.Customer;
pageinput.Page = page;
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IOperation fakeOperation = Substitute.For <Operation>(mockCache);
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
IStringLocalizer <TransactionHistoryController> localizer = Substitute.For <IStringLocalizer <TransactionHistoryController> >();
string key = "NoDataFound";
string value = "No data found for provided ID";
var localizedString = new LocalizedString(key, value);
localizer[Arg.Any <string>()].ReturnsForAnyArgs(localizedString);
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
ITransactionHistoryApi terminalListApi = Substitute.For <ITransactionHistoryApi>();
ApiResult <GenericPaginationResponse <TransactionHistory> > response = new ApiResult <GenericPaginationResponse <TransactionHistory> >();
response.Result = new GenericPaginationResponse <TransactionHistory>();
terminalListApi.GetTransactionHistoryAsync(terminalId, page).ReturnsForAnyArgs(response);
TransactionHistoryController fakecontroller
= FakeController(mockCache, terminalListApi, localizer, fakeOperation, loggingFacade);
// Act
var terminalList = await fakecontroller.GetTransactionHistory(pageinput);
// Assert
Assert.Equal(((Microsoft.AspNetCore.Mvc.ObjectResult)terminalList).StatusCode, 200);
var actualTransactionHistory = ((Microsoft.AspNetCore.Mvc.ObjectResult)terminalList).Value;
Assert.Equal(((GenericPaginationResponse <TransactionHistory>)actualTransactionHistory).ModelMessage, localizer["NoDataFound"].Value);
}
public async Task TransactionHistoryControllerTest_Success()
{
// Arrange
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
TransactionHistoryInput pageinput = new TransactionHistoryInput();
pageinput.LIDValue = terminalId;
pageinput.lidTypeEnum = Wp.CIS.LynkSystems.Model.Enums.LidTypeEnum.Customer;
pageinput.Page = page;
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IStringLocalizer <TransactionHistoryController> localizer
= Substitute.For <IStringLocalizer <TransactionHistoryController> >();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
IOperation fakeOperation = Substitute.For <Operation>(mockCache);
fakeOperation.WhenForAnyArgs(x => x.RetrieveCache(Arg.Any <string>(), Arg.Any <ICollection <Wp.CIS.LynkSystems.Model.TransactionHistory> >())).DoNotCallBase();
fakeOperation.WhenForAnyArgs(x => x.AddCacheAsync(Arg.Any <string>(), Arg.Any <ICollection <Wp.CIS.LynkSystems.Model.TransactionHistory> >())).DoNotCallBase();
ITransactionHistoryApi terminalListApi = Substitute.For <ITransactionHistoryApi>();
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
TransactionHistoryController controller
= new TransactionHistoryController(mockCache, terminalListApi, localizer, fakeOperation, loggingFacade);
terminalListApi.GetTransactionHistoryAsync(terminalId, page).ReturnsForAnyArgs(expectedResult);
// Act
var terminalList = await controller.GetTransactionHistory(pageinput);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)terminalList).Value;
string terminalInfo = ((IList <TransactionHistory>)((GenericPaginationResponse <TransactionHistory>)actualRecord).ReturnedRecords)
.Where(x => x.REQ_TRAN_TYPE == transactionType).FirstOrDefault().REQ_AMT;
// Assert
var recordCount = ((GenericPaginationResponse <TransactionHistory>)actualRecord).ReturnedRecords;
Assert.Equal(recordCount.ToList().Count, 1);
//Assert.Equal(((IList<Wp.CIS.LynkSystems.Model.TransactionHistory>)actualRecord).Count, 1);
Assert.Equal(terminalInfo, "589587");
}
//Forming the Unique ChacheId
private string UniqueCachingKey(TransactionHistoryInput pageinput)
{
string terminalId = pageinput.LIDValue;
PaginationTransactionHistory page = pageinput.Page;
TransactionTypeEnum transactionType = page.TransactionType;
var key = _localizer["UniqueKeyTerminalList"] + "_" + transactionType.ToString() + "_" + terminalId;
if (page.PageSize > 0)
{
key = key + "_PageSize_" + page.PageSize;
}
if (page.SkipRecordNumber > 0)
{
key = key + "_SkipRecord_" + page.SkipRecordNumber;
}
if (page.SortField != null)
{
key = key + "_" + page.SortField + "_" + page.SortFieldByAsc;
}
if (page.FilterByAmount != null)
{
key = key + "_FilterByAmount_" + page.FilterByAmount;
}
if (page.FilterByDate != null)
{
key = key + "_FilterByDate_" + page.FilterByDate;
}
if (page.FilterByLast4 != null)
{
key = key + "_FilterByLast4_" + page.FilterByLast4;
}
if (page.FilterByNetworkCD != null)
{
key = key + "_FilterByNetworkCD_" + page.FilterByNetworkCD;
}
if (page.FilterByTranType != null)
{
key = key + "_FilterByTranType_" + page.FilterByTranType;
}
return(key);
}
///Unit Test for the RetrieveCache()
public async Task TransactionHistoryControllerTest_GetDataFromCache()
{
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
TransactionHistoryInput pageinput = new TransactionHistoryInput();
pageinput.LIDValue = terminalId;
pageinput.lidTypeEnum = Wp.CIS.LynkSystems.Model.Enums.LidTypeEnum.Customer;
pageinput.Page = page;
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
ITransactionHistoryRepository mockRepo = Substitute.For <ITransactionHistoryRepository>();
IStringLocalizer <TransactionHistoryController> localizer
= Substitute.For <IStringLocalizer <TransactionHistoryController> >();
ITransactionHistoryApi mockTransactionHistoryApi = Substitute.For <ITransactionHistoryApi>();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
IOperation fakeOperation = Substitute.For <Operation>(mockCache);
fakeOperation.WhenForAnyArgs(x => x.RetrieveCache(Arg.Any <string>(), Arg.Any <ICollection <Wp.CIS.LynkSystems.Model.TransactionHistory> >())).DoNotCallBase();
fakeOperation.RetrieveCache("FakeStringID", new GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory>()).ReturnsForAnyArgs(expectedResult.Result);
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
TransactionHistoryController controller = new TransactionHistoryController(mockCache, mockTransactionHistoryApi, localizer, fakeOperation, loggingFacade);
//ACT
var terminalList = await controller.GetTransactionHistory(pageinput);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)terminalList).Value;
//Assert
Assert.Equal(JsonConvert.SerializeObject(actualRecord), JsonConvert.SerializeObject(expectedResult.Result));
}
//UnitTest for validating the Invalid Model Data.
public void TransactionHistoryController_ModelState_Invalid()
{
//Arrange
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
TransactionHistoryInput pageinput = new TransactionHistoryInput();
pageinput.LIDValue = terminalId.ToString();
pageinput.lidTypeEnum = Wp.CIS.LynkSystems.Model.Enums.LidTypeEnum.Customer;
pageinput.Page = page;
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IStringLocalizer <TransactionHistoryController> localizer
= Substitute.For <IStringLocalizer <TransactionHistoryController> >();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
IDistributedCache mockCache = FakeCache();
ITransactionHistoryApi terminalListApi = Substitute.For <ITransactionHistoryApi>();
IOperation fakeOperation = Substitute.For <Operation>(mockCache);
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
TransactionHistoryController controller = new TransactionHistoryController(mockCache, terminalListApi, localizer, fakeOperation, loggingFacade);
//Act
controller.ModelState.AddModelError("key", "error message");
var result = controller.GetTransactionHistory(pageinput);
//Assert
Assert.Equal(((Microsoft.AspNetCore.Mvc.ObjectResult)result.Result).StatusCode.ToString(), "400");
}
public async Task <ApiResult <GenericPaginationResponse <TransactionHistory> > > GetTransactionHistoryAsync(string terminalID, PaginationTransactionHistory Page)
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Starting Transaction History API Service for TerminalID - " + terminalID,
"TransactionHistoryApi.cs", "TransactionHistoryApi"), CancellationToken.None);
ApiResult <GenericPaginationResponse <TransactionHistory> > response = new ApiResult <GenericPaginationResponse <TransactionHistory> >();
try
{
response.Result = await _transactionHistoryRepository.GetTransactionHistoryAsync(terminalID, Page);
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Fetched the Transaction History resultset from DB for TerminalID - " + terminalID,
"TransactionHistoryApi.cs", "GetTransactionHistoryAsync"), CancellationToken.None);
}
catch (Exception)
{
throw;
}
return(response);
}
/// <summary>
/// Model - Terminal
/// </summary>
/// <param name="merchantId"></param>
/// <returns></returns>
public async Task <GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory> > GetTransactionHistoryAsync(string terminalId, PaginationTransactionHistory page)
{
try
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Starting Transaction History GetTransactionHistoryAsync for TerminalID " + terminalId,
"TransactionHistoryRepository.cs", "GetTransactionHistoryAsync()"), CancellationToken.None);
var response = new GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory>
{
SkipRecords = page.SkipRecordNumber
};
return(await this._connectionFactory.GetConnection(async c =>
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Open Dapper Connection of SQL server for Transaction History Repository for TerminalID " + terminalId,
"TransactionHistoryRepository.cs", "GetTransactionHistoryAsync()"), CancellationToken.None);
var p = new DynamicParameters();
p.Add("TerminalID", terminalId, DbType.String);
if (!string.IsNullOrEmpty(page.SortField))
{
p.Add("SortField", page.SortField, DbType.String);
p.Add("SortOrder", page.SortFieldByAsc, DbType.Boolean);
}
if (!string.IsNullOrEmpty(page.FilterByDate))
{
p.Add("FilterByDate", page.FilterByDate, DbType.String);
}
if (!string.IsNullOrEmpty(page.FilterByAmount))
{
p.Add("FilterByAmount", page.FilterByAmount, DbType.String);
}
if (!string.IsNullOrEmpty(page.FilterByLast4))
{
p.Add("FilterByLast4", page.FilterByLast4, DbType.String);
}
if (!string.IsNullOrEmpty(page.FilterByTranType))
{
p.Add("FilterByTranType", page.FilterByTranType, DbType.String);
}
if (!string.IsNullOrEmpty(page.FilterByDesc))
{
p.Add("FilterByDesc", page.FilterByDesc, DbType.String);
}
if (!string.IsNullOrEmpty(page.FilterByNetworkCD))
{
p.Add("FilterByNetworkCD", page.FilterByNetworkCD, DbType.String);
}
if (page.PageSize > 0)
{
p.Add("PageSize", page.PageSize, DbType.Int16);
}
if (page.SkipRecordNumber > 0)
{
p.Add("SkipRecords", page.SkipRecordNumber, DbType.Int16);
}
p.Add("MaximumRecsLimit", maxRecordCount, DbType.Int16);
p.Add("TotalRecordsCount", DbType.Int32, direction: ParameterDirection.Output);
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Dapper Connection parameterized Query for Transaction History Repository for TerminalID " + terminalId,
"TransactionHistoryRepository.cs", "GetTransactionHistoryAsync()"), CancellationToken.None);
if (page.TransactionType == TransactionTypeEnum.Settled)
{
response.ReturnedRecords = await c.QueryAsync <Wp.CIS.LynkSystems.Model.TransactionHistory>(sql: "[CISPlus].[uspCISPlusGetTerminalTransactionsSettled]", param: p, commandType: CommandType.StoredProcedure);
response.TotalNumberOfRecords = p.Get <int>("TotalRecordsCount");
}
else if (page.TransactionType == TransactionTypeEnum.Acquired)
{
response.ReturnedRecords = await c.QueryAsync <Wp.CIS.LynkSystems.Model.TransactionHistory>(sql: "[CISPlus].[uspCISPlusGetTerminalTransactionsAcquired]", param: p, commandType: CommandType.StoredProcedure);
response.TotalNumberOfRecords = p.Get <int>("TotalRecordsCount");
}
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Successful DB call for Transaction History Repository Query result for TerminalID " + terminalId,
"TransactionHistoryRepository.cs", "GetTransactionHistoryAsync()"), CancellationToken.None);
return response;
}));
}
catch (Exception ex)
{
var msg = String.Format("{0}.GetTransactionHistoryAsync() experienced an exception (not a timeout) for TerminalID " + terminalId, GetType().FullName);
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Error, msg + ex.ToString() + ex.Message, "GetTransactionHistoryAsync.cs",
"GetTransactionHistoryAsync()"), CancellationToken.None);
throw;
}
}
public async Task <IActionResult> GetTransactionHistory([FromBody] TransactionHistoryInput pageinput)
{
try
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Web Api call for Transaction History Controller " + pageinput.lidTypeEnum.ToString() + ", Value - "
+ pageinput.LIDValue, "TransactionHistoryController.cs", "GetTransactionHistory"),
CancellationToken.None);
string terminalId = pageinput.LIDValue;
PaginationTransactionHistory page = pageinput.Page;
var key = UniqueCachingKey(pageinput);
if (!ModelState.IsValid)
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Error, ModelState.ToString(), "TransactionHistoryController.cs",
"GetTransactionHistory"), CancellationToken.None);
return(BadRequest(ModelState));
}
//first check if the data is in cache..
var data = _operation.RetrieveCache(key, new GenericPaginationResponse <TransactionHistory>());
if (data == null)
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "calling the GetTransactionHistoryAsync for resultset(Transaction Hostory) " + pageinput.lidTypeEnum.ToString() + ", Value - "
+ pageinput.LIDValue,
"TransactionHistoryController.cs", "GetTransactionHistory"), CancellationToken.None);
var result = await _transactionHistoryApi.GetTransactionHistoryAsync(terminalId, page);
if (result.ErrorMessages.Count == 0)
{
if (result.Result != null && result.Result.TotalNumberOfRecords > 0)
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "got the resultset for the GetTransactionHistoryAsync " + pageinput.lidTypeEnum.ToString() + ", Value - "
+ pageinput.LIDValue, "TransactionHistoryController.cs",
"GetTransactionHistory"), CancellationToken.None);
await _operation.AddCacheAsync(key, result.Result);
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Added to Cache for the Terminal List resultset " + pageinput.lidTypeEnum.ToString() + ", Value - "
+ pageinput.LIDValue,
"TransactionHistoryController.cs", "GetTransactionHistory"), CancellationToken.None);
return(Ok(result.Result));
}
else
{
var msg = this._localizer["NoDataFound"]?.Value;
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "GetTransactionHistoryAsync No Data Found " + pageinput.lidTypeEnum.ToString() + ", Value - "
+ pageinput.LIDValue, "TransactionHistoryController.cs",
"GetTransactionHistory"), CancellationToken.None);
result.Result.ModelMessage = msg;
return(Ok(result.Result));
}
}
else
{
var msg = this._localizer?["InternalServerError"]?.Value;
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Error, "Error Occured for " + pageinput.lidTypeEnum.ToString() + ", Value - "
+ pageinput.LIDValue + " " + msg, "TransactionHistoryController.cs",
"GetTransactionHistory"), CancellationToken.None);
return(this.StatusCode((int)System.Net.HttpStatusCode.InternalServerError, msg));
}
}
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "GetTransaction History Got resultset from Cache " + key + ", Value - "
+ pageinput.LIDValue, "TransactionHistoryController.cs",
"GetTransactionHistory"), CancellationToken.None);
return(Ok(data));
}
catch (Exception ex)
{
var msg = this._localizer?["InternalServerError"]?.Value;
await _loggingFacade.LogExceptionAsync(ex, this.HttpContext?.Request?.Headers["UserName"], LogLevels.Error, "Error in GetTransactionHistory()", CancellationToken.None);
return(this.StatusCode((int)System.Net.HttpStatusCode.InternalServerError, msg));
}
}
