internal void CanSerializeAndDeserialize_SubmitBracketOrderCommands_WithNoTakeProfit()
        {
            // Arrange
            var entry        = new StubOrderBuilder().BuildMarketOrder();
            var stopLoss     = new StubOrderBuilder().BuildStopMarketOrder();
            var bracketOrder = new BracketOrder(entry, stopLoss);

            var command = new SubmitBracketOrder(
                new TraderId("TESTER", "000"),
                new AccountId("FXCM", "028999999", "SIMULATED"),
                new StrategyId("EMACross", "001"),
                new PositionId("P-123456"),
                bracketOrder,
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            var packed   = this.serializer.Serialize(command);
            var unpacked = (SubmitBracketOrder)this.serializer.Deserialize(packed);

            // Assert
            Assert.Equal(command, unpacked);
            Assert.Equal(bracketOrder, unpacked.BracketOrder);
            this.Output.WriteLine(Convert.ToBase64String(packed));
            this.Output.WriteLine(Encoding.UTF8.GetString(packed));
        }
Пример #2
0
        internal void GetSlippage_SellOrderFilledVariousAveragePrices_ReturnsExpectedResult(decimal averagePrice, decimal expectedSlippage)
        {
            // Arrange
            var order = new StubOrderBuilder()
                        .WithOrderSide(OrderSide.Sell)
                        .WithPrice(Price.Create(1.20000m, 5))
                        .BuildStopMarketOrder();

            var event1 = StubEventMessageProvider.OrderSubmittedEvent(order);
            var event2 = StubEventMessageProvider.OrderAcceptedEvent(order);
            var event3 = StubEventMessageProvider.OrderWorkingEvent(order, order.Price);
            var event4 = StubEventMessageProvider.OrderFilledEvent(order, Price.Create(averagePrice, 5));

            order.Apply(event1);
            order.Apply(event2);
            order.Apply(event3);
            order.Apply(event4);

            // Act
            var result = order.Slippage;

            // Assert
            Assert.Equal(OrderState.Filled, order.State);
            Assert.Equal(expectedSlippage, result);
        }
Пример #3
0
        internal void OnSubmitOrderCommand_WhenCommandValid_OperatesDatabaseAndSendsToGateway()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            var command = new SubmitOrder(
                traderId,
                accountId,
                strategyId,
                positionId,
                order,
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            this.engine.Endpoint.SendAsync(command).Wait();
            Task.Delay(100).Wait();  // Buffer to avoid intermittent tests

            // Assert
            Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
            Assert.Equal(2, this.engine.ProcessedCount);
            Assert.Equal(1, this.engine.CommandCount);
            Assert.Single(this.tradingGateway.CalledMethods);
            Assert.Single(this.tradingGateway.ReceivedObjects);
            Assert.Equal("SubmitOrder", this.tradingGateway.CalledMethods[0]);
            Assert.Equal(order, this.tradingGateway.ReceivedObjects[0]);
        }
        internal void CanSerializeAndDeserialize_OrderWorkingWithExpireTimeEvents()
        {
            // Arrange
            var order = new StubOrderBuilder()
                        .WithTimeInForce(TimeInForce.GTD)
                        .WithExpireTime(StubZonedDateTime.UnixEpoch() + Duration.FromMinutes(1))
                        .BuildStopMarketOrder();

            var working = new OrderWorking(
                AccountId.FromString("FXCM-02851908-DEMO"),
                order.Id,
                new OrderIdBroker("B" + order.Id.Value),
                order.Symbol,
                order.OrderSide,
                order.OrderType,
                order.Quantity,
                order.Price,
                order.TimeInForce,
                order.ExpireTime,
                StubZonedDateTime.UnixEpoch(),
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            var packed   = this.serializer.Serialize(working);
            var unpacked = (OrderWorking)this.serializer.Deserialize(packed);

            // Assert
            Assert.Equal(working, unpacked);
            this.Output.WriteLine(Convert.ToBase64String(packed));
        }
Пример #5
0
        internal void OnOrderPartiallyFilledEvent_UpdatesOrderSendsToPublisher()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            var submitOrder = new SubmitOrder(
                traderId,
                accountId,
                strategyId,
                positionId,
                order,
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            this.engine.Endpoint.SendAsync(submitOrder).Wait();
            this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
            this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderPartiallyFilledEvent(
                                               order,
                                               Quantity.Create(50000),
                                               Quantity.Create(50000))).Wait();
            Task.Delay(100).Wait();  // Buffer to avoid intermittent tests

            // Assert
            Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
            Assert.Equal(4, this.engine.ProcessedCount);
            Assert.Equal(1, this.engine.CommandCount);
            Assert.Equal(2, this.engine.EventCount);
            Assert.Equal(3, this.receiver.Messages.Count);
            Assert.Equal(OrderState.PartiallyFilled, order.State);
        }
Пример #6
0
        internal void OnOrderFilledEvent_WithNoPosition_OpensPosition()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            var submitOrder = new SubmitOrder(
                traderId,
                accountId,
                strategyId,
                positionId,
                order,
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            this.engine.Endpoint.SendAsync(submitOrder).Wait();
            this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderSubmittedEvent(order)).Wait();
            this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
            this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderFilledEvent(order)).Wait();
            Task.Delay(100).Wait();  // Buffer to avoid intermittent tests

            // Assert
            Assert.Single(this.database.GetPositions());
        }
