static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure();
var logger = new Logger(log4net.LogManager.GetLogger("Logger"));
var optionsBuilder = new DbContextOptionsBuilder <ExchangeContext>();
optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=StockExchangeW;Trusted_Connection=True;");
IUnitOfWork unitOfWork = new UnitOfWork(new ExchangeContext(optionsBuilder.Options));
IClientService clientService = new ClientService(unitOfWork);
IClientStockService clientStockService = new ClientStockService(unitOfWork);
IOrderService orderService = new OrderService(unitOfWork);
IStockService stockService = new StockService(unitOfWork);
ITransactionHistoryService transactionHistoryService = new TransactionHistoryService(unitOfWork);
StockExchange stockExchange = new StockExchange(
unitOfWork,
clientService,
clientStockService,
orderService,
stockService,
transactionHistoryService,
logger);
logger.Info("Trading is started");
stockExchange.RunTraiding();
logger.Info("Trading is finished");
}
public AddressHistoryController(
IAddressValidationService addressValidator,
TransactionHistoryService transactionHistoryService)
{
_addressValidator = addressValidator;
_transactionHistoryService = transactionHistoryService;
}
public StockExchange(ExchangeContext db,
ITableRepository <Client> clientTableRepository,
ITableRepository <ClientStock> clientStockTableRepository,
ITableRepository <Issuer> issuerTableRepository,
ITableRepository <Order> orderTableRepository,
ITableRepository <PriceHistory> priceHistoryTableRepository,
ITableRepository <Stock> stockTableRepository,
ITableRepository <TransactionHistory> transactionHistoryTableRepository,
ClientService clientService,
ClientStockService clientStockService,
OrderService orderService,
PriceHistoryService priceHistoryService,
TransactionHistoryService transactionHistoryService,
ILogger logger
)
{
this.db = db;
this.clientTableRepository = clientTableRepository;
this.clientStockTableRepository = clientStockTableRepository;
this.issuerTableRepository = issuerTableRepository;
this.orderTableRepository = orderTableRepository;
this.priceHistoryTableRepository = priceHistoryTableRepository;
this.stockTableRepository = stockTableRepository;
this.transactionHistoryTableRepository = transactionHistoryTableRepository;
this.clientService = clientService;
this.clientStockService = clientStockService;
this.orderService = orderService;
this.priceHistoryService = priceHistoryService;
this.transactionHistoryService = transactionHistoryService;
this.logger = logger;
}
public async Task TransactionHistory_UpdateWallets_SkipErrorMemo()
{
Mock <IBlockchainAssetsService> blockchainAssetsService = new Mock <IBlockchainAssetsService>();
Mock <IBalanceService> balanceService = new Mock <IBalanceService>();
Mock <ITxHistoryRepository> txHistoryRepository = new Mock <ITxHistoryRepository>();
Mock <IHorizonService> horizonService = new Mock <IHorizonService>();
Mock <IObservationRepository <TransactionHistoryObservation> > observationRepository
= new Mock <IObservationRepository <TransactionHistoryObservation> >();
Mock <IKeyValueStoreRepository> keyValueStoreRepository = new Mock <IKeyValueStoreRepository>();
Mock <IWalletBalanceRepository> walletBalanceRepository = new Mock <IWalletBalanceRepository>();
string depositBaseAddress = "GCCWY6MNVWORHO7B3L6W5LULGFR337K5UAATA2Z3FSPQA5MYRW5X33ZP";
string memo = "http://stellar-win.me/";
string[] explorerUrlFormats = new [] { "" };
Mock <ILog> l1 = new Mock <ILog>();
Mock <ILogFactory> log = new Mock <ILogFactory>();
log.Setup(x => x.CreateLog(It.IsAny <object>())).Returns(l1.Object);
horizonService.Setup(x => x.GetMemo(It.IsAny <TransactionResponse>())).Returns(memo);
balanceService.Setup(x => x.GetDepositBaseAddress()).Returns(depositBaseAddress);
txHistoryRepository.Setup(x => x.InsertOrReplaceAsync(It.IsAny <TxDirectionType>(), It.IsAny <TxHistory>()))
.Returns(Task.FromResult(0)).Verifiable();
horizonService.Setup(x => x.GetTransactions(depositBaseAddress,
OrderDirection.ASC,
null,
It.IsAny <int>()))
.ReturnsAsync(new EditableList <TransactionResponse>()
{
new TransactionResponse("hash", 1, DateTime.UtcNow.ToString(), "", true, "", 1, 1000, 1,
"AAAAAM2Tf7J/6Vt6MRtYUwilF0fY5ndYLYtRWBHT6QU6LO5VAAAAZAByK8oAAAAlAAAAAAAAAAAAAAABAAAAAQAAAADNk3+yf+lbejEbWFMIpRdH2OZ3WC2LUVgR0+kFOizuVQAAAAEAAAAAhWx5ja2dE7vh2v1urosxY739XaABMGs7LJ8AdZiNu30AAAAAAAAAAAABhqEAAAAAAAAAATos7lUAAABAbYa73/EQqpadqoXuVhQyzcjf0jWOAAqsIiRmi0Qlmqbh8EyrhIlkPYgiteg2tTGujhiGN9EhNodGCIKyfmvjAA==",
"", "", Memo.Text(memo), null)
});
blockchainAssetsService.Setup(x => x.GetNativeAsset())
.Returns(new Asset("XLM", "", "Stellar Lumen", "native", 7));
TransactionHistoryService transactionHistoryService = new TransactionHistoryService(balanceService.Object,
horizonService.Object,
keyValueStoreRepository.Object,
observationRepository.Object,
txHistoryRepository.Object,
log.Object,
blockchainAssetsService.Object);
await transactionHistoryService.UpdateDepositBaseTransactionHistory();
balanceService.Setup(x => x.GetDepositBaseAddress()).Returns(depositBaseAddress);
txHistoryRepository
.Verify(x => x.InsertOrReplaceAsync(It.IsAny <TxDirectionType>(), It.IsAny <TxHistory>()), Times.Never());
}
public void ShouldThrowExceptionIfCantFindTransaction()
{
// Arrange
var transactionTableRepository = Substitute.For <ITableRepository <TransactionHistory> >();
TransactionHistoryService transactionService = new TransactionHistoryService(transactionTableRepository);
transactionTableRepository.ContainsByPK(1).Returns(false);
// Act
var transaction = transactionService.GetTransactionByID(1);
}
public void ShouldGetTransactionInfo()
{
// Arrange
var transactionTableRepository = Substitute.For <ITableRepository <TransactionHistory> >();
TransactionHistoryService transactionService = new TransactionHistoryService(transactionTableRepository);
transactionTableRepository.ContainsByPK(1).Returns(true);
// Act
var transaction = transactionService.GetTransactionByID(1);
// Assert
transactionTableRepository.Received(1).FindByPK(1);
}
static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure();
var logger = new Logger(log4net.LogManager.GetLogger("Logger"));
ExchangeContext db = new ExchangeContext();
IDTOMethodsforPriceHistory dTOMethodsforPriceHistory = new DTOMethodsforPriceHistory(db);
ITableRepository <Client> clientTableRepository = new ClientTableRepository <Client>(db);
ITableRepository <ClientStock> clientStockTableRepository = new ClientStockTableRepository <ClientStock>(db);
ITableRepository <Issuer> issuerTableRepository = new IssuerTableRepository <Issuer>(db);
ITableRepository <Order> orderTableRepository = new OrderTableRepository <Order>(db);
ITableRepository <PriceHistory> priceHistoryTableRepository = new PriceHistoryTableRepository <PriceHistory>(db);
ITableRepository <Stock> stockTableRepository = new StockTableRepository <Stock>(db);
ITableRepository <TransactionHistory> transactionHistoryTableRepository = new TransactionHistoryTableRepository <TransactionHistory>(db);
ClientService clientService = new ClientService(clientTableRepository);
ClientStockService clientStockService = new ClientStockService(clientStockTableRepository);
OrderService orderService = new OrderService(orderTableRepository);
PriceHistoryService priceHistoryService = new PriceHistoryService(priceHistoryTableRepository, dTOMethodsforPriceHistory);
TransactionHistoryService transactionHistoryService = new TransactionHistoryService(transactionHistoryTableRepository);
StockExchange stockExchange = new StockExchange(
db,
clientTableRepository,
clientStockTableRepository,
issuerTableRepository,
orderTableRepository,
priceHistoryTableRepository,
stockTableRepository,
transactionHistoryTableRepository,
clientService,
clientStockService,
orderService,
priceHistoryService,
transactionHistoryService,
logger);
using (db)
{
logger.Info("Trading is started");
stockExchange.RunTraiding();
logger.Info("Trading is finished");
};
}
public async void Get_null_record()
{
var mock = new ServiceMockFacade <ITransactionHistoryRepository>();
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <TransactionHistory>(null));
var service = new TransactionHistoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTransactionHistoryMapperMock,
mock.DALMapperMockFactory.DALTransactionHistoryMapperMock);
ApiTransactionHistoryResponseModel response = await service.Get(default(int));
response.Should().BeNull();
mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
}
public async void ByReferenceOrderIDReferenceOrderLineID_Not_Exists()
{
var mock = new ServiceMockFacade <ITransactionHistoryRepository>();
mock.RepositoryMock.Setup(x => x.ByReferenceOrderIDReferenceOrderLineID(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult <List <TransactionHistory> >(new List <TransactionHistory>()));
var service = new TransactionHistoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTransactionHistoryMapperMock,
mock.DALMapperMockFactory.DALTransactionHistoryMapperMock);
List <ApiTransactionHistoryResponseModel> response = await service.ByReferenceOrderIDReferenceOrderLineID(default(int), default(int));
response.Should().BeEmpty();
mock.RepositoryMock.Verify(x => x.ByReferenceOrderIDReferenceOrderLineID(It.IsAny <int>(), It.IsAny <int>()));
}
public async void Create()
{
var mock = new ServiceMockFacade <ITransactionHistoryRepository>();
var model = new ApiTransactionHistoryRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <TransactionHistory>())).Returns(Task.FromResult(new TransactionHistory()));
var service = new TransactionHistoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTransactionHistoryMapperMock,
mock.DALMapperMockFactory.DALTransactionHistoryMapperMock);
CreateResponse <ApiTransactionHistoryResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiTransactionHistoryRequestModel>()));
mock.RepositoryMock.Verify(x => x.Create(It.IsAny <TransactionHistory>()));
}
public async void All()
{
var mock = new ServiceMockFacade <ITransactionHistoryRepository>();
var records = new List <TransactionHistory>();
records.Add(new TransactionHistory());
mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new TransactionHistoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTransactionHistoryMapperMock,
mock.DALMapperMockFactory.DALTransactionHistoryMapperMock);
List <ApiTransactionHistoryResponseModel> response = await service.All();
response.Should().HaveCount(1);
mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
}
public async void ByProductID_Exists()
{
var mock = new ServiceMockFacade <ITransactionHistoryRepository>();
var records = new List <TransactionHistory>();
records.Add(new TransactionHistory());
mock.RepositoryMock.Setup(x => x.ByProductID(It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new TransactionHistoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTransactionHistoryMapperMock,
mock.DALMapperMockFactory.DALTransactionHistoryMapperMock);
List <ApiTransactionHistoryResponseModel> response = await service.ByProductID(default(int));
response.Should().NotBeEmpty();
mock.RepositoryMock.Verify(x => x.ByProductID(It.IsAny <int>()));
}
public async void Delete()
{
var mock = new ServiceMockFacade <ITransactionHistoryRepository>();
var model = new ApiTransactionHistoryRequestModel();
mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask);
var service = new TransactionHistoryService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTransactionHistoryMapperMock,
mock.DALMapperMockFactory.DALTransactionHistoryMapperMock);
ActionResponse response = await service.Delete(default(int));
response.Should().NotBeNull();
mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>()));
mock.ModelValidatorMockFactory.TransactionHistoryModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
}
public void ShouldAddTransactiont()
{
//Arrange
var transactionTableRepository = Substitute.For <ITableRepository <TransactionHistory> >();
TransactionHistoryService transactionService = new TransactionHistoryService(transactionTableRepository);
TransactionInfo transactInfo = new TransactionInfo
{
CustomerOrderId = 1,
SalerOrderId = 1,
TrDateTime = new DateTime(2019, 08, 21)
};
//Act
transactionService.AddTransactionInfo(transactInfo);
//Assert
transactionTableRepository.Received(1).Add(Arg.Is <TransactionHistory>(
w => w.CustomerOrderID == 1 &&
w.SalerOrderID == 1 &&
w.TransactionDateTime == new DateTime(2019, 08, 21)
));
}
public TransactionsController(TransactionHistoryService transactionHistoryService)
{
this.transactionHistoryService = transactionHistoryService;
}
