public void Ctor1_WithContentType_SetsContentType()
        {
            var contentTypeString = "text/html";
            var httpBodyContent = new HttpBodyContent(body: new {}, contentType: contentTypeString, encoding: null);

            Assert.Equal(contentTypeString, httpBodyContent.ContentType);
        }
예제 #2
0
        public void Ctor2_WithEncoding_SetsEncoding()
        {
            var encoding = Encoding.Unicode;
            var httpBodyContent = new HttpBodyContent(body: String.Empty, contentType: null, encoding: encoding);

            Assert.Equal(encoding, httpBodyContent.Encoding);
        }
예제 #3
0
        public void Ctor2_WithContentType_SetsContentType()
        {
            const string contentTypeString = "text/html";
            var httpBodyContent = new HttpBodyContent(content: String.Empty, contentType: contentTypeString, encoding: null);

            Assert.Equal(contentTypeString, httpBodyContent.ContentType);
        }
        public void Convert_WithContentLengthHeader_ContentLengthHeaderIsAddedToHttpRequestMessageContentHeaders()
        {
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Length", "12" }
                },
                Body = "Some content"
            };
            var httpBodyContent = new HttpBodyContent(request.Body, "text/plain", Encoding.UTF8);
            var stringContent = new StringContent(request.Body, Encoding.UTF8, "text/plain");

            var mapper = GetSubject();

            _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            _mockHttpBodyContentMapper.Convert(Arg.Any<string>(), Arg.Any<IDictionary<string, string>>()).Returns(httpBodyContent);
            _mockHttpContentMapper.Convert(httpBodyContent).Returns(stringContent);

            var result = mapper.Convert(request);

            Assert.Equal(request.Headers.Last().Key, result.Content.Headers.Last().Key);
            Assert.Equal(request.Headers.Last().Value, result.Content.Headers.Last().Value.First());
        }
        public void Convert_WithJsonBody_CallsHttpBodyContentMapperAndCorrectlySetsBody()
        {
            var headers = new Dictionary<string, IEnumerable<string>>
            {
                { "Content-Type", new List<string> { "application/json", "charset=utf-8" } }
            };
            var body = new
            {
                Test = "tester",
                test2 = 1
            };
            const string content = "{\"Test\":\"tester\",\"test2\":1}";
            var contentBytes = Encoding.UTF8.GetBytes(content);
            var request = GetPreCannedRequest(headers: headers, content: content);
            var httpBodyContent = new HttpBodyContent(content: contentBytes, contentType: "application/json", encoding: Encoding.UTF8);

            var mockHttpVerbMapper = Substitute.For<IHttpVerbMapper>();
            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();
            mockHttpVerbMapper.Convert("GET").Returns(HttpVerb.Get);
            mockHttpBodyContentMapper.Convert(content: Arg.Any<byte[]>(), headers: Arg.Any<IDictionary<string, string>>()).Returns(httpBodyContent);

            var mapper = new ProviderServiceRequestMapper(mockHttpVerbMapper, mockHttpBodyContentMapper);

            var result = mapper.Convert(request);

            Assert.Equal(body.Test, (string)result.Body.Test);
            Assert.Equal(body.test2, (int)result.Body.test2);
            mockHttpBodyContentMapper.Received(1).Convert(content: Arg.Any<byte[]>(), headers: Arg.Any<IDictionary<string, string>>());
        }
        public void Convert_WithContentTypeAndCustomHeader_OnlyCustomHeadersIsAddedToHttpRequestMessage()
        {
            const string contentTypeString = "text/plain";
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", contentTypeString },
                    { "X-Custom", "My Custom header" }
                },
                Body = new { }
            };
            var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, null);

            var mockHttpMethodMapper = Substitute.For<IHttpMethodMapper>();
            var mockHttpContentMapper = Substitute.For<IHttpContentMapper>();
            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();

            mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(httpBodyContent);

            IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper(
                mockHttpMethodMapper,
                mockHttpContentMapper,
                mockHttpBodyContentMapper);

            var result = mapper.Convert(request);

            Assert.Equal(request.Headers.Last().Key, result.Headers.First().Key);
            Assert.Equal(request.Headers.Last().Value, result.Headers.First().Value.First());
        }
        public void Ctor1_WithPlainTextBody_SetsBodyAndContent()
        {
            const string body = "Some plain text";
            var httpBodyContent = new HttpBodyContent(body: body, contentType: "application/plain", encoding: null);

            Assert.Equal(body, httpBodyContent.Content);
            Assert.Equal(body, httpBodyContent.Body);
        }
예제 #8
0
        public void Convert_WithEmptyContent_ReturnsNull()
        {
            var httpBodyContent = new HttpBodyContent(String.Empty, "text/plain", Encoding.UTF8);
            var mapper = GetSubject();

            var result = mapper.Convert(httpBodyContent);

            Assert.Empty(result.ReadAsStringAsync().Result);
        }
        public HttpContent Convert(HttpBodyContent from)
        {
            if (from == null)
            {
                return null;
            }

            return new StringContent(from.Content, from.Encoding, from.ContentType);
        }
예제 #10
0
        public void Ctor1_WithJsonBodyAndTitleCasedContentType_SetsBodyAndContent()
        {
            var body = new
            {
                Test = "tester",
                tesTer = 1
            };
            const string content = "{\"Test\":\"tester\",\"tesTer\":1}";
            var httpBodyContent = new HttpBodyContent(body: body, contentType: "Application/Json", encoding: null);

            Assert.Equal(content, httpBodyContent.Content);
            Assert.Equal(body, httpBodyContent.Body);
        }
        public void Convert_WithJsonBody_CallsConvertOnHttpBodyContentMapperAndAssignsContents()
        {
            const string contentTypeString = "application/json";
            var response = new ProviderServiceResponse
            {
                Status = 200,
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", contentTypeString }
                },
                Body = new
                {
                    Test = "tester",
                    Test2 = 1
                }
            };
            var jsonBody = "{\"Test\":\"tester\",\"Test2\":1}";
            var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(jsonBody), contentType: contentTypeString, encoding: null);

            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();

            mockHttpBodyContentMapper.Convert(body: Arg.Any<object>(), headers: response.Headers)
                .Returns(httpBodyContent);

            var mapper = new NancyResponseMapper(mockHttpBodyContentMapper);

            var result = mapper.Convert(response);

            string content;
            using (var stream = new MemoryStream())
            {
                result.Contents(stream);
                stream.Position = 0;
                using (var reader = new StreamReader(stream))
                {
                    content = reader.ReadToEnd();
                }
            }

            Assert.Equal(jsonBody, content);
            mockHttpBodyContentMapper.Received(1).Convert(body: Arg.Any<object>(), headers: response.Headers);
        }
        public void Convert_WithContentTypeSpecifiedAndAlsoBeingSetByStringContent_ContentTypeHeaderIsNotReAddedToHttpRequestMessageContentHeaders()
        {
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", "text/plain" }
                },
                Body = "Some content"
            };
            var httpBodyContent = new HttpBodyContent(request.Body, "text/plain", Encoding.UTF8);
            var stringContent = new StringContent(request.Body, Encoding.UTF8, "text/plain");

            var mapper = GetSubject();

            _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            _mockHttpBodyContentMapper.Convert(Arg.Any<string>(), Arg.Any<IDictionary<string, string>>()).Returns(httpBodyContent);
            _mockHttpContentMapper.Convert(httpBodyContent).Returns(stringContent);

            var result = mapper.Convert(request);

            Assert.Equal(1, result.Content.Headers.Count());
            Assert.Equal(request.Headers.First().Key, result.Content.Headers.First().Key);
            Assert.Equal("text/plain; charset=utf-8", result.Content.Headers.First().Value.First());
        }
예제 #13
0
        public void Ctor2_WithJsonContent_SetsBodyAndContent()
        {
            var body = new
            {
                Test = "tester",
                tesTer = 1
            };
            const string content = "{\"Test\":\"tester\",\"tesTer\":1}";
            var httpBodyContent = new HttpBodyContent(content: content, contentType: "application/json", encoding: null);

            Assert.Equal(content, httpBodyContent.Content);
            Assert.Equal(body.Test, (string) httpBodyContent.Body.Test);
            Assert.Equal(body.tesTer, (int) httpBodyContent.Body.tesTer);
        }
예제 #14
0
        public void Ctor1_WithCustomJsonBody_SetsBodyAndContent()
        {
            var body = new
            {
                Test = "tester",
                tesTer = 1
            };
            const string content = "{\"Test\":\"tester\",\"tesTer\":1}";
            var httpBodyContent = new HttpBodyContent(body: body, contentType: "application/x-amz-json-1.1", encoding: null);

            Assert.Equal(content, httpBodyContent.Content);
            Assert.Equal(body, httpBodyContent.Body);
        }
        public void Convert_WithPlainTextBody_CallsHttpBodyContentMapperAndCorrectlySetsBody()
        {
            const string content = "Plain text body";
            var contentByes = Encoding.UTF8.GetBytes(content);
            var request = GetPreCannedRequest(content: content);
            var httpBodyContent = new HttpBodyContent(content, null, null);

            var mockHttpVerbMapper = Substitute.For<IHttpVerbMapper>();
            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();
            mockHttpVerbMapper.Convert("GET").Returns(HttpVerb.Get);
            mockHttpBodyContentMapper.Convert(content: Arg.Any<byte[]>(), headers: null).Returns(httpBodyContent);

            var mapper = new ProviderServiceRequestMapper(mockHttpVerbMapper, mockHttpBodyContentMapper);

            var result = mapper.Convert(request);

            Assert.Equal(content, result.Body);
            mockHttpBodyContentMapper.Received(1).Convert(content: Arg.Any<byte[]>(), headers: null);
        }
        public void Convert_WithPlainContentTypeAndUtf8CharsetHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithEncodingAndContentType()
        {
            const string contentTypeString = "text/plain";
            const string encodingString = "utf-8";
            var encoding = Encoding.UTF8;
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", contentTypeString + "; charset=" + encodingString }
                },
                Body = new { }
            };
            var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, encoding);

            var mapper = GetSubject();

            _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            _mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(httpBodyContent);

            var result = mapper.Convert(request);

            Assert.Empty(result.Headers);
            _mockHttpBodyContentMapper.Received(1).Convert(request.Body, request.Headers);
            _mockHttpContentMapper.Received(1).Convert(httpBodyContent);
        }
        public void Convert_WithContentTypeSpecifiedButNotBeingSetByByteArrayContent_ContentTypeHeaderIsNotReAddedToHttpRequestMessageContentHeaders()
        {
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", "application/octet-stream" }
                },
                Body = Encoding.UTF8.GetBytes("Some content")
            };
            var httpBodyContent = new HttpBodyContent(request.Body, "text/plain", Encoding.UTF8);
            var byteArrayContent = new ByteArrayContent(request.Body as byte[]);

            var mapper = GetSubject();

            _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            _mockHttpBodyContentMapper.Convert(Arg.Any<object>(), Arg.Any<IDictionary<string, string>>()).Returns(httpBodyContent);
            _mockHttpContentMapper.Convert(httpBodyContent).Returns(byteArrayContent);

            var result = mapper.Convert(request);

            Assert.Equal(1, result.Content.Headers.Count());
            Assert.Equal(request.Headers.First().Key, result.Content.Headers.First().Key);
            Assert.Equal("application/octet-stream", result.Content.Headers.First().Value.First());
        }
예제 #18
0
        public void Encoding_WithNullEncodingSet_ReturnsUtf8Encoding()
        {
            var httpBodyContent = new HttpBodyContent(new {}, null, null);

            Assert.Equal(Encoding.UTF8, httpBodyContent.Encoding);
        }
        public void Convert_WithJsonContentTypeAndUnicodeCharsetHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithEncodingAndContentType()
        {
            const string contentTypeString = "application/json";
            const string encodingString = "utf-16";
            var encoding = Encoding.Unicode;
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", contentTypeString + "; charset=" + encodingString }
                },
                Body = new { }
            };
            var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, encoding);

            var mockHttpMethodMapper = Substitute.For<IHttpMethodMapper>();
            var mockHttpContentMapper = Substitute.For<IHttpContentMapper>();
            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();

            mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(httpBodyContent);

            IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper(
                mockHttpMethodMapper,
                mockHttpContentMapper,
                mockHttpBodyContentMapper);

            var result = mapper.Convert(request);

            Assert.Empty(result.Headers);
            mockHttpBodyContentMapper.Received(1).Convert(request.Body, request.Headers);
            mockHttpContentMapper.Received(1).Convert(httpBodyContent);
        }
예제 #20
0
        public void ContentBytes_WithEmptyContent_ReturnsEmptyUtf8ByteArray()
        {
            var httpBodyContent = new HttpBodyContent(String.Empty, null, null);

            Assert.Empty(httpBodyContent.ContentBytes);
        }
예제 #21
0
        public void ContentType_WithEmptyContentTypeSet_ReturnsPlainContentType()
        {
            var httpBodyContent = new HttpBodyContent(new {}, String.Empty, null);

            Assert.Equal("text/plain", httpBodyContent.ContentType);
        }
예제 #22
0
        public void Ctor2_WithPlainTextContent_SetsBodyAndContent()
        {
            const string content = "Some plain text";
            var httpBodyContent = new HttpBodyContent(content: content, contentType: "application/plain", encoding: null);

            Assert.Equal(content, httpBodyContent.Content);
            Assert.Equal(content, httpBodyContent.Body);
        }
        public void Convert_WithPlainContentTypeHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithContentType()
        {
            const string contentTypeString = "text/plain";
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", contentTypeString }
                },
                Body = new {}
            };
            var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, null);

            var mockHttpMethodMapper = Substitute.For<IHttpMethodMapper>();
            var mockHttpContentMapper = Substitute.For<IHttpContentMapper>();
            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();

            mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(httpBodyContent);

            IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper(
                mockHttpMethodMapper,
                mockHttpContentMapper,
                mockHttpBodyContentMapper);

            var result = mapper.Convert(request);

            Assert.Empty(result.Headers);
            mockHttpContentMapper.Received(1).Convert(httpBodyContent);
        }
        public void Convert_WithPlainTextBody_CallsConvertOnHttpBodyContentMapperAndAssignsContents()
        {
            const string contentTypeString = "text/plain";
            var response = new ProviderServiceResponse
            {
                Status = 200,
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", contentTypeString }
                },
                Body = "This is a plain body"
            };
            var httpBodyContent = new HttpBodyContent(body: response.Body, contentType: contentTypeString, encoding: null);

            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();

            mockHttpBodyContentMapper.Convert(body: Arg.Any<object>(), headers: response.Headers)
                .Returns(httpBodyContent);

            var mapper = new NancyResponseMapper(mockHttpBodyContentMapper);

            var result = mapper.Convert(response);

            string content;
            using (var stream = new MemoryStream())
            {
                result.Contents(stream);
                stream.Position = 0;
                using (var reader = new StreamReader(stream))
                {
                    content = reader.ReadToEnd();
                }
            }

            Assert.Equal(response.Body, content);
            mockHttpBodyContentMapper.Received(1).Convert(body: Arg.Any<object>(), headers: response.Headers);
        }
예제 #25
0
        public void Ctor1_WithBinaryBody_SetsBodyAndContent()
        {
            var body = new byte[] {1, 2, 3};

            var httpBodyContent = new HttpBodyContent(body, "application/octet-stream", Encoding.UTF8);

            Assert.Equal(body, httpBodyContent.Body);
            Assert.Equal(Encoding.UTF8.GetString(body), httpBodyContent.Content);
        }
        public void Convert_WithTheWorks_CorrectlyMappedHttpRequestMessageIsReturned()
        {
            const string encodingString = "utf-8";
            var encoding = Encoding.UTF8;
            const string contentTypeString = "application/json";
            const string bodyJson = "{\"Test\":\"tester\",\"Testing\":1}";

            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Get,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "Content-Type", contentTypeString + "; charset=" + encodingString },
                    { "X-Custom", "My Custom header" },
                    { "Content-Length", "10000" }, //This header is removed and replace with the correct value of 29
                },
                Body = new
                {
                    Test = "tester",
                    Testing = 1
                }
            };
            var httpBodyContent = new HttpBodyContent(bodyJson, contentTypeString, encoding);

            var mockHttpMethodMapper = Substitute.For<IHttpMethodMapper>();
            var mockHttpContentMapper = Substitute.For<IHttpContentMapper>();
            var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>();

            mockHttpMethodMapper.Convert(HttpVerb.Get).Returns(HttpMethod.Get);
            mockHttpContentMapper.Convert(httpBodyContent).Returns(new StringContent(bodyJson, encoding, contentTypeString));
            mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(httpBodyContent);

            IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper(
                mockHttpMethodMapper,
                mockHttpContentMapper,
                mockHttpBodyContentMapper);

            var result = mapper.Convert(request);
            var requestContent = result.Content.ReadAsStringAsync().Result;

            var contentTypeHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Type"));
            var customHeader = result.Headers.First(x => x.Key.Equals("X-Custom"));
            var contentLengthHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Length"));

            Assert.Equal(bodyJson, requestContent);

            //Content-Type header
            Assert.Equal(request.Headers.First().Key, contentTypeHeader.Key);
            Assert.Equal(request.Headers.First().Value, contentTypeHeader.Value.First());

            //X-Custom header
            Assert.Equal(request.Headers.Skip(1).First().Key, customHeader.Key);
            Assert.Equal(request.Headers.Skip(1).First().Value, customHeader.Value.First());

            //Content-Length header
            Assert.Equal(request.Headers.Last().Key, contentLengthHeader.Key);
            Assert.Equal("29", contentLengthHeader.Value.First());
        }
예제 #27
0
        public void Ctor2_WithBinaryContent_SetsBodyAndContent()
        {
            const string content = "LOL";
            var httpBodyContent = new HttpBodyContent(content, "application/octet-stream", Encoding.UTF8);

            Assert.Equal(content, httpBodyContent.Content);
            Assert.IsType<byte[]>(httpBodyContent.Body);
            Assert.Equal(new byte[] {76, 79, 76}, httpBodyContent.Body);
        }
        public void Convert_WithPlainContentTypeHeaderLowercased_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithContentType()
        {
            const string contentTypeString = "text/plain";
            var request = new ProviderServiceRequest
            {
                Method = HttpVerb.Post,
                Path = "/events",
                Headers = new Dictionary<string, string>
                {
                    { "content-type", contentTypeString }
                },
                Body = new { }
            };
            var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: contentTypeString, encoding: null);

            var mapper = GetSubject();

            _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post);
            _mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(httpBodyContent);

            var result = mapper.Convert(request);

            Assert.Empty(result.Headers);
            _mockHttpContentMapper.Received(1).Convert(httpBodyContent);
        }