Increase code coverage (#107)

2026-05-28 10:49:14 +02:00 · 2018-03-13 22:04:43 +01:00
parent 83d71bb24e
commit c2183ab40c
24 changed files with 1215 additions and 628 deletions
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using NFluent;
+using WireMock.ResponseBuilders;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.ResponseBuilderTests
+{
+    public class ResponseWithBodyHandlebarsTests
+    {
+        private const string ClientIp = "::1";
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_WithBodyAsJson()
+        {
+            // given
+            string jsonString = "{ \"things\": [ { \"name\": \"RequiredThing\" }, { \"name\": \"Wiremock\" } ] }";
+            var bodyData = new BodyData
+            {
+                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                Encoding = Encoding.UTF8
+            };
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, bodyData);
+
+            var response = Response.Create()
+                .WithBodyAsJson(new { x = "test {{request.url}}" })
+                .WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(JsonConvert.SerializeObject(responseMessage.BodyAsJson)).Equals("{\"x\":\"test http://localhost/foo\"}");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_UrlPathVerb()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create()
+                .WithBody("test {{request.url}} {{request.path}} {{request.method}}")
+                .WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test http://localhost/foo /foo post");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_Query()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo?a=1&a=2&b=5"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create()
+                .WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
+                .WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test keya=1 idx=1 idx=2 keyb=5");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_Header()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
+
+            var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}").WithBody("test").WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test");
+            Check.That(responseMessage.Headers).ContainsKey("x");
+            Check.That(responseMessage.Headers["x"]).ContainsExactly("text/plain");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_Headers()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
+
+            var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}", "{{request.url}}").WithBody("test").WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test");
+            Check.That(responseMessage.Headers).ContainsKey("x");
+            Check.That(responseMessage.Headers["x"]).Contains("text/plain");
+            Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_Origin_Port_Protocol_Host()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost:1234"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create()
+                .WithBody("test {{request.origin}} {{request.port}} {{request.protocol}} {{request.host}}")
+                .WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test http://localhost:1234 1234 http localhost");
+        }
+    }
+}
@@ -0,0 +1,145 @@
+using System;
+using System.Text;
+using System.Threading.Tasks;
+using NFluent;
+using WireMock.ResponseBuilders;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.ResponseBuilderTests
+{
+    public class ResponseWithBodyTests
+    {
+        private const string ClientIp = "::1";
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithBody_Bytes_Encoding_Destination_String()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.String, Encoding.ASCII);
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("01");
+            Check.That(responseMessage.BodyAsBytes).IsNull();
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithBody_Bytes_Encoding_Destination_Bytes()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.SameAsSource, Encoding.ASCII);
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.BodyAsBytes).ContainsExactly(new byte[] { 48, 49 });
+            Check.That(responseMessage.Body).IsNull();
+            Check.That(responseMessage.BodyEncoding).IsNull();
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithBody_String_Encoding()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create().WithBody("test", null, Encoding.ASCII);
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test");
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithBody_Object_Encoding()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", ClientIp, body, bodyAsString, Encoding.UTF8);
+
+            object x = new { value = "test" };
+            var response = Response.Create().WithBodyAsJson(x, Encoding.ASCII);
+
+            // act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // then
+            Check.That(responseMessage.BodyAsJson).IsNotNull();
+            Check.That(responseMessage.BodyAsJson).Equals(x);
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithBody_String_SameAsSource_Encoding()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost"), "GET", ClientIp);
+
+            var response = Response.Create().WithBody("r", BodyDestinationFormat.SameAsSource, Encoding.ASCII);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.BodyAsBytes).IsNull();
+            Check.That(responseMessage.BodyAsJson).IsNull();
+            Check.That(responseMessage.Body).Equals("r");
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithBody_String_Bytes_Encoding()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost"), "GET", ClientIp);
+
+            var response = Response.Create().WithBody("r", BodyDestinationFormat.Bytes, Encoding.ASCII);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.Body).IsNull();
+            Check.That(responseMessage.BodyAsJson).IsNull();
+            Check.That(responseMessage.BodyAsBytes).IsNotNull();
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithBody_String_Json_Encoding()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost"), "GET", ClientIp);
+
+            var response = Response.Create().WithBody("{ \"value\": 42 }", BodyDestinationFormat.Json, Encoding.ASCII);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.Body).IsNull();
+            Check.That(responseMessage.BodyAsBytes).IsNull();
+            Check.That(((dynamic) responseMessage.BodyAsJson).value).Equals(42);
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+    }
+}
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NFluent;
+using WireMock.ResponseBuilders;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.ResponseBuilderTests
+{
+    public class ResponseWithHeadersTests
+    {
+        private const string ClientIp = "::1";
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithHeaders_SingleValue()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost"), "GET", ClientIp);
+            var headers = new Dictionary<string, string> { { "h", "x" } };
+            var response = Response.Create().WithHeaders(headers);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithHeaders_MultipleValues()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost"), "GET", ClientIp);
+            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+            var response = Response.Create().WithHeaders(headers);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_WithHeaders_WiremockList()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost"), "GET", ClientIp);
+            var headers = new Dictionary<string, WireMockList<string>> { { "h", new WireMockList<string>("x") } };
+            var response = Response.Create().WithHeaders(headers);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
+        }
+    }
+}