Пример #7
0
        internal void OnModifyOrderCommand_WhenNoOrderExists_DoesNotSendToGateway()
        {
            // Arrange
            var order     = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId  = TraderId.FromString("TESTER-000");
            var accountId = AccountId.FromString("NAUTILUS-000-SIMULATED");

            var modify = new ModifyOrder(
                traderId,
                accountId,
                order.Id,
                order.Quantity,
                Price.Create(1.00010m, 5),
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            this.engine.Endpoint.SendAsync(modify);
            Task.Delay(100).Wait();  // Buffer to avoid intermittent tests

            // Assert
            Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
            Assert.Equal(2, this.engine.ProcessedCount);
            Assert.Equal(1, this.engine.CommandCount);
            Assert.Equal(0, this.engine.EventCount);
            Assert.Empty(this.tradingGateway.CalledMethods);
            Assert.Empty(this.tradingGateway.ReceivedObjects);
            Assert.Empty(this.receiver.Messages);
        }
        internal void CanSerializeAndDeserialize_OrderFilledEvents()
        {
            // Arrange
            var order = new StubOrderBuilder()
                        .WithQuantity(Quantity.Create(100000))
                        .BuildStopLimitOrder();

            var filled = new OrderFilled(
                AccountId.FromString("FXCM-02851908-DEMO"),
                order.Id,
                new ExecutionId("E123456"),
                new PositionIdBroker("P123456"),
                order.Symbol,
                order.OrderSide,
                order.Quantity,
                Price.Create(2m, 1),
                Currency.USD,
                StubZonedDateTime.UnixEpoch(),
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            var packed   = this.serializer.Serialize(filled);
            var unpacked = (OrderFilled)this.serializer.Deserialize(packed);

            // Assert
            Assert.Equal(filled, unpacked);
            this.Output.WriteLine(Convert.ToBase64String(packed));
        }
Пример #9
0
        internal void GetOrdersCompleted_WhenDoesNotExistInCache_ReturnsEmptyDictionary()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            order.Apply(StubEventMessageProvider.OrderSubmittedEvent(order));
            this.database.UpdateOrder(order);

            order.Apply(StubEventMessageProvider.OrderRejectedEvent(order));
            this.database.UpdateOrder(order);

            // Act
            this.database.ClearCaches();

            // Assert
            Assert.Empty(this.database.GetOrders());
            Assert.Empty(this.database.GetOrders(traderId));
            Assert.Empty(this.database.GetOrders(traderId, strategyId));
            Assert.Empty(this.database.GetOrdersWorking());
            Assert.Empty(this.database.GetOrdersWorking(traderId));
            Assert.Empty(this.database.GetOrdersWorking(traderId, strategyId));
            Assert.Empty(this.database.GetOrdersCompleted());
            Assert.Empty(this.database.GetOrdersCompleted(traderId));
            Assert.Empty(this.database.GetOrdersCompleted(traderId, strategyId));
        }
Пример #10
0
        internal void GetPositionsClosed_WhenNotPositionsInCache_ReturnsEmptyDictionary()
        {
            // Arrange
            var order1 = new StubOrderBuilder()
                         .WithOrderId("O-123456-1")
                         .BuildMarketOrder();

            var order2 = new StubOrderBuilder()
                         .WithOrderId("O-123456-2")
                         .WithOrderSide(OrderSide.Sell)
                         .BuildMarketOrder();

            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var strategyId = new StrategyId("SCALPER", "001");
            var positionId = new PositionId("P-123456");

            this.database.AddOrder(order1, traderId, accountId, strategyId, positionId);
            this.database.AddOrder(order2, traderId, accountId, strategyId, positionId);

            var position = new Position(positionId, StubEventMessageProvider.OrderFilledEvent(order1));

            this.database.AddPosition(position);

            position.Apply(StubEventMessageProvider.OrderFilledEvent(order2));
            this.database.UpdatePosition(position);

            // Act
            this.database.ClearCaches();

            // Assert
            Assert.Empty(this.database.GetPositionsClosed());
            Assert.Empty(this.database.GetPositionsClosed(traderId));
            Assert.Empty(this.database.GetPositionsClosed(traderId, strategyId));
        }
Пример #11
0
        internal void GetPositionsOpen_WhenNotPositionsInCache_ReturnsEmptyDictionary()
        {
            // Arrange
            var order      = new StubOrderBuilder().BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var strategyId = new StrategyId("SCALPER", "001");
            var positionId = new PositionId("P-123456");

            this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            var position = new Position(positionId, StubEventMessageProvider.OrderPartiallyFilledEvent(
                                            order,
                                            Quantity.Create(50000),
                                            Quantity.Create(50000)));

            this.database.AddPosition(position);

            position.Apply(StubEventMessageProvider.OrderFilledEvent(order));
            this.database.UpdatePosition(position);

            // Act
            this.database.ClearCaches();

            // Assert
            Assert.Empty(this.database.GetPositionsOpen());
            Assert.Empty(this.database.GetPositionsOpen(traderId));
            Assert.Empty(this.database.GetPositionsOpen(traderId, strategyId));
        }
Пример #12
0
        internal void UpdateOrder_WhenOrderCompleted_CorrectlyUpdatesIndexes()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            order.Apply(StubEventMessageProvider.OrderSubmittedEvent(order));
            this.database.UpdateOrder(order);

            order.Apply(StubEventMessageProvider.OrderRejectedEvent(order));

            // Act
            this.database.UpdateOrder(order);

            // Assert
            Assert.Contains(order.Id, this.database.GetOrderIds());
            Assert.Contains(order.Id, this.database.GetOrderIds(traderId));
            Assert.Contains(order.Id, this.database.GetOrderIds(traderId, strategyId));
            Assert.Contains(order.Id, this.database.GetOrderCompletedIds());
            Assert.Contains(order.Id, this.database.GetOrderCompletedIds(traderId));
            Assert.Contains(order.Id, this.database.GetOrderCompletedIds(traderId, strategyId));
            Assert.DoesNotContain(order.Id, this.database.GetOrderWorkingIds());
            Assert.Contains(order.Id, this.database.GetOrders(traderId));
            Assert.Contains(order.Id, this.database.GetOrders(traderId, strategyId));
            Assert.Contains(order.Id, this.database.GetOrdersCompleted(traderId));
            Assert.Contains(order.Id, this.database.GetOrdersCompleted(traderId, strategyId));
        }
