public async Task Test()
        {
            ConvertAmountParams request = new ConvertAmountParams();

            request.Amount = (123L);
            request.Source = ("USD");
            request.Target = ("EUR");

            using (Client client = GetClient())
            {
                ConvertAmount response = await client
                                         .Merchant(GetMerchantId())
                                         .Services()
                                         .ConvertAmount(request);

                Assert.NotNull(response.ConvertedAmount);
            }
        }
Ejemplo n.º 2
0
        public async Task Test()
        {
            ConvertAmountParams request = new ConvertAmountParams();

            request.Amount = 123L;
            request.Source = "USD";
            request.Target = "EUR";

            CommunicatorConfiguration configuration = GetCommunicatorConfiguration();

            using (Client client = Factory.CreateClient(configuration))
            {
                ConvertAmount response = await client
                                         .Merchant(GetMerchantId())
                                         .Services()
                                         .ConvertAmount(request);

                Assert.NotNull(response.ConvertedAmount);
            }
        }
        public async Task TestLoggingConvertAmount()
        {
            // GET with query params

            TestLogger logger = new TestLogger();

            using (MockServer host = new MockServer(Port, "/v1/1234/services/convert/amount", (request, response, arg3) =>
            {
                AssignResponse((HttpStatusCode)200, new Dictionary <string, string>(), response);

                return(convertAmountJson);
            }))
                using (Client client = CreateClient())
                {
                    client.EnableLogging(logger);
                    ConvertAmountParams query = new ConvertAmountParams();
                    query.Amount = 1000L;
                    query.Source = "EUR";
                    query.Target = "USD";
                    ConvertAmount response = await client.Merchant("1234").Services().ConvertAmount(query);

                    Assert.NotNull(response);
                    Assert.NotNull(response.ConvertedAmount);
                }

            Assert.That(logger.Entries, Has.Count.EqualTo(2));

            TestLoggerEntry requestEntry = logger.Entries.First();

            Assert.NotNull(requestEntry.Message);
            Assert.Null(requestEntry.Thrown);

            TestLoggerEntry responseEntry = logger.Entries.ElementAt(1);

            Assert.NotNull(responseEntry.Message);
            Assert.Null(responseEntry.Thrown);

            AssertRequestAndResponse(requestEntry.Message, responseEntry.Message, convertAmountRequest, convertAmountResponse);
        }
        /// <summary>
        /// Smoke Test for using a proxy configured throught SDK properties.
        /// </summary>
        public async Task Test()
        {
            ConvertAmountParams request = new ConvertAmountParams();

            request.Amount = 123L;
            request.Source = "USD";
            request.Target = "EUR";

            using (Client client = GetClient())
            {
                ServicesClient services = client
                                          .Merchant(GetMerchantId())
                                          .Services();

                Assert.That(services, Is.TypeOf(typeof(ServicesClient)));
                CommunicatorConfiguration configuration = GetCommunicatorConfiguration();
                Assert.NotNull(configuration.Proxy);
                AssertProxyAndAuthentication(GetConnectionFromService(services), configuration.Proxy);

                ConvertAmount response = await services.ConvertAmount(request);

                Assert.NotNull(response.ConvertedAmount);
            }
        }