Add IFileSystemHandler to support Azure for StaticMapping location (#180)

* wip * CustomStaticMappingFileHandler * Add unit-tests * Tests * IFileSystemHandler * version
2026-03-25 10:31:01 +01:00 · 2018-08-14 18:54:53 +02:00
parent c92e733ef9
commit 4b91c05fe7
21 changed files with 505 additions and 59 deletions
--- a/test/WireMock.Net.Tests/FluentMockServerTests.cs
+++ b/test/WireMock.Net.Tests/FluentMockServerTests.cs
@@ -7,6 +7,7 @@ using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using Moq;
 using NFluent;
 using WireMock.Matchers;
 using WireMock.RequestBuilders;
@@ -14,6 +15,10 @@ using WireMock.ResponseBuilders;
 using WireMock.Server;
 using Xunit;
 using Newtonsoft.Json;
+using WireMock.Handlers;
+using WireMock.Logging;
+using WireMock.Settings;
+using WireMock.Admin.Mappings;

 namespace WireMock.Net.Tests
 {
@@ -42,6 +47,35 @@ namespace WireMock.Net.Tests
            server2.Stop();
        }

+        [Fact]
+        public void FluentMockServer_SaveStaticMappings()
+        {
+            // Assign
+            string guid = "791a3f31-6946-aaaa-8e6f-0237c7441111";
+            var _staticMappingHandlerMock = new Mock<IFileSystemHandler>();
+            _staticMappingHandlerMock.Setup(m => m.GetMappingFolder()).Returns("folder");
+            _staticMappingHandlerMock.Setup(m => m.FolderExists(It.IsAny<string>())).Returns(true);
+            _staticMappingHandlerMock.Setup(m => m.WriteMappingFile(It.IsAny<string>(), It.IsAny<string>()));
+
+            _server = FluentMockServer.Start(new FluentMockServerSettings
+            {
+                FileSystemHandler = _staticMappingHandlerMock.Object
+            });
+
+            _server
+                .Given(Request.Create().WithPath($"/foo_{Guid.NewGuid()}"))
+                .WithGuid(guid)
+                .RespondWith(Response.Create().WithBody("save test"));
+
+            // Act
+            _server.SaveStaticMappings();
+
+            // Assert and Verify
+            _staticMappingHandlerMock.Verify(m => m.GetMappingFolder(), Times.Once);
+            _staticMappingHandlerMock.Verify(m => m.FolderExists("folder"), Times.Once);
+            _staticMappingHandlerMock.Verify(m => m.WriteMappingFile(Path.Combine("folder", guid + ".json"), It.IsAny<string>()), Times.Once);
+        }
+
        [Fact]
        public void FluentMockServer_ReadStaticMapping_WithNonGuidFilename()
        {
@@ -108,6 +142,49 @@ namespace WireMock.Net.Tests
            Check.That(mappings.First().Title).IsNullOrEmpty();
        }

+        [Fact]
+        public void FluentMockServer_ReadStaticMappings_FolderExistsIsTrue()
+        {
+            // Assign
+            var _staticMappingHandlerMock = new Mock<IFileSystemHandler>();
+            _staticMappingHandlerMock.Setup(m => m.GetMappingFolder()).Returns("folder");
+            _staticMappingHandlerMock.Setup(m => m.FolderExists(It.IsAny<string>())).Returns(true);
+            _staticMappingHandlerMock.Setup(m => m.EnumerateFiles(It.IsAny<string>())).Returns(new string[0]);
+
+            _server = FluentMockServer.Start(new FluentMockServerSettings
+            {
+                FileSystemHandler = _staticMappingHandlerMock.Object
+            });
+
+            // Act
+            _server.ReadStaticMappings();
+
+            // Assert and Verify
+            _staticMappingHandlerMock.Verify(m => m.GetMappingFolder(), Times.Once);
+            _staticMappingHandlerMock.Verify(m => m.FolderExists("folder"), Times.Once);
+            _staticMappingHandlerMock.Verify(m => m.EnumerateFiles("folder"), Times.Once);
+        }
+
+        [Fact]
+        public void FluentMockServer_ReadStaticMappingAndAddOrUpdate()
+        {
+            // Assign
+            string mapping = "{\"Request\": {\"Path\": {\"Matchers\": [{\"Name\": \"WildcardMatcher\",\"Pattern\": \"/static/mapping\"}]},\"Methods\": [\"get\"]},\"Response\": {\"BodyAsJson\": { \"body\": \"static mapping\" }}}";
+            var _staticMappingHandlerMock = new Mock<IFileSystemHandler>();
+            _staticMappingHandlerMock.Setup(m => m.ReadMappingFile(It.IsAny<string>())).Returns(mapping);
+
+            _server = FluentMockServer.Start(new FluentMockServerSettings
+            {
+                FileSystemHandler = _staticMappingHandlerMock.Object
+            });
+
+            // Act
+            _server.ReadStaticMappingAndAddOrUpdate(@"c:\test.json");
+
+            // Assert and Verify
+            _staticMappingHandlerMock.Verify(m => m.ReadMappingFile(@"c:\test.json"), Times.Once);
+        }
+
        [Fact]
        public void FluentMockServer_ReadStaticMappings()
        {
@@ -142,7 +219,7 @@ namespace WireMock.Net.Tests
            string guid = "90356dba-b36c-469a-a17e-669cd84f1f05";
            _server = FluentMockServer.Start();

-            _server.Given(Request.Create().WithPath("/foo1").UsingGet()).WithGuid(guid)
+            _server.Given(Request.Create().WithPath("/foo100").UsingGet()).WithGuid(guid)
                .RespondWith(Response.Create().WithStatusCode(201).WithBody("1"));

            var mappings = _server.Mappings.ToArray();
@@ -219,13 +296,14 @@ namespace WireMock.Net.Tests
        public async Task FluentMockServer_Should_respond_to_request_methodPatch()
        {
            // given
+            string path = $"/foo_{Guid.NewGuid()}";
            _server = FluentMockServer.Start();

-            _server.Given(Request.Create().WithPath("/foo").UsingMethod("patch"))
+            _server.Given(Request.Create().WithPath(path).UsingMethod("patch"))
                .RespondWith(Response.Create().WithBody("hello patch"));

            // when
-            var msg = new HttpRequestMessage(new HttpMethod("patch"), new Uri("http://localhost:" + _server.Ports[0] + "/foo"))
+            var msg = new HttpRequestMessage(new HttpMethod("patch"), new Uri("http://localhost:" + _server.Ports[0] + path))
            {
                Content = new StringContent("{\"data\": {\"attr\":\"value\"}}")
            };
@@ -338,13 +416,14 @@ namespace WireMock.Net.Tests
        public async Task FluentMockServer_Should_respond_to_request_bodyAsBytes()
        {
            // given
+            string path = $"/foo_{Guid.NewGuid()}";
            _server = FluentMockServer.Start();

-            _server.Given(Request.Create().WithPath("/foo").UsingGet()).RespondWith(Response.Create().WithBody(new byte[] { 48, 49 }));
+            _server.Given(Request.Create().WithPath(path).UsingGet()).RespondWith(Response.Create().WithBody(new byte[] { 48, 49 }));

            // when
-            var responseAsString = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
-            var responseAsBytes = await new HttpClient().GetByteArrayAsync("http://localhost:" + _server.Ports[0] + "/foo");
+            var responseAsString = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + path);
+            var responseAsBytes = await new HttpClient().GetByteArrayAsync("http://localhost:" + _server.Ports[0] + path);

            // then
            Check.That(responseAsString).IsEqualTo("01");
@@ -371,13 +450,14 @@ namespace WireMock.Net.Tests

            foreach (var item in validMatchersForHelloServerJsonMessage)
            {
+                string path = $"/foo_{Guid.NewGuid()}";
                _server
-                    .Given(Request.Create().WithPath("/foo").WithBody((IMatcher)item[0]))
+                    .Given(Request.Create().WithPath(path).WithBody((IMatcher)item[0]))
                    .RespondWith(Response.Create().WithBody("Hello client"));

                // Act
                var content = new StringContent(jsonRequestMessage, Encoding.UTF8, (string)item[1]);
-                var response = await new HttpClient().PostAsync("http://localhost:" + _server.Ports[0] + "/foo", content);
+                var response = await new HttpClient().PostAsync("http://localhost:" + _server.Ports[0] + path, content);

                // Assert
                var responseString = await response.Content.ReadAsStringAsync();
@@ -392,10 +472,11 @@ namespace WireMock.Net.Tests
        public async Task FluentMockServer_Should_respond_404_for_unexpected_request()
        {
            // given
+            string path = $"/foo{Guid.NewGuid()}";
            _server = FluentMockServer.Start();

            // when
-            var response = await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
+            var response = await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + path);

            // then
            Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.NotFound);
@@ -405,20 +486,21 @@ namespace WireMock.Net.Tests
        [Fact]
        public async Task FluentMockServer_Should_find_a_request_satisfying_a_request_spec()
        {
-            // given
+            // Assign
+            string path = $"/bar_{Guid.NewGuid()}";
            _server = FluentMockServer.Start();

            // when
            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
-            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/bar");
+            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + path);

            // then
            var result = _server.FindLogEntries(Request.Create().WithPath(new RegexMatcher("^/b.*"))).ToList();
            Check.That(result).HasSize(1);

            var requestLogged = result.First();
-            Check.That(requestLogged.RequestMessage.Path).IsEqualTo("/bar");
-            Check.That(requestLogged.RequestMessage.Url).IsEqualTo("http://localhost:" + _server.Ports[0] + "/bar");
+            Check.That(requestLogged.RequestMessage.Path).IsEqualTo(path);
+            Check.That(requestLogged.RequestMessage.Url).IsEqualTo("http://localhost:" + _server.Ports[0] + path);
        }

        [Fact]
@@ -439,11 +521,12 @@ namespace WireMock.Net.Tests
        public void FluentMockServer_Should_reset_mappings()
        {
            // given
+            string path = $"/foo_{Guid.NewGuid()}";
            _server = FluentMockServer.Start();

            _server
                .Given(Request.Create()
-                    .WithPath("/foo")
+                    .WithPath(path)
                    .UsingGet())
                .RespondWith(Response.Create()
                    .WithBody(@"{ msg: ""Hello world!""}"));
@@ -453,35 +536,38 @@ namespace WireMock.Net.Tests

            // then
            Check.That(_server.Mappings).IsEmpty();
-            Check.ThatAsyncCode(() => new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo"))
+            Check.ThatAsyncCode(() => new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + path))
                .ThrowsAny();
        }

        [Fact]
        public async Task FluentMockServer_Should_respond_a_redirect_without_body()
        {
-            // given
+            // Assign
+            string path = $"/foo_{Guid.NewGuid()}";
+            string pathToRedirect = $"/bar_{Guid.NewGuid()}";
+
            _server = FluentMockServer.Start();

            _server
                .Given(Request.Create()
-                    .WithPath("/foo")
+                    .WithPath(path)
                    .UsingGet())
                .RespondWith(Response.Create()
                    .WithStatusCode(307)
-                    .WithHeader("Location", "/bar"));
+                    .WithHeader("Location", pathToRedirect));
            _server
                .Given(Request.Create()
-                    .WithPath("/bar")
+                    .WithPath(pathToRedirect)
                    .UsingGet())
                .RespondWith(Response.Create()
                    .WithStatusCode(200)
                    .WithBody("REDIRECT SUCCESSFUL"));

-            // when
-            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
+            // Act
+            var response = await new HttpClient().GetStringAsync($"http://localhost:{_server.Ports[0]}{path}");

-            // then
+            // Assert
            Check.That(response).IsEqualTo("REDIRECT SUCCESSFUL");
        }

--- a/test/WireMock.Net.Tests/StatefulBehaviorTests.cs
+++ b/test/WireMock.Net.Tests/StatefulBehaviorTests.cs
@@ -1,4 +1,5 @@
-using System.Linq;
+using System;
+using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
@@ -16,16 +17,17 @@ namespace WireMock.Net.Tests
        public async Task Scenarios_Should_skip_non_relevant_states()
        {
            // given
+            string path = $"/foo_{Guid.NewGuid()}";
            var server = FluentMockServer.Start();

            server
-                .Given(Request.Create().WithPath("/foo").UsingGet())
+                .Given(Request.Create().WithPath(path).UsingGet())
                .InScenario("s")
                .WhenStateIs("Test state")
                .RespondWith(Response.Create());

            // when
-            var response = await new HttpClient().GetAsync("http://localhost:" + server.Ports[0] + "/foo");
+            var response = await new HttpClient().GetAsync("http://localhost:" + server.Ports[0] + path);

            // then
            Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.NotFound);
@@ -37,23 +39,24 @@ namespace WireMock.Net.Tests
        public async Task Scenarios_Should_process_request_if_equals_state_and_single_state_defined()
        {
            // given
+            string path = $"/foo_{Guid.NewGuid()}";
            var server = FluentMockServer.Start();

            server
-                .Given(Request.Create().WithPath("/foo").UsingGet())
+                .Given(Request.Create().WithPath(path).UsingGet())
                .InScenario("s")
                .WillSetStateTo("Test state")
                .RespondWith(Response.Create().WithBody("No state msg"));

            server
-                .Given(Request.Create().WithPath("/foo").UsingGet())
+                .Given(Request.Create().WithPath(path).UsingGet())
                .InScenario("s")
                .WhenStateIs("Test state")
                .RespondWith(Response.Create().WithBody("Test state msg"));

            // when
-            var responseNoState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/foo");
-            var responseWithState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/foo");
+            var responseNoState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path);
+            var responseWithState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path);

            // then
            Check.That(responseNoState).Equals("No state msg");
--- a/test/WireMock.Net.Tests/Util/FileHelperTests.cs
+++ b/test/WireMock.Net.Tests/Util/FileHelperTests.cs
@@ -0,0 +1,44 @@
+using System;
+using System.IO;
+using Moq;
+using NFluent;
+using WireMock.Handlers;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.Util
+{
+    public class FileHelperTests
+    {
+        [Fact]
+        public void FileHelper_ReadAllTextWithRetryAndDelay()
+        {
+            // Assign
+            var _staticMappingHandlerMock = new Mock<IFileSystemHandler>();
+            _staticMappingHandlerMock.Setup(m => m.ReadMappingFile(It.IsAny<string>())).Returns("text");
+
+            // Act
+            string result = FileHelper.ReadAllTextWithRetryAndDelay(_staticMappingHandlerMock.Object, @"c:\temp");
+
+            // Assert
+            Check.That(result).Equals("text");
+
+            // Verify
+            _staticMappingHandlerMock.Verify(m => m.ReadMappingFile(@"c:\temp"), Times.Once);
+        }
+
+        [Fact]
+        public void FileHelper_ReadAllTextWithRetryAndDelay_Throws()
+        {
+            // Assign
+            var _staticMappingHandlerMock = new Mock<IFileSystemHandler>();
+            _staticMappingHandlerMock.Setup(m => m.ReadMappingFile(It.IsAny<string>())).Throws<NotSupportedException>();
+
+            // Act
+            Check.ThatCode(() => FileHelper.ReadAllTextWithRetryAndDelay(_staticMappingHandlerMock.Object, @"c:\temp")).Throws<IOException>();
+
+            // Verify
+            _staticMappingHandlerMock.Verify(m => m.ReadMappingFile(@"c:\temp"), Times.Exactly(3));
+        }
+    }
+}