Пример #13
0
        internal void AddOrder_WithNoOrdersInDatabase_CorrectlyAddsOrderWithIndexes()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            // Act
            this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            // Assert
            Assert.Equal(order, this.database.GetOrder(order.Id));
            Assert.Equal(positionId, this.database.GetPositionId(order.Id));
            Assert.Equal(traderId, this.database.GetTraderId(order.Id));
            Assert.Single(this.database.GetOrders());
            Assert.Single(this.database.GetOrders(traderId));
            Assert.Single(this.database.GetOrders(traderId, strategyId));
            Assert.Contains(order.Id, this.database.GetOrders());
            Assert.Contains(order.Id, this.database.GetOrders(traderId));
            Assert.Contains(order.Id, this.database.GetOrders(traderId, strategyId));
            Assert.Contains(traderId, this.database.GetTraderIds());
            Assert.Contains(accountId, this.database.GetAccountIds());
            Assert.Contains(strategyId, this.database.GetStrategyIds(traderId));
        }
Пример #14
0
        internal void IsComplete_OrderPartiallyFilled_ReturnsFalse()
        {
            // Arrange
            var order = new StubOrderBuilder()
                        .WithQuantity(Quantity.Create(100000))
                        .BuildStopMarketOrder();

            var event1 = StubEventMessageProvider.OrderSubmittedEvent(order);
            var event2 = StubEventMessageProvider.OrderAcceptedEvent(order);
            var event3 = StubEventMessageProvider.OrderWorkingEvent(order, order.Price);
            var event4 = StubEventMessageProvider.OrderPartiallyFilledEvent(
                order,
                Quantity.Create(50000),
                Quantity.Create(50000),
                order.Price);

            order.Apply(event1);
            order.Apply(event2);
            order.Apply(event3);
            order.Apply(event4);

            // Act
            var result = order.IsCompleted;

            // Assert
            Assert.True(order.State == OrderState.PartiallyFilled);
            Assert.False(result);
        }
