public void ApiClient_RequestJsonAsync_Failure_StartEndTraceLogged(string url)
        {
            var req = new HttpRequestBuilder()
                      .SetMethod(HttpMethod.Get)
                      .SetUri(url)
                      .Create();

            var entity = new SerialisedEntity {
                Message = "test message"
            };
            var content = JsonConvert.SerializeObject(entity);
            var instrumentationClient = Substitute.For <IInstrumentationClient>();

            var mockHttp = new MockHttpMessageHandler();

            mockHttp.When(HttpMethod.Get, url).Respond(r => new HttpResponseMessage(HttpStatusCode.NotFound)
            {
                Content = new StringContent(content, Encoding.UTF8, "application/json")
            });

            using (var http = mockHttp.ToHttpClient())
            {
                var api = new ApiClient(instrumentationClient, http);

                Action a = () =>
                {
                    var _ = api.RequestJsonAsync <SerialisedEntity>(req, false).Result;
                };

                a.Should().Throw <HttpRequestException>();
                instrumentationClient.Received(1).Info(Arg.Any <string>());
            }
        }
        public Property DateTimeOffset_SerialisationIsSymmetric(DateTime dateTime)
        {
            var dateTimeOffset = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour,
                                                    dateTime.Minute, dateTime.Second, TimeSpan.Zero);

            var value = new SerialisedEntity
            {
                DateAndTime = dateTimeOffset
            };

            Func <bool> rule = () =>
            {
                var json     = JsonConvert.SerializeObject(value);
                var newValue = JsonConvert.DeserializeObject <SerialisedEntity>(json);

                return(dateTimeOffset == newValue.DateAndTime);
            };

            return(rule.When(true));
        }
        public Property DateTimeOffset_MillisecondsIgnored(DateTime dateTime, int milliseconds)
        {
            var dt = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute,
                                  dateTime.Second, DateTimeKind.Utc).AddMilliseconds(milliseconds);
            var dto = new DateTimeOffset(dt, TimeSpan.Zero);

            var value = new SerialisedEntity
            {
                DateAndTime = dto
            };

            Func <bool> rule = () =>
            {
                var json     = JsonConvert.SerializeObject(value);
                var newValue = JsonConvert.DeserializeObject <SerialisedEntity>(json);

                var delta = Math.Abs((value.DateAndTime - newValue.DateAndTime).TotalMilliseconds);
                return(delta == milliseconds);
            };

            return(rule.When(milliseconds > 0));
        }
        public async Task ApiClient_RequestJsonAsync_Success_NoContent(string url)
        {
            var req = new HttpRequestBuilder()
                      .SetMethod(HttpMethod.Get)
                      .SetUri(url)
                      .Create();

            var entity = new SerialisedEntity {
                Message = "test message"
            };
            var content = JsonConvert.SerializeObject(entity);

            var mockHttp = new MockHttpMessageHandler();

            mockHttp.When(HttpMethod.Get, url).Respond(r => new HttpResponseMessage(HttpStatusCode.OK));

            using (var http = mockHttp.ToHttpClient())
            {
                var api    = new ApiClient(Substitute.For <IInstrumentationClient>(), http);
                var result = await api.RequestJsonAsync <SerialisedEntity>(req, false);

                result.Should().BeNull();
            }
        }