Esempio n. 1
0
        public async Task ShouldTestService()
        {
            var noAuthClient = ApiServiceBuilder <ITradeService> .Build("http://localhost:8080").Create();

            var eqTraderClient = _tradeClient;

            var traderToken = ApiServiceBuilder <IUserService> .Build("http://localhost:8080")
                              .Create()
                              .Login(new Credentials()
            {
                Username = "******",
                Password = "******"
            }).Result;

            var tradeClient = ApiServiceBuilder <ITradeService> .Build("http://localhost:8080")
                              .AddAuthorizationHeader(() => traderToken.Digest)
                              .Create();

            Assert.CatchAsync(async() =>
            {
                await noAuthClient.GetAllTrades();
            }, "Response status code does not indicate success: 403 (Forbidden).");

            var trades = await tradeClient.GetAllTrades();

            var request = new TradeCreationRequest()
            {
                Counterparty = "XXX",
                Asset        = "XXX",
                Price        = 100.0,
                Volume       = 100,
                Way          = TradeWay.Buy
            };

            Assert.CatchAsync(async() =>
            {
                await tradeClient.CreateTrade(request);
            }, "Response status code does not indicate success: 403 (Forbidden).");

            var createdTradeResult = await eqTraderClient.CreateTrade(request);

            Assert.IsNotNull(createdTradeResult);

            var createdTrade = await eqTraderClient.GetTradeById(createdTradeResult.TradeId);

            Assert.IsNotNull(createdTrade);
            Assert.AreEqual(request.Counterparty, createdTrade.Counterparty);
            Assert.AreEqual(request.Asset, createdTrade.Asset);

            var client    = new HttpClient();
            var jsonError = await client.GetAsync("http://localhost:8080/api/v1/trade");

            var error = JsonConvert.DeserializeObject <ServiceErrorModel>(await jsonError.Content.ReadAsStringAsync());

            Assert.IsNotNull(error, "erroe should be send to the client in json format");
            Assert.AreEqual("User must have role [Trader]", error.Details);
            Assert.AreEqual("Unauthorized", error.Reason);

            await Task.Delay(500);
        }
Esempio n. 2
0
        public void SetUp()
        {
            _host = new Host <TradeServiceStartup>();
            _app  = _host.Build();
            _app.Start();

            _configuration = AppCore.Instance.Get <IServiceConfiguration>();

            var jsonSettings   = new AppJsonSerializer();
            var jsonSerializer = JsonSerializer.Create(jsonSettings);

            AppCore.Instance.ObjectProvider.Configure(conf => conf.For <JsonSerializerSettings>().Use(jsonSettings));
            AppCore.Instance.ObjectProvider.Configure(conf => conf.For <JsonSerializer>().Use(jsonSerializer));

            _traderToken = ApiServiceBuilder <IUserService> .Build("http://localhost:8080")
                           .Create()
                           .Login(new Credentials()
            {
                Username = "******",
                Password = "******"
            }).Result;

            _tradeClient = ApiServiceBuilder <ITradeService> .Build("http://localhost:8080")
                           .AddAuthorizationHeader(() => _traderToken.Digest)
                           .Create();

            _priceClient = AppCore.Instance.GetService <IPriceService>();

            Task.Delay(1000);

            var publisher = AppCore.Instance.Get <IPublisher>();

            publisher.Stop().Wait();
        }
        public TradeGenerator(TradeGeneratorConfiguration configuration, IEventStoreRepository <Guid> repository, IEventStoreCache <Guid, Trade> cache)
        {
            _configuration = configuration;

            _cache      = cache;
            _repository = repository;
            _jwthandler = new JwtSecurityTokenHandler();
            _cleanup    = new CompositeDisposable();

            var settings = AppCore.Instance.Get <JsonSerializerSettings>();

            var refitSettings = new RefitSettings()
            {
                ContentSerializer         = new JsonContentSerializer(settings),
                HttpMessageHandlerFactory = () => new HttpRetryForeverMessageHandler(5000)
            };

            var accessTokenRetrieverFactory = new AccessTokenRetrieverFactory();

            _tradeService = ApiServiceBuilder <ITradeService>
                            .Build(configuration.Gateway)
                            .AddAuthorizationHeader(accessTokenRetrieverFactory.GetToken(
                                                        "bob.woodworth",
                                                        "bob",
                                                        _configuration.Identity,
                                                        AzurePlaygroundConstants.Auth.ClientReferenceToken,
                                                        AzurePlaygroundConstants.Api.Trade,
                                                        _configuration.Key

                                                        ))
                            .Create(refitSettings: refitSettings);
        }
 public TradesController(AppConfiguration configuration)
 {
     _tradeService = ApiServiceBuilder <ITradeService> .Build(configuration.Gateway)
                     .AddAuthorizationHeader(() =>
     {
         return(HttpContext.GetTokenAsync("access_token").Result);
     })
                     .Create();
 }
        public MarketService(IEventStoreRepository <Guid> repository, MarketServiceConfiguration configuration, IEventStoreCache <Guid, Trade> cache)
        {
            _cache         = cache;
            _repository    = repository;
            _configuration = configuration;

            var settings = AppCore.Instance.Get <JsonSerializerSettings>();

            var refitSettings = new RefitSettings()
            {
                ContentSerializer         = new JsonContentSerializer(settings),
                HttpMessageHandlerFactory = () => new HttpRetryForeverMessageHandler(5000)
            };

            _priceService = ApiServiceBuilder <IPriceService>
                            .Build(configuration.Gateway)
                            .Create(refitSettings: refitSettings);
        }
        public async Task GetAsync_WhenInvoked_TheCorrectURLAndQueryParamsSent()
        {
            //Arrange
            var expectedResponse = new HttpResponseMessage
            {
                StatusCode = HttpStatusCode.OK,
                Content    = new FormUrlEncodedContent(new Dictionary <string, string> {
                    { "key", "value" }
                })
            };

            var mockHttpClientFactory  = new Mock <IHttpClientFactory>();
            var mockHttpMessageHandler = new Mock <HttpMessageHandler>(MockBehavior.Strict);

            mockHttpMessageHandler.Protected()
            .Setup <Task <HttpResponseMessage> >(
                "SendAsync",
                ItExpr.IsAny <HttpRequestMessage>(),
                ItExpr.IsAny <CancellationToken>()
                )
            .ReturnsAsync(expectedResponse)
            .Verifiable();
            var client = new HttpClient(mockHttpMessageHandler.Object);

            mockHttpClientFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(client);

            var service = new ApiServiceBuilder().WithHttpClientFactory(mockHttpClientFactory.Object).Build();

            //Act
            var response = await service.GetAsync(_tflMockRoadApiUrl, _tflMockQueryParams);

            var expectedContent = await expectedResponse.Content.ReadAsStringAsync();

            var actualContent = await response.Content.ReadAsStringAsync();

            //Assert
            mockHttpMessageHandler.Protected().Verify(
                "SendAsync",
                Times.Exactly(1),
                ItExpr.Is <HttpRequestMessage>(ex => ex.Method == HttpMethod.Get && (expectedContent == actualContent)),
                ItExpr.IsAny <CancellationToken>()
                );
        }