Пример #15
0
        internal void UpdatePosition_WhenPositionOpen_CorrectlyUpdatesIndexes()
        {
            // Arrange
            var order      = new StubOrderBuilder().BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var strategyId = new StrategyId("SCALPER", "001");
            var positionId = new PositionId("P-123456");

            this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            var position = new Position(positionId, StubEventMessageProvider.OrderPartiallyFilledEvent(
                                            order,
                                            Quantity.Create(50000),
                                            Quantity.Create(50000)));

            this.database.AddPosition(position);

            // Act
            position.Apply(StubEventMessageProvider.OrderFilledEvent(order));
            this.database.UpdatePosition(position);

            // Assert
            Assert.Equal(position, this.database.GetPosition(positionId));
            Assert.Contains(position.Id, this.database.GetPositions());
            Assert.Contains(position.Id, this.database.GetPositions(traderId));
            Assert.Contains(position.Id, this.database.GetPositions(traderId, strategyId));
            Assert.Contains(position.Id, this.database.GetPositionsOpen());
            Assert.Contains(position.Id, this.database.GetPositionsOpen(traderId));
            Assert.Contains(position.Id, this.database.GetPositionsOpen(traderId, strategyId));
            Assert.Contains(position.Id, this.database.GetPositionIds());
            Assert.Contains(position.Id, this.database.GetPositionOpenIds());
            Assert.DoesNotContain(position.Id, this.database.GetPositionClosedIds());
        }
Пример #16
0
        internal void Apply_OrderPartiallyFilled_ReturnsCorrectOrderStatus()
        {
            // Arrange
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            var event1 = StubEventMessageProvider.OrderSubmittedEvent(order);
            var event2 = StubEventMessageProvider.OrderAcceptedEvent(order);
            var event3 = StubEventMessageProvider.OrderWorkingEvent(order, order.Price);
            var event4 = StubEventMessageProvider.OrderPartiallyFilledEvent(
                order,
                order.Quantity,
                Quantity.Create(order.Quantity / 2),
                order.Price);

            // Act
            order.Apply(event1);
            order.Apply(event2);
            order.Apply(event3);
            order.Apply(event4);

            var result = order.State;

            // Assert
            Assert.Equal(OrderState.PartiallyFilled, result);
        }
