New test options: expectedcharset and expectedcontenttype

Author: codeape2

UnitTests/TestTestCommand.cs

@@ -31,6 +31,7 @@ public static class TESTCOMMAND_CONSTANTS
             'match': {},
             'script': 'myscript.csscript',
             'contenttype': 'text/xml',
+            'charset': 'ascii',
             'replacements': [
                 {'search': 'a', 'replace': 'b'},
                 {'search': 'foo', 'replace': 'bar'}
@@ -292,6 +293,68 @@ async public void CanCheckExpectedRequestMatcherSuccess()
             Assert.True(result.OK);
         }
 
+        [Fact]
+        async public Task CanCheckExpectedContentTypeSuccess()
+        {
+            var testcase =
+                (new JSONTest { name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcontenttype = "text/xml" })
+                .Validated().CreateTestCase(".");
+
+            Assert.True(testcase.HasExpectations);
+            Assert.True(testcase.NeedsResponseBody);
+            Assert.Equal("text/xml", testcase.ExpectedContentType);
+
+            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
+            Assert.True(result.OK);
+        }
+
+        [Fact]
+        async public Task CanCheckExpectedContentTypeError()
+        {
+            var testcase =
+                (new JSONTest { name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcontenttype = "text/plain" })
+                .Validated().CreateTestCase(".");
+
+            Assert.Equal("text/plain", testcase.ExpectedContentType);
+
+            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
+            Assert.Null(result.Exception);
+            Assert.True(result.Error);            
+            Assert.Equal("Expected contenttype: 'text/plain'\nActual: 'text/xml'", result.Message);
+        }
+
+        [Fact]
+        async public Task CanCheckExpectedCharSetSuccess()
+        {
+            var testcase =
+                (new JSONTest { name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcharset = "us-ascii" })
+                .Validated().CreateTestCase(".");
+
+            Assert.True(testcase.HasExpectations);
+            Assert.True(testcase.NeedsResponseBody);
+            Assert.Equal("us-ascii", testcase.ExpectedCharSet);
+
+            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
+            Assert.Null(result.Exception);
+            Assert.Equal(null, result.Message);
+            Assert.True(result.OK);
+        }
+
+        [Fact]
+        async public Task CanCheckExpectedCharSetError()
+        {
+            var testcase =
+                (new JSONTest { name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcharset = "utf-8" })
+                .Validated().CreateTestCase(".");
+
+            Assert.Equal("utf-8", testcase.ExpectedCharSet);
+
+            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
+            Assert.Null(result.Exception);
+            Assert.True(result.Error);
+            Assert.Equal("Expected charset: 'utf-8'\nActual: 'us-ascii'", result.Message);
+        }
+
         [Fact]
         public void CanGetResultBody()
         {

netmockery/JSONReader.cs

@@ -27,6 +27,8 @@ public class JSONTest
         public string expectedrequestmatcher;
         public string expectedresponsecreator;
         public string expectedresponsebody;
+        public string expectedcontenttype;
+        public string expectedcharset;
 
         public JSONTest Validated()
         {
@@ -58,6 +60,8 @@ public NetmockeryTestCase CreateTestCase(string directory)
                 ExpectedRequestMatcher = expectedrequestmatcher,
                 ExpectedResponseCreator = expectedresponsecreator,
 
+                ExpectedContentType = expectedcontenttype,
+                ExpectedCharSet = expectedcharset,
                 ExpectedResponseBody = 
                     expectedresponsebody != null && expectedresponsebody.StartsWith("file:")
                     ? 

netmockery/NetmockeryTestCase.cs

@@ -80,28 +80,33 @@ public class NetmockeryTestCase
         public string ExpectedRequestMatcher;
         public string ExpectedResponseCreator;
 
+        public string ExpectedContentType;
+        public string ExpectedCharSet;
         public string ExpectedResponseBody;
 
         public bool NeedsResponseBody
         {
             get
             {
-                return (new[] { ExpectedResponseBody }).Any(val => val != null);
+                return (new[] { ExpectedResponseBody, ExpectedContentType, ExpectedCharSet }).Any(val => val != null);
             }
         }
 
         public bool HasExpectations
         {
             get
             {
-                return (new[] { ExpectedResponseBody, ExpectedRequestMatcher, ExpectedResponseCreator }).Any(val => val != null);
+                return (new[] { ExpectedResponseBody, ExpectedRequestMatcher, ExpectedResponseCreator, ExpectedContentType, ExpectedCharSet }).Any(val => val != null);
             }
         }
 
 
-        public bool Evaluate(string requestMatcher, string responseCreator, string responseBody, out string message)
+        public bool Evaluate(string requestMatcher, string responseCreator, string responseBody, string contentType, string charset, out string message)
         {
             Debug.Assert(responseBody != null || !NeedsResponseBody);
+            Debug.Assert(contentType != null || !NeedsResponseBody);
+            Debug.Assert(charset != null || !NeedsResponseBody);
+
             Debug.Assert(requestMatcher != null);
             Debug.Assert(responseCreator != null);
             message = null;
@@ -124,6 +129,18 @@ public bool Evaluate(string requestMatcher, string responseCreator, string respo
                 return false;
             }
 
+            if (ExpectedContentType != null && ExpectedContentType != contentType)
+            {
+                message = $"Expected contenttype: '{ExpectedContentType}'\nActual: '{contentType}'";
+                return false;
+            }
+
+            if (ExpectedCharSet != null && ExpectedCharSet != charset)
+            {
+                message = $"Expected charset: '{ExpectedCharSet}'\nActual: '{charset}'";
+                return false;
+            }
+
             Debug.Assert(message == null);
             return true;
         }
@@ -157,7 +174,15 @@ async public Task<NetmockeryTestCaseResult> ExecuteAgainstHttpClientAsync(HttpCl
             {
                 responseCreator = responseMessage.Headers.GetValues("X-Netmockery-ResponseCreator").ElementAt(0);
             }
-            if (Evaluate(requestMatcher, responseCreator, body, out message))
+            var contentType = "";
+            var charset = "";
+            if (responseMessage.Content.Headers.ContentType != null)
+            {
+                contentType = responseMessage.Content.Headers.ContentType.MediaType;
+                charset = responseMessage.Content.Headers.ContentType.CharSet;
+            }
+
+            if (Evaluate(requestMatcher, responseCreator, body, contentType, charset, out message))
             {
                 retval.SetSuccess();
             }
@@ -204,6 +229,8 @@ async public Task<NetmockeryTestCaseResult> ExecuteAsync(EndpointCollection endp
 
                 var responseCreator = matcher_and_creator.ResponseCreator;
                 string responseBody = null;
+                string charset = "";
+                string contenttype = "";
                 if (NeedsResponseBody)
                 {
                     var simpleResponseCreator = responseCreator as SimpleResponseCreator;
@@ -225,9 +252,11 @@ async public Task<NetmockeryTestCaseResult> ExecuteAsync(EndpointCollection endp
                         requestInfo.SetStaticNow(now.Value);
                     }
                     responseBody = simpleResponseCreator.GetBodyAndExecuteReplacements(requestInfo);
+                    contenttype = simpleResponseCreator.ContentType ?? "";
+                    charset = simpleResponseCreator.Encoding.WebName;
                 }
                 string message;
-                if (Evaluate(matcher_and_creator.RequestMatcher.ToString(), matcher_and_creator.ResponseCreator.ToString(), responseBody, out message))
+                if (Evaluate(matcher_and_creator.RequestMatcher.ToString(), matcher_and_creator.ResponseCreator.ToString(), responseBody, contenttype, charset, out message))
                 {
                     return testResult.SetSuccess();
                 }