Esempio n. 7
0
        public async Task ShouldTestResponseCache()
        {
            //response cache do not work with an auth header
            var tradeClient = ApiServiceBuilder <ITradeService> .Build("http://localhost:8080").Create();

            var initialTrades = await tradeClient.GetAllTradesViaCache();

            var request = new TradeCreationRequest()
            {
                Counterparty = "XXXXX",
                Asset        = "XXXXX",
                Price        = 100.0,
                Volume       = 100,
                Way          = TradeWay.Buy
            };

            var createdTradeResult = await _tradeClient.CreateTrade(request);

            await Task.Delay(1000);

            var cachedTrades = await tradeClient.GetAllTradesViaCache();

            var notCachedTrades = await _tradeClient.GetAllTrades();

            Assert.AreEqual(initialTrades.Count(), cachedTrades.Count());
            Assert.AreEqual(notCachedTrades.Count(), cachedTrades.Count() + 1);


            var tradeClientNoCache = ApiServiceBuilder <ITradeService> .Build("http://localhost:8080")
                                     .AddHeader("Cache-Control", () => "no-cache ")
                                     .Create();

            //wait for the cache to invalidate
            await Task.Delay(3000);

            cachedTrades = await tradeClientNoCache.GetAllTradesViaCache();

            Assert.AreEqual(notCachedTrades.Count(), cachedTrades.Count());
        }
        public void GetAsync_WhenRequestExceptionIsThrown_ThrowsRequestException()
        {
            //Arrange
            var expectedResponse = new HttpResponseMessage
            {
                StatusCode = HttpStatusCode.OK,
                Content    = new FormUrlEncodedContent(new Dictionary <string, string> {
                    { "key", "value" }
                })
            };

            var mockHttpClientFactory  = new Mock <IHttpClientFactory>();
            var mockHttpMessageHandler = new Mock <HttpMessageHandler>(MockBehavior.Strict);

            mockHttpMessageHandler.Protected()
            .Setup <Task <HttpResponseMessage> >(
                "SendAsync",
                ItExpr.IsAny <HttpRequestMessage>(),
                ItExpr.IsAny <CancellationToken>()
                )
            .Throws(new HttpRequestException());
            var client = new HttpClient(mockHttpMessageHandler.Object);

            mockHttpClientFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(client);

            var service = new ApiServiceBuilder().WithHttpClientFactory(mockHttpClientFactory.Object).Build();

            //Act
            //Assert
            Assert.ThrowsAsync <HttpRequestException>(async() => await service.GetAsync(_tflMockRoadApiUrl, _tflMockQueryParams));
            mockHttpMessageHandler.Protected().Verify(
                "SendAsync",
                Times.Exactly(1),
                ItExpr.IsAny <HttpRequestMessage>(),
                ItExpr.IsAny <CancellationToken>()
                );
        }
        public MainViewModel()
        {
            Events = new ObservableCollection <string>();

            Trades = new ObservableCollection <TradeViewModel>();

            var configuration = AppCore.Instance.Get <AppConfiguration>();


            var refitSettings = new RefitSettings()
            {
                ContentSerializer         = new JsonContentSerializer(AppCore.Instance.Get <JsonSerializerSettings>()),
                HttpMessageHandlerFactory = () => new HttpRetryForeverMessageHandler(5000)
            };

            _tradeService = ApiServiceBuilder <ITradeService> .Build(configuration.Gateway)
                            .AddAuthorizationHeader(() =>
            {
                return(_token.AccessToken);
            })
                            .Create(refitSettings: refitSettings);



            MakeTrade = new Command(async() =>
            {
                var asset        = TradeServiceReferential.Assets.Random();
                var counterparty = TradeServiceReferential.Counterparties.Random();

                var rand = new Random();

                var request = new TradeCreationRequest()
                {
                    Asset  = asset.Name,
                    Volume = rand.Next(1, 50),
                    Way    = TradeWay.Buy
                };

                var tradeEvent = await _tradeService.CreateTrade(request);

                var trade = await _tradeService.GetTradeById(tradeEvent.TradeId);

                Notify($"{_token.User.Identity.Name} created trade {trade.EntityId} on desktop UI");
            });

            var options = new OidcClientOptions()
            {
                Authority = configuration.Identity,
                ClientId  = AzurePlaygroundConstants.Auth.ClientOpenIdNative,
                Scope     = "openid profile desk trade",
                Policy    = new Policy {
                    Discovery = new DiscoveryPolicy {
                        RequireHttps = false
                    }
                },
                RedirectUri           = "http://127.0.0.1/sample-wpf-app",
                PostLogoutRedirectUri = "http://127.0.0.1/sample-wpf-app",
                ResponseMode          = OidcClientOptions.AuthorizeResponseMode.FormPost,
                Flow    = OidcClientOptions.AuthenticationFlow.AuthorizationCode,
                Browser = new WpfEmbeddedBrowser()
            };

            _oidcClient = new OidcClient(options);

            Login = new Command(async() =>
            {
                try
                {
                    _token = await _oidcClient.LoginAsync(new IdentityModel.OidcClient.LoginRequest());
                }
                catch (Exception ex)
                {
                    Notify(ex.ToString());
                    return;
                }

                if (_token.IsError)
                {
                    var error = _token.Error == "User Cancellled" ? "The sign-in window was closed before authorization was completed." : _token.Error;
                    Notify(error);
                }
                else
                {
                    Token = _token;

                    Notify($"Logged in as { _token.User.Identity.Name}");

                    _priceEventService = SignalRServiceBuilder <Price, PriceRequest>
                                         .Create()
                                         .Build(new PriceRequest((p) => true), (opts) =>
                    {
                        opts.AccessTokenProvider = () => Task.FromResult(_token.AccessToken);
                    });

                    var priceServiceConnection = _priceEventService
                                                 .Connect(Scheduler.Default, 1000)
                                                 .Subscribe((priceEvent) =>
                    {
                        lock (_locker)
                        {
                            if (null == Application.Current.Dispatcher)
                            {
                                return;
                            }

                            foreach (var trade in Trades.Where(trade => trade.Asset == priceEvent.Asset).ToList())
                            {
                                Application.Current.Dispatcher.Invoke(() => trade.CurrentPrice = priceEvent.Value);
                            }
                        }

                        var ev = MakeEvent("PRICE", "PRICE", priceEvent.Asset, priceEvent.Value);

                        this.Notify(ev);
                    });


                    _tradeEventService = SignalRServiceBuilder <Trade, TradeEventRequest>
                                         .Create()
                                         .Build(new TradeEventRequest((p) => true), (opts) =>
                    {
                        opts.AccessTokenProvider = () => Task.FromResult(_token.AccessToken);
                    });


                    var tradeEventServiceConnection = _tradeEventService
                                                      .Connect(Scheduler.Default, 500)
                                                      .Subscribe((tradeEvent) =>
                    {
                        lock (_locker)
                        {
                            if (null == Application.Current.Dispatcher)
                            {
                                return;
                            }

                            Application.Current.Dispatcher.Invoke(() =>
                            {
                                var trade = Trades.FirstOrDefault(t => t.Id == tradeEvent.EntityId);

                                if (null == trade)
                                {
                                    Trades.Add(new TradeViewModel(tradeEvent));
                                }
                                else
                                {
                                    trade.ApplyChange(tradeEvent);
                                }
                            });
                        }

                        this.Notify(MakeEvent("TRADE", _tradeEventService.Current.Endpoint, tradeEvent.EntityId, tradeEvent.EntityId));
                    });



                    _cleanup.Add(priceServiceConnection);
                    //_cleanup.Add(tradeEventServiceConnection);

                    if (null == Application.Current.Dispatcher)
                    {
                        return;
                    }

                    await Application.Current.Dispatcher.Invoke(async() =>
                    {
                        var trades = await _tradeService.GetAllTrades();

                        foreach (var trade in trades)
                        {
                            var vm = new TradeViewModel(trade);
                            Trades.Add(vm);
                        }

                        Notify($"Fetched {trades.Count()} trade(s)");
                    });
                }
            }, () => Token == null);


            Dispatcher.CurrentDispatcher.ShutdownStarted += (s, e) =>
            {
                _cleanup.Dispose();
            };

            //Logout = new Command(async() =>
            //{

            //    try
            //    {
            //        var request = new LogoutRequest
            //        {
            //            IdTokenHint = Token.IdentityToken
            //        };

            //        await _oidcClient.LogoutAsync(request);

            //        Token = null;

            //        Notify($"Logged out");


            //    }
            //    catch (Exception ex)
            //    {
            //        Notify(ex.ToString());
            //        return;
            //    }
            //});
        }
        public MainViewModel()
        {
            Events = new ObservableCollection <string>();

            _authService = ApiServiceBuilder <IUserService>
                           .Build(TradeServiceReferential.ServiceHost)
                           .Create();

            _userToken = _authService.Login(new Credentials()
            {
                Username = "******",
                Password = "******"
            }).Result;

            AppCore.Instance.ObjectProvider.Configure(config => config.For <TradeServiceToken>().Use(_userToken));

            _tradeService = ApiServiceBuilder <ITradeService> .Build(TradeServiceReferential.ServiceHost)
                            .AddAuthorizationHeader(() => _userToken.Digest)
                            .Create();

            _priceEventService = SignalRServiceBuilder <Price, PriceRequest>
                                 .Create()
                                 .Build(new PriceRequest((p) => true), (opts) =>
            {
                opts.AccessTokenProvider = () => Task.FromResult(_userToken.Digest);
            });

            _priceEventService
            .Connect(Scheduler.Default, 1000)
            .Subscribe((priceEvent) =>
            {
                foreach (var trade in Trades.Where(trade => trade.Asset == priceEvent.Asset).ToList())
                {
                    Application.Current.Dispatcher.Invoke(() => trade.CurrentPrice = priceEvent.Value);
                }

                var ev = MakeEvent("PRICE", "PRICE", priceEvent.Asset, priceEvent.Value);
                this.Notify(ev);
            });


            _tradeEventService = SignalRServiceBuilder <TradeEvent, TradeEventRequest>
                                 .Create()
                                 .Build(new TradeEventRequest((p) => true), (opts) =>
            {
                opts.AccessTokenProvider = () => Task.FromResult(_userToken.Digest);
            });

            _tradeEventService
            .Connect(Scheduler.Default, 500)
            .Subscribe((tradeEvent) =>
            {
                Application.Current.Dispatcher.Invoke(() =>
                {
                    var trade = Trades.FirstOrDefault(t => t.Id == tradeEvent.TradeId);
                    if (null == trade)
                    {
                        return;
                    }
                    trade.Status = tradeEvent.Status;
                });

                this.Notify(MakeEvent("TRADE", _tradeEventService.Current.Endpoint, tradeEvent.TradeId, tradeEvent.Status));
            });


            Trades = new ObservableCollection <TradeViewModel>();

            MakeTrade = new Command(async() =>
            {
                var asset        = TradeServiceReferential.Assets.Random();
                var counterparty = TradeServiceReferential.Counterparties.Random();

                var rand = new Random();

                var request = new TradeCreationRequest()
                {
                    Counterparty = counterparty,
                    Asset        = asset.Name,
                    Price        = asset.Price,
                    Volume       = rand.Next(1, 50),
                    Way          = TradeWay.Buy
                };

                var tradeEvent = await _tradeService.CreateTrade(request);

                var trade = await _tradeService.GetTradeById(tradeEvent.TradeId);

                Application.Current.Dispatcher.Invoke(() => Trades.Add(new TradeViewModel(trade)));
            });

            Application.Current.Dispatcher.Invoke(async() =>
            {
                var trades = await _tradeService.GetAllTrades();

                foreach (var trade in trades)
                {
                    var vm = new TradeViewModel(trade);
                    Trades.Add(vm);
                }
            });
        }