Пример #17
0
        internal void Build_WithAllParametersModified_ThenReturnsExpectedOrder()
        {
            // Arrange
            // Act
            var order = new StubOrderBuilder()
                        .WithSymbol(new Symbol("AUD/USD", new Venue("FXCM")))
                        .WithOrderId("O-678910")
                        .WithOrderSide(OrderSide.Sell)
                        .WithQuantity(Quantity.Create(100000))
                        .WithPrice(Price.Create(1.00000m, 5))
                        .WithTimeInForce(TimeInForce.GTD)
                        .WithExpireTime(StubZonedDateTime.UnixEpoch() + Period.FromMinutes(5).ToDuration())
                        .WithTimestamp(StubZonedDateTime.UnixEpoch() + Period.FromMinutes(1).ToDuration())
                        .BuildStopMarketOrder();

            // Assert
            Assert.Equal(new Symbol("AUD/USD", new Venue("FXCM")), order.Symbol);
            Assert.Equal("O-678910", order.Id.Value);
            Assert.Equal(OrderSide.Sell, order.OrderSide);
            Assert.Equal(OrderType.Stop, order.OrderType);
            Assert.Equal(Quantity.Create(100000), order.Quantity);
            Assert.Equal(Price.Create(1m, 5), order.Price);
            Assert.Equal(TimeInForce.GTD, order.TimeInForce);
            Assert.Equal(StubZonedDateTime.UnixEpoch() + Period.FromMinutes(5).ToDuration(), order.ExpireTime);
            Assert.Equal(StubZonedDateTime.UnixEpoch() + Period.FromMinutes(1).ToDuration(), order.Timestamp);
        }
Пример #18
0
        internal void BrokerOrderId_ListIsEmpty_ReturnsNullEntityId()
        {
            // Arrange
            // Act
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            // Assert
            Assert.Null(order.IdBroker);
        }
Пример #19
0
        internal void ExecutionId_ListIsEmpty_ReturnsNullEntityId()
        {
            // Arrange
            // Act
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            // Assert
            Assert.Null(order.ExecutionId);
        }
Пример #20
0
        internal void BuildStopMarket_ThenReturnsExpectedOrder()
        {
            // Arrange
            // Act
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            // Assert
            Assert.Equal(OrderType.Stop, order.OrderType);
        }
Пример #21
0
        internal void OnModifyOrderCommand_WhenOrderAlreadyBeingModified_DoesNotSendToGateway()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildStopMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            var submit = new SubmitOrder(
                traderId,
                accountId,
                strategyId,
                positionId,
                order,
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            var modify1 = new ModifyOrder(
                traderId,
                accountId,
                order.Id,
                order.Quantity,
                Price.Create(1.00010m, 5),
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            var modify2 = new ModifyOrder(
                traderId,
                accountId,
                order.Id,
                order.Quantity,
                Price.Create(1.00010m, 5),
                Guid.NewGuid(),
                StubZonedDateTime.UnixEpoch());

            // Act
            this.engine.Endpoint.SendAsync(submit).Wait();
            this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderAcceptedEvent(order)).Wait();
            this.engine.Endpoint.SendAsync(StubEventMessageProvider.OrderWorkingEvent(order)).Wait();
            this.engine.Endpoint.SendAsync(modify1).Wait();
            this.engine.Endpoint.SendAsync(modify2).Wait();
            Task.Delay(100).Wait();  // Buffer to avoid intermittent tests

            // Assert
            Assert.Null(this.engine.UnhandledMessages.FirstOrDefault());
            Assert.Equal(6, this.engine.ProcessedCount);
            Assert.Equal(3, this.engine.CommandCount);
            Assert.Equal(2, this.engine.EventCount);
            Assert.Equal(2, this.tradingGateway.CalledMethods.Count);
            Assert.Equal(2, this.tradingGateway.ReceivedObjects.Count);
            Assert.Equal("SubmitOrder", this.tradingGateway.CalledMethods[0]);
            Assert.Equal("ModifyOrder", this.tradingGateway.CalledMethods[1]);
            Assert.Equal(3, this.receiver.Messages.Count);
        }
Пример #22
0
        internal void GetSlippage_UnfilledOrder_ReturnsZero()
        {
            // Arrange
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            // Act
            var result = order.Slippage.HasValue;

            // Assert
            Assert.False(result);
        }
Пример #23
0
        internal void IsComplete_OrderInitialized_ReturnsFalse()
        {
            // Arrange
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            // Act
            var result = order.IsCompleted;

            // Assert
            Assert.False(result);
        }
Пример #24
0
        internal void Equals_OrderWithTheSameOrderId_ReturnsFalse()
        {
            // Arrange
            var order1 = new StubOrderBuilder().WithOrderId("O-1234567").BuildStopMarketOrder();
            var order2 = new StubOrderBuilder().WithOrderId("O-123456789").BuildStopMarketOrder();

            // Act
            var result = order1.Equals(order2);

            // Assert
            Assert.False(result);
        }
Пример #25
0
        internal void Equals_ObjectSomeOtherType_ReturnsFalse()
        {
            // Arrange
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            // Act
            // ReSharper disable once SuspiciousTypeConversion.Global (this is why the test returns false)
            var result = order.Equals(string.Empty);

            // Assert
            Assert.False(result);
        }
Пример #26
0
        internal void Equals_OrderWithTheSameOrderId_ReturnsTrue()
        {
            // Arrange
            var order1 = new StubOrderBuilder().WithOrderId("O-123456789").BuildStopMarketOrder();
            var order2 = new StubOrderBuilder().WithOrderId("O-123456789").BuildStopMarketOrder();

            // Act
            var result = order1.Equals(order2);

            this.Output.WriteLine(order1.ToString());
            this.Output.WriteLine(order2.ToString());

            // Assert
            Assert.True(result);
        }
Пример #27
0
        internal void Rejected_ParametersValid_ReturnsExpectedResult()
        {
            // Arrange
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            var event1 = StubEventMessageProvider.OrderSubmittedEvent(order);
            var event2 = StubEventMessageProvider.OrderRejectedEvent(order);

            // Act
            order.Apply(event1);
            order.Apply(event2);

            // Assert
            Assert.Equal(3, order.EventCount);
            Assert.Equal(OrderState.Rejected, order.State);
            Assert.Equal(StubZonedDateTime.UnixEpoch(), order.LastEvent.Timestamp);
        }
Пример #28
0
        internal void Build_WithNoParametersModified_ThenReturnsExpectedOrder()
        {
            // Arrange
            // Act
            var order = new StubOrderBuilder().BuildStopMarketOrder();

            // Assert
            Assert.Equal(new Symbol("AUD/USD", new Venue("FXCM")), order.Symbol);
            Assert.Equal("O-123456", order.Id.Value);
            Assert.Equal(OrderSide.Buy, order.OrderSide);
            Assert.Equal(OrderType.Stop, order.OrderType);
            Assert.Equal(Quantity.Create(100000), order.Quantity);
            Assert.Equal(Price.Create(1m, 1), order.Price);
            Assert.Equal(TimeInForce.DAY, order.TimeInForce);
            Assert.Null(order.ExpireTime);
            Assert.Equal(StubZonedDateTime.UnixEpoch(), order.Timestamp);
        }
Пример #29
0
        internal void ClearCaches_WithOrderInCaches_CorrectlyClearsCache()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            // Act
            this.database.ClearCaches();

            // Assert
            Assert.Null(this.database.GetOrder(order.Id));
        }
Пример #30
0
        internal void AddOrder_WhenOrderAlreadyExists_ReturnsFailureResult()
        {
            // Arrange
            var order      = new StubOrderBuilder().EntryOrder("O-123456").BuildMarketOrder();
            var traderId   = TraderId.FromString("TESTER-000");
            var accountId  = AccountId.FromString("NAUTILUS-000-SIMULATED");
            var positionId = new PositionId("P-123456");
            var strategyId = new StrategyId("SCALPER", "001");

            this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            // Act
            var result = this.database.AddOrder(order, traderId, accountId, strategyId, positionId);

            // Assert
            Assert.True(result.IsFailure);
        }