Example #1
0
        public async Task Does_throw_WebServiceException_on_Error_Async()
        {
            var client = new JsonServiceClient(Config.AbsoluteBaseUri);
            //var client = new JsonServiceClient("http://localhost:55799/");

            var requests = new[]
            {
                new BatchThrowsAsync {
                    Id = 1, Name = "Foo"
                },
                new BatchThrowsAsync {
                    Id = 2, Name = "Bar"
                },
                new BatchThrowsAsync {
                    Id = 3, Name = "Baz"
                },
            };

            try
            {
                var responses = await client.SendAllAsync(requests);

                Assert.Fail("Should throw");
            }
            catch (WebServiceException ex)
            {
                ex.ResponseStatus.PrintDump();

                Assert.That(ex.ErrorCode, Is.EqualTo(typeof(Exception).Name));
                Assert.That(ex.ResponseStatus.ErrorCode, Is.EqualTo(typeof(Exception).Name));
                Assert.That(ex.ResponseStatus.Message, Is.EqualTo("Batch Throws"));
                Assert.That(ex.ResponseHeaders[HttpHeaders.XAutoBatchCompleted], Is.EqualTo("0"));
            }
        }
Example #2
0
        public async Task Can_send_async_multi_reply_HelloAllCustom_requests()
        {
            var client = new JsonServiceClient(Config.AbsoluteBaseUri);

            var requests = new[]
            {
                new HelloAllCustom {
                    Name = "Foo"
                },
                new HelloAllCustom {
                    Name = "Bar"
                },
                new HelloAllCustom {
                    Name = "Baz"
                },
            };

            var responses = await client.SendAllAsync(requests);

            responses.PrintDump();

            var results = responses.Map(x => x.Result);

            Assert.That(results, Is.EquivalentTo(new[] {
                "Custom, Foo!", "Custom, Bar!", "Custom, Baz!"
            }));
        }
        async Task ConcreteAsyncApiUsage(JsonServiceClient client)
        {
            UsageNone none = await client.SendAsync <UsageNone>(new UsageNone());

            UsageNone noneToken = await client.SendAsync <UsageNone>(new UsageNone(), CancellationToken.None);

            UsageReturn @return = await client.SendAsync(new UsageReturn());

            UsageReturn returnToken = await client.SendAsync(new UsageReturn(), CancellationToken.None);

            await client.SendAsync(new UsageVoid());

            await client.SendAsync(new UsageVoid(), CancellationToken.None);

            List <UsageReturn> returnAll = await client.SendAllAsync(new[] { new UsageReturn() });

            List <UsageReturn> returnAllToken = await client.SendAllAsync(new[] { new UsageReturn() }, CancellationToken.None);

            await client.PublishAsync(new UsageNone());

            await client.PublishAsync(new UsageNone(), CancellationToken.None);

            await client.PublishAsync(new UsageReturn());

            await client.PublishAsync(new UsageReturn(), CancellationToken.None);

            await client.PublishAsync(new UsageVoid());

            await client.PublishAsync(new UsageVoid(), CancellationToken.None);

            await client.PublishAllAsync(new[] { new UsageNone() });

            await client.PublishAllAsync(new[] { new UsageNone() }, CancellationToken.None);

            await client.PublishAllAsync(new[] { new UsageReturn() });

            await client.PublishAllAsync(new[] { new UsageReturn() }, CancellationToken.None);

            await client.PublishAllAsync(new[] { new UsageVoid() });

            await client.PublishAllAsync(new[] { new UsageVoid() }, CancellationToken.None);
        }