public TransactionsControllerTests(TestFixture <Startup> fixture)
{
var transactions = new List <ProductTransaction>
{
new ProductTransaction
{
SKU = "2600",
Currency = "CAD",
Amount = 91.97M
}
};
OnlineRepository = new Mock <IRepository <ProductTransaction> >();
OnlineRepository.Setup(x => x.GetAll())
.ReturnsAsync(transactions);
OnlineRepository.Setup(x => x.Where(It.IsAny <Expression <Func <ProductTransaction, bool> > >()))
.Returns((Expression <Func <ProductTransaction, bool> > exp) => transactions.AsQueryable().Where(exp));
LocalRepository = new Mock <ILocalSourceRepository <ProductTransaction> >();
LocalRepository.Setup(x => x.GetAll())
.ReturnsAsync(transactions);
LocalRepository.Setup(x => x.Where(It.IsAny <Expression <Func <ProductTransaction, bool> > >()))
.Returns((Expression <Func <ProductTransaction, bool> > exp) => transactions.AsQueryable().Where(exp));
LocalRepository.Setup(x => x.Refresh(transactions));
var logger = (ILogger <TransactionService>)fixture.Server.Host.Services.GetService(typeof(ILogger <TransactionService>));
Service = new TransactionService(OnlineRepository.Object, LocalRepository.Object, logger);
var Mapper = (IMapper)fixture.Server.Host.Services.GetService(typeof(IMapper));
var Logger = (ILogger <TransactionsController>)fixture.Server.Host.Services.GetService(typeof(ILogger <TransactionsController>));
TestController = new TransactionsController(Service, Mapper, Logger);
}
public async Task GetTransactionsPage_ServiceFailed_Returns500()
{
// Arrange
var mediator = new Mock <IMediator>();
var transactionPageQueryResult = new OperationDataResult <TransactionPageQueryResult>(false, new List <string> {
"Error"
});
mediator.Setup(m => m.Send(It.IsAny <TransactionPageQuery>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(transactionPageQueryResult));
var controller = new TransactionsController(mediator.Object);
// Act
var result = await controller.GetTransactionsPage(new TransactionPageQuery());
var objectResult = result as ObjectResult;
var operationDataResult = objectResult.Value as OperationDataResult <TransactionPageQueryResult>;
// Assert
Assert.AreEqual(500, objectResult.StatusCode);
Assert.AreEqual(false, operationDataResult.Succeeded);
Assert.AreNotEqual(0, operationDataResult.Messages);
}
static void Main(string[] args)
{
SuppliersController callSupplier = new SuppliersController();
ItemsController callItem = new ItemsController();
TransactionsController callTransaction = new TransactionsController();
Console.WriteLine("=========== Manage Data ============");
Console.WriteLine("1. Item");
Console.WriteLine("2. Supplier");
Console.WriteLine("3. Transaction");
Console.WriteLine("====================================");
Console.Write("Going to : ");
int chance = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("====================================");
if (chance == 1)
{
callItem.ManageItem();
}
else if (chance == 2)
{
callSupplier.ManageSupplier();
}
else if (chance == 3)
{
//callTransaction.ManageTransaction();
callTransaction.Print();
}
else
{
Console.WriteLine("Something is wrong, please try again.");
Console.Read();
}
}
private void editToolStripMenuItem_Click(object sender, EventArgs e)
{
if (this.mTransactionOLV.SelectedItems.Count == 1)
{
TransactionsController.getInstance().EditRecord((Record)this.mTransactionOLV.SelectedObject);
}
}
public ActionResult Edit(Transaction transaction)
{
TransactionsController tc = new TransactionsController(db);
var result = tc.PutTransaction(transaction.TransactionId, transaction) as OkNegotiatedContentResult <Transaction>;
return(RedirectToAction("Index"));
}
public ActionResult Edit(int id)
{
TransactionsController tc = new TransactionsController(db);
var result = tc.GetTransaction(id) as OkNegotiatedContentResult <Transaction>;
return(View(result.Content));
}
public void Index_ReturnsCorrectViewWhenUserNotSignedIn_True()
{
TransactionsController controller = new TransactionsController();
ActionResult Index = controller.Index();
Assert.IsInstanceOfType(Index, typeof(RedirectToActionResult));
}
public ActionResult Delete(int id)
{
TransactionsController tc = new TransactionsController(db);
var result = tc.DeleteTransaction(id);
return(RedirectToAction("Index"));
}
public void GetTransactionsException(string value)
{
var mock = new Mock <IBankRepository>();
var controller = new TransactionsController(mock.Object, _cardService, _businessLogicService);
Assert.Throws <UserDataException>(() => controller.Get(value, 0));
}
public void Transaction_Reporting_And_Management_Search_Transaction_Request_Returns_Successfully()
{
// Arramge
var request = new TransactionSearchRequest
{
TransactionId = 111995104,
CustomerId = "5000587",
StartDate = Convert.ToDateTime("02/01/2014"),
EndDate = Convert.ToDateTime("05/31/2014"),
Amount = 11.00m,
DeveloperApplication = new DeveloperApplication
{
DeveloperId = 12345678,
Version = "1.2"
}
};
var apiContext = new APIContext();
var controller = new TransactionsController();
// Act
var response = controller.ProcessRequest<TransactionSearchResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
}
public async Task GetSecureTest()
{
var controller = new TransactionsController(_Repository);
var value = (await controller.GetSecure(new TransactionsQuery())).Value;
Assert.Equal(20, value.Results.Count);
}
public async Task CallCorrectServiceMethod()
{
//Arrange
var userManagerMock = new Mock <IUserManager <User> >();
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var transactionServicesMock = new Mock <ITransactionServices>();
transactionServicesMock
.Setup(tsm => tsm.SearchTransactionAsync(null, null, null, null, null, false))
.ReturnsAsync(new List <TransactionViewModel>());
transactionServicesMock
.Setup(tsm => tsm.GetTypesAsync())
.ReturnsAsync(new List <string>());
var sut = new TransactionsController(userManagerMock.Object, transactionServicesMock.Object, memoryCache);
//Act
var result = await sut.Index(null, null, null, null, null, null, false);
var result2 = await sut.Index(null, null, null, null, null, null, false);
//Assert
transactionServicesMock.Verify(tsm => tsm.SearchTransactionAsync(null, null, null, null, null, false), Times.Exactly(2));
transactionServicesMock.Verify(tsm => tsm.GetTypesAsync(), Times.Once);
}
public void GetTransaction_ShouldNotFindTransaction()
{
var context = new TestTransactionContext();
context.Transactions.Add(new Transaction {
TransactionId = 1, Description = "Demo1", TransactionAmount = 1.23M
});
context.Transactions.Add(new Transaction {
TransactionId = 2, Description = "Demo2", TransactionAmount = 2.34M
});
context.Transactions.Add(new Transaction {
TransactionId = 3, Description = "Demo3", TransactionAmount = 34.45M
});
context.Transactions.Add(new Transaction {
TransactionId = 4, Description = "Demo4", TransactionAmount = 456.78M
});
var controller = new TransactionsController(context);
try
{
var result = controller.GetTransaction(999);
}
catch (HttpResponseException ex)
{
Assert.AreEqual(ex.Response.StatusCode, HttpStatusCode.BadRequest, "Transaction not found");
}
}
public void PostTransaction_ShouldPostTransaction()
{
var context = new TestTransactionContext();
context.Transactions.Add(new Transaction {
TransactionId = 1, Description = "Demo1", TransactionAmount = 1.23M
});
context.Transactions.Add(new Transaction {
TransactionId = 2, Description = "Demo2", TransactionAmount = 2.34M
});
context.Transactions.Add(new Transaction {
TransactionId = 3, Description = "Demo3", TransactionAmount = 34.45M
});
context.Transactions.Add(new Transaction {
TransactionId = 4, Description = "Demo4", TransactionAmount = 456.78M
});
var controller = new TransactionsController(context);
var result = controller.PostTransaction(new Transaction {
TransactionId = 5, Description = "Demo5", TransactionAmount = 5678.90M
});
var createdResult = result as CreatedAtRouteNegotiatedContentResult <Transaction>;
Assert.IsNotNull(createdResult);
Assert.AreEqual("DefaultApi", createdResult.RouteName);
Assert.AreEqual(5, createdResult.Content.TransactionId);
}
public async Task TestCredit()
{
var mok = new Mock <ITransactionsRepository>();
var controller = new TransactionsController(mok.Object);
TransactionEntity obj = new TransactionEntity
{
Account = 1,
Value = 50.0,
IsDebit = false,
Date = DateTime.Now
};
mok.Setup(a => a.BalanceAsync(It.IsAny <int>()))
.Returns(Task.FromResult(60.0 + obj.Value));
var result = await controller.Credit(obj);
result.Should().BeOfType <OkObjectResult>().Which.Value.Should()
.BeOfType <SuccessViewModel>().Which.Message.Should().Be("Successfully inserted credits");
result.Should().BeOfType <OkObjectResult>().Which.Value.Should()
.BeOfType <SuccessViewModel>().Which.Value.Should().Be(50.0);
result.Should().BeOfType <OkObjectResult>().Which.Value.Should()
.BeOfType <SuccessViewModel>().Which.Balance.Should().Be(110.0);
}
public async Task TestUpdateStatus()
{
var toAdd = SampleTransactions()[0];
DbContext.Transaction.Add(toAdd);
DbContext.SaveChanges();
var controller = new TransactionsController(DbContext);
//change the transaction status from Completed to Pending
var statusUpdate = new StatusUpdate()
{
Status = "Pending"
};
var result = (await controller.ModifyStatus(1, statusUpdate)) as StatusCodeResult;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
Assert.AreEqual(204, result.StatusCode);
var transaction = await DbContext.Transaction.FindAsync((long)1);
Assert.AreEqual(transaction.Id, toAdd.Id, "Ids did not match");
Assert.AreEqual(transaction.Datetime, toAdd.Datetime, "Datetimes did not match");
Assert.AreEqual(transaction.Descripton, toAdd.Descripton, "Desciptions did not match");
Assert.AreEqual(transaction.Amount, toAdd.Amount, "Amounts did not match");
Assert.AreEqual(transaction.Status, statusUpdate.Status, "Status was not updated");
ClearDb();
}
// Teste sendo ignorado pois não consegui fazer os Controllers funcionarem
public void Save_TransaçãoComValorMaiorQueLimiteCredito_RetornaErros()
{
//Arrange
transactionsController = new TransactionsController();
transactionTypeApiName = "credito";
var transactionEVM = new TransactionEditViewModel
{
Amount = "120,00",
CardBrandApiName = cardBrandApiName,
CardHolderName = "PEDRITA FLINTSTONE",
Cvv = "999",
ExpirationMonth = 01,
ExpirationYear = 2019,
Installments = 0,
Number = "5555666677778888",
Password = cardPassword,
TransactionTypeApiName = transactionTypeApiName
};
//Act
var transactionResult = transactionsController.Save(transactionEVM);
var test = new RedirectResult("test");
//Assert
Assert.IsNotNull(transactionResult);
Assert.AreSame(test, transactionResult);
}
private void mFilterButton_Click(object sender, EventArgs e)
{
List <Record> nFilterList = null;
if (this.mAllRButton.Checked)
{
nFilterList = TransactionsController.getInstance().Filter(FilterCodes: this.mCodeOLV.CheckedObjects);
}
if (this.mMonthRButton.Checked)
{
int nYear = int.Parse(this.mYearComboBox.Text);
int nMonth = this.mMonthComboBox.SelectedIndex + 1;
DateTime startDate = new DateTime(nYear, nMonth, 1);
DateTime endDate = new DateTime(nYear, nMonth, DateTime.DaysInMonth(nYear, nMonth));
nFilterList = TransactionsController.getInstance().Filter(startDate, endDate, this.mCodeOLV.CheckedObjects);
}
if (this.mRangeRButton.Checked)
{
DateTime startDate = this.mFromDatePicker.Value;
DateTime endDate = this.mToDatePicker.Value;
nFilterList = TransactionsController.getInstance().Filter(startDate, endDate, this.mCodeOLV.CheckedObjects);
}
if (((String)(this.mFilterListbox.Text)).Equals("Transactions"))
{
DisplayOLVForm form = new DisplayOLVForm(nFilterList);
form.Show();
}
else if (((String)(this.mFilterListbox.Text)).Equals("Trial Balance"))
{
DisplayTBForm form = new DisplayTBForm(nFilterList);
form.Show();
}
}
public async Task FetchUserTransactionsAsync_ShouldBeOfTypeNoContentResult()
{
// Arrange
TestMock.TransactionQuery
.Setup(
transactionQuery => transactionQuery.FetchUserTransactionsAsync(
It.IsAny <UserId>(),
It.IsAny <CurrencyType>(),
It.IsAny <TransactionType>(),
It.IsAny <TransactionStatus>()))
.ReturnsAsync(new Collection <ITransaction>())
.Verifiable();
var controller = new TransactionsController(TestMock.TransactionQuery.Object, TestMapper)
{
ControllerContext =
{
HttpContext = MockHttpContextAccessor.GetInstance()
}
};
// Act
var result = await controller.FetchUserTransactionsAsync();
// Assert
result.Should().BeOfType <NoContentResult>();
TestMock.TransactionQuery.Verify(
transactionQuery => transactionQuery.FetchUserTransactionsAsync(
It.IsAny <UserId>(),
It.IsAny <CurrencyType>(),
It.IsAny <TransactionType>(),
It.IsAny <TransactionStatus>()),
Times.Once);
}
public void GetAllTransactionsReturnsEverythingInRepository()
{
var allTransactions = new[]
{
new Transaction()
{
TransactionDate = DateTime.Now,
TransactionId = 1
},
new Transaction()
{
TransactionDate = DateTime.Now,
TransactionId = 2
}
};
var mockTransactionService = new Mock <ITransactionService>();
mockTransactionService.Setup(x => x.GetAllTransactions()).Returns(allTransactions);
var controller = new TransactionsController(mockTransactionService.Object);
IHttpActionResult actionResult = controller.GetTransactions();
OkNegotiatedContentResult <IEnumerable <Transaction> > contentResult = Assert.IsType <OkNegotiatedContentResult <IEnumerable <Transaction> > >(actionResult);
Assert.NotNull(contentResult);
Assert.NotNull(contentResult.Content);
Assert.Same(allTransactions, contentResult.Content);
}
public void Transaction_Reporting_And_Management_Search_Transaction_Request_Returns_Successfully()
{
var paymentsController = new PaymentsControllerTests();
int transactionId = paymentsController.Credit_Card_Present_AuthorizationOnly_Request_Returns_Successfully();
// Arramge
var request = new TransactionSearchRequest
{
TransactionId = transactionId,
StartDate = DateTime.UtcNow.AddDays(-1),
EndDate = DateTime.UtcNow.AddDays(1),
Amount = 11.00m,
DeveloperApplication = new DeveloperApplication
{
DeveloperId = 12345678,
Version = "1.2"
}
};
var apiContext = new APIContext();
var controller = new TransactionsController();
// Act
var response = controller.ProcessRequest<TransactionSearchResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
}
public void TestInitialize()
{
_fakeContext = new FakeBankContext();
_controller = new TransactionsController(_fakeContext);
_givenBankAccounts =
new[]
{
new BankAccount
{
Id = new Guid("bd877de3-d2c9-4237-b5ca-08bd3ba56cd8"),
Balance = 1000
},
new BankAccount
{
Id = new Guid("29222f0b-dd48-4589-921b-02eb8a4518f0"),
Balance = 100
},
};
_givenTransactions = new[]
{
new Transaction
{
Id = new Guid("bd877de3-d2c9-4237-b5ca-08bd3ba56ca7"),
AccountFrom = _givenBankAccounts[0],
AccountTo = _givenBankAccounts[1],
Amount = 100,
Timestamp = new DateTime(2015, 1, 1)
}
};
_fakeContext.BankAccounts.AddRange(_givenBankAccounts);
_fakeContext.Transactions.AddRange(_givenTransactions);
}
public void Transaction_Reporting_And_Management_Search_Transaction_Request_Returns_Successfully()
{
var paymentsController = new PaymentsControllerTests();
int transactionId = paymentsController.Credit_Card_Present_AuthorizationOnly_Request_Returns_Successfully();
// Arramge
var request = new TransactionSearchRequest
{
TransactionId = transactionId,
StartDate = DateTime.UtcNow.AddDays(-1),
EndDate = DateTime.UtcNow.AddDays(1),
Amount = 11.00m,
DeveloperApplication = new DeveloperApplication
{
DeveloperId = 12345678,
Version = "1.2"
}
};
var apiContext = new APIContext();
var controller = new TransactionsController();
// Act
var response = controller.ProcessRequest <TransactionSearchResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
}
public void Transaction_Reporting_And_Management_Search_Transaction_Request_Returns_Successfully()
{
// Arramge
var request = new TransactionSearchRequest
{
TransactionId = 111995104,
CustomerId = "5000587",
StartDate = Convert.ToDateTime("02/01/2016"),
EndDate = Convert.ToDateTime("05/31/2017"),
Amount = 11.00m,
DeveloperApplication = new DeveloperApplication
{
DeveloperId = 12345678,
Version = "1.2"
}
};
var apiContext = new APIContext();
var controller = new TransactionsController();
// Act
var response = controller.ProcessRequest <TransactionSearchResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
}
private void mTransactionOLV_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (this.mTransactionOLV.SelectedItems.Count == 1)
{
TransactionsController.getInstance().EditRecord((Record)this.mTransactionOLV.SelectedObject);
}
}
public ActionResult Index()
{
ViewBag.Title = "Transaction Page";
TransactionsController tc = new TransactionsController(db);
var result = tc.GetAllTransactions() as OkNegotiatedContentResult <List <Transaction> >;
return(View(result.Content));
}
public TransactionsControllerTest()
{
_serviceMock = new Mock <ITransactionService>();
_mapperMock = new Mock <IMapper>();
_loggerMock = new Mock <ILogger <TransactionsController> >();
controller = new TransactionsController(_serviceMock.Object, _mapperMock.Object, _loggerMock.Object);
}
public void SetUp()
{
_mockListTransacionsUsecase = new Mock <IListTransactions>();
ILogger <TransactionsController> nullLogger = NullLogger <TransactionsController> .Instance;
_classUnderTest = new TransactionsController(_mockListTransacionsUsecase.Object, nullLogger);
}
public void Index_ReturnsCorrectViewWhenUserSignedIn_True()
{
UserAccount user = new UserAccount("frodo", "shire");
TransactionsController controller = new TransactionsController();
ActionResult Index = controller.Index();
Assert.IsInstanceOfType(Index, typeof(ActionResult));
}
public async Task TestCreditNoAccount()
{
var mok = new Mock <ITransactionsRepository>();
var controller = new TransactionsController(mok.Object);
TransactionEntity obj = new TransactionEntity
{
Account = default,
public void Get_ShouldNotFindTransaction()
{
TransactionRepository repo = new TransactionRepository();
var transactionController = new TransactionsController(repo);
var result = transactionController.Get(-1);
Assert.That(result, Is.TypeOf <NotFoundResult>());
}
public TransactionsControllerTests()
{
_currencyService = new CurrencyServiceFake();
_merchantsService = new MerchantServiceFake();
_transactionsService = new TransactionServiceFake();
_cardDetailsService = new CardDetailsServiceFake();
_bankService = new BankServiceFake();
_transactionsController = new TransactionsController(_currencyService, _cardDetailsService, _merchantsService, _transactionsService, _bankService);
}
public void GetTransactionDetails_ControllerMethod_Should_Return_CorrectTransaction()
{
const string exceptedTransAccountCode = "12455145442";
const string exceptedTransactionRef = "110009011496RI";
_transConfiguration.SetupMockEntityRepositoryForGetAll(_transList);
var controller = new TransactionsController(_transConfiguration.MockPersistence.Object, _transConfiguration.MockLog.Object, _transConfiguration.MockSecurity.Object);
var returnValue = controller.GetTransactionDetails(exceptedTransAccountCode, exceptedTransactionRef, "v1");
Assert.IsNotNull(returnValue);
Assert.IsInstanceOfType(returnValue, typeof(OkResult));
}
public void Transaction_Reporting_And_Management_Retrieve_Transaction_Request_Returns_Successfully()
{
// Arrange
var request = new TransactionRetrieveRequest
{
TransactionId = 111995104
};
var apiContext = new APIContext();
var controller = new TransactionsController();
// Act
var response = controller.ProcessRequest<TransactionRetrieveResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
}
public void Transaction_Reporting_And_Management_Retrieve_Transaction_Request_Returns_Successfully()
{
var paymentsController = new PaymentsControllerTests();
int transactionId = paymentsController.Credit_Card_Present_AuthorizationOnly_Request_Returns_Successfully();
// Arrange
var request = new TransactionRetrieveRequest
{
TransactionId = transactionId
};
var apiContext = new APIContext();
var controller = new TransactionsController();
// Act
var response = controller.ProcessRequest<TransactionRetrieveResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
}
private static TransactionsController GetController()
{
var reps = new Mock<TransactionsRepository>();
reps.Setup(m => m.GetTransactions(It.IsAny<int?>())).Returns<int?>(p => GetTestTrans(p));
var car_rep = new Mock<CategoriesRepository>();
car_rep.Setup(m => m.GetAll(It.IsAny<int?>())).Returns<int?>(p => GetTestCats(p));
var tag_rep = new Mock<TagsRepository>();
tag_rep.Setup(m => m.GetAll(It.IsAny<int?>())).Returns<int?>(p => GetTestTags(p));
var controller = new TransactionsController(reps.Object, car_rep.Object, tag_rep.Object);
//set user and def company
var user = new UserProfile();
user.DefaultCompany = 1;
var comps = new List<Company>();
comps.Add(new Company() { Id = 1 });
user.Companies = comps;
controller.CurrentUser = user;
return controller;
}
public void Transaction_Reporting_And_Management_Update_Transaction_Request_Returns_Successfully()
{
// Arrange
var request = new TransactionUpdateRequest
{
ReferenceTransactionId = 111995104,
DutyAmount = "2.07",
DeveloperApplication = new DeveloperApplication
{
DeveloperId = 12345678,
Version = "1.2"
}
};
var apiContext = new APIContext();
var controller = new TransactionsController();
// Act
var response = controller.ProcessRequest<TransactionUpdateResponse>(apiContext, request);
// Assert
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
}
