All arg params are now switches, re-added integration tests

Author: Andrioden

README.md

@@ -5,17 +5,22 @@ The [end user documentation](netmockery/documentation.md) is a work in progress.
 [![Build Status](https://travis-ci.org/codeape2/netmockery.svg?branch=master)](https://travis-ci.org/codeape2/netmockery)
 
 
-BUILDING AND TESTING
+TESTING
 ====================
+```
+dotnet test .\netmockery.sln
+```
 
 
+RUNNING
+====================
 ```
-dotnet test .\netmockery.sln
+dotnet run --project .\netmockery\netmockery.csproj --command web --endpoints C:\Projects\NHN\Helsenorge\Test\netmockery_config\helsenorge_endpoints --urls http://*:9876
 ```
 
+
 DEPLOYMENT PACKAGES
 ===================
-
 ```
 dotnet publish .\netmockery.sln
 ```

UnitTests/TestCommandLineParser.cs

@@ -1,63 +1,63 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using netmockery;
+using netmockery;
 using Xunit;
 
 using static netmockery.CommandLineParser;
 
 
-
 namespace UnitTests
 {
     public class TestCommandLineParser
     {
         [Fact]
-        public void ParsesWithNoCommand()
+        public void WebCommand()
         {
-            var result = ParseArguments(new[] { "c:\\dir\\foo" });
-
-            Assert.Equal(COMMAND_NORMAL, result.Command);
-            Assert.Equal("c:\\dir\\foo", result.EndpointCollectionDirectory);
+            var result = ParseArguments(new[] { "--command", "web", "--endpoints", "c:\\dir\\foo" });
+            Assert.Equal(COMMAND_WEB, result.Command);
+            Assert.Equal("c:\\dir\\foo", result.Endpoints);
             Assert.Null(result.Urls);
         }
 
         [Fact]
-        public void NormalNoTestMode()
+        public void WebCommandNoTestMode()
         {
-            var result = ParseArguments(new[] { "c:\\dir\\foo", "--notestmode" });
-            Assert.Equal(COMMAND_NORMAL, result.Command);
-            Assert.Equal("c:\\dir\\foo", result.EndpointCollectionDirectory);
+            var result = ParseArguments(new[] { "--command", "web", "--endpoints", "c:\\dir\\foo", "--notestmode" });
+            Assert.Equal(COMMAND_WEB, result.Command);
+            Assert.Equal("c:\\dir\\foo", result.Endpoints);
             Assert.True(result.NoTestMode);
 
         }
 
         [Fact]
-        public void NormalExecutionCanHaveUrl()
+        public void WebCommandWithUrls()
         {
-            var result = ParseArguments(new[] { "c:\\dir\\foo", "--urls", "http://*:5000" });
-            Assert.Equal(COMMAND_NORMAL, result.Command);
-            Assert.Equal("c:\\dir\\foo", result.EndpointCollectionDirectory);
+            var result = ParseArguments(new[] { "--command", "web", "--endpoints", "c:\\dir\\foo", "--urls", "http://*:5000" });
+            Assert.Equal(COMMAND_WEB, result.Command);
+            Assert.Equal("c:\\dir\\foo", result.Endpoints);
             Assert.Equal("http://*:5000", result.Urls);
         }
 
         [Fact]
-        public void MissingEndpointDirectoryGivesError()
+        public void MissingCommand()
         {
-            AssertGivesException("No endpoint directory specified", new string[0]);
+            AssertGivesException("Missing required switch --command", new[] { "--endpoints", "c:\\foo\\bar" });
         }
 
         [Fact]
         public void UnknownCommand()
         {
-            AssertGivesException("Unknown command 'foobar'", new[] { "c:\\foo\\bar", "foobar" });
+            AssertGivesException("Unknown command 'foobar'", new[] { "--command", "foobar", "--endpoints", "c:\\foo\\bar" });
+        }
+
+        [Fact]
+        public void MissingEndpoints()
+        {
+            AssertGivesException("Missing required switch --endpoints", new[] { "--command", "web" });
         }
 
         [Fact]
         public void TestCommand()
         {
-            var result = ParseArguments(new[] { "c:\\dir\\foo", "test" });
+            var result = ParseArguments(new[] { "--command", "test", "--endpoints", "c:\\dir\\foo" });
             Assert.Equal(COMMAND_TEST, result.Command);
             Assert.False(result.ShowResponse);
             Assert.Null(result.Only);
@@ -66,7 +66,7 @@ public void TestCommand()
         [Fact]
         public void TestCommandWithOptions()
         {
-            var result = ParseArguments(new[] { "c:\\dir\\foo", "test", "--only", "1", "--showResponse" });
+            var result = ParseArguments(new[] { "--command", "test", "--endpoints", "c:\\dir\\foo", "--only", "1", "--showResponse" });
             Assert.Equal(COMMAND_TEST, result.Command);
             Assert.Equal("1", result.Only);
             Assert.True(result.ShowResponse);
@@ -76,7 +76,7 @@ public void TestCommandWithOptions()
         [Fact]
         public void TestWithStopOption()
         {
-            var result = ParseArguments(new[] { "c:\\dir\\foo", "test", "--stop" });
+            var result = ParseArguments(new[] { "--command", "test", "--endpoints", "c:\\dir\\foo", "--stop" });
             Assert.Equal(COMMAND_TEST, result.Command);
             Assert.Null(result.Only);
             Assert.False(result.ShowResponse);
@@ -86,22 +86,22 @@ public void TestWithStopOption()
         [Fact]
         public void DumpCommand()
         {
-            var result = ParseArguments(new[] { "c:\\foo\\bar", "dump" });
+            var result = ParseArguments(new[] { "--command", "dump", "--endpoints", "c:\\foo\\bar" });
             Assert.Equal(COMMAND_DUMP, result.Command);
-            Assert.Equal("c:\\foo\\bar", result.EndpointCollectionDirectory);
+            Assert.Equal("c:\\foo\\bar", result.Endpoints);
         }
 
         [Fact]
         public void InvalidArgumentsForDumpCommand()
         {
-            AssertGivesException("'--only' is not a valid argument for the 'dump' command", new[] { "c:\\foo\\bar", "dump", "--only", "2" });
-            AssertGivesException("'--urls' is not a valid argument for the 'dump' command", new[] { "c:\\foo\\bar", "dump", "--urls", "http://localhost:5000/" });
+            AssertGivesException("'--only' is not a valid argument for the 'dump' command", new[] { "--command", "dump", "--endpoints", "c:\\foo\\bar", "--only", "2" });
+            AssertGivesException("'--urls' is not a valid argument for the 'dump' command", new[] { "--command", "dump", "--endpoints", "c:\\foo\\bar", "--urls", "http://localhost:5000/" });
         }
 
         [Fact]
-        public void InvalidArgumentsForNormalCommand()
+        public void InvalidArgumentsForWebCommand()
         {
-            AssertGivesException("'--only' is not a valid argument", new[] { "c:\\foo\\bar", "--only", "2" });
+            AssertGivesException("'--only' is not a valid argument for the 'web' command", new[] { "--command", "web", "--endpoints", "c:\\foo\\bar", "--only", "2" });
         }
 
         private void AssertGivesException(string expectedMessage, string[] args)

UnitTests/TestReloadWorks.cs

@@ -0,0 +1,72 @@
+using Microsoft.AspNetCore.Mvc.Testing;
+using netmockery;
+using Newtonsoft.Json;
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace UnitTests
+{
+    public class TestReloadWorks : IDisposable
+    {
+        private readonly DirectoryCreator _dc;
+        private readonly HttpClient _client;
+
+        public TestReloadWorks()
+        {
+            _dc = new DirectoryCreator();
+            _dc.AddFile(
+                "endpoint1/endpoint.json",
+                JsonConvert.SerializeObject(DataUtils.CreateSimpleEndpoint("foobar", "myfile.txt"))
+            );
+            _dc.AddFile("endpoint1/myfile.txt", "Hello world");
+            var ecp = new EndpointCollectionProvider(_dc.DirectoryName);
+
+            var factory = new CustomWebApplicationFactory<Program>(ecp);
+            _client = factory.CreateClient(new WebApplicationFactoryClientOptions
+            {
+                AllowAutoRedirect = false,
+            });
+        }
+
+        public void Dispose()
+        {
+            _dc.Dispose();
+        }
+
+        [Fact]
+        public async Task CanListEndpointnames()
+        {
+            Assert.Equal(new[] { "foobar" }, await GetEndpointNames());
+        }
+
+        [Fact]
+        public async Task NewEndpointIsAvailableAfterReload()
+        {
+            Assert.Equal(new[] { "foobar" }, await GetEndpointNames());
+
+            _dc.AddFile(
+                "endpoint2/endpoint.json",
+                JsonConvert.SerializeObject(DataUtils.CreateSimpleEndpoint("baz", "myfile.txt"))
+            );
+            _dc.AddFile("endpoint2/myfile.txt", "Hello world");
+
+            Assert.Equal(new[] { "foobar" }, await GetEndpointNames());
+
+            var response = await _client.GetAsync("/__netmockery/endpoints/reloadconfig");
+            Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
+
+            Assert.Equal(new[] { "baz", "foobar" }, await GetEndpointNames());
+        }
+
+        private async Task<string[]> GetEndpointNames()
+        {
+            var response = await _client.GetAsync("/__netmockery/endpoints/endpointnames");
+            response.EnsureSuccessStatusCode();
+            return (from arrayitem in JsonConvert.DeserializeObject<string[]>(await response.Content.ReadAsStringAsync()) orderby arrayitem select arrayitem).ToArray();
+        }
+    }
+}

UnitTests/TestResponseHasCorrectEncoding.cs

@@ -0,0 +1,87 @@
+using Microsoft.AspNetCore.Mvc.Testing;
+using netmockery;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace UnitTests
+{
+    public class TestResponseHasCorrectEncoding : IDisposable
+    {
+        private readonly DirectoryCreator _dc;
+        private readonly HttpClient _client;
+
+        public TestResponseHasCorrectEncoding()
+        {
+            _dc = new DirectoryCreator();
+            _dc.AddFile("endpoint1/endpoint.json", JsonConvert.SerializeObject(DataUtils.CreateSimpleEndpoint("endpoint1", "myfile.txt", "/endpoint1")));
+            _dc.AddFile("endpoint1/myfile.txt", "æøå");
+
+            var endpoint2 = DataUtils.CreateSimpleEndpoint("endpoint2", "myfile.txt", "/endpoint2");
+            endpoint2.responses[0].charset = "latin1";
+            _dc.AddFile("endpoint2/endpoint.json", JsonConvert.SerializeObject(endpoint2));
+            _dc.AddFile("endpoint2/myfile.txt", "æøå");
+            var tests = new List<JSONTest>(new[] {
+                new JSONTest { name = "Test endpoint1", requestpath = "/endpoint1", expectedresponsebody = "æøå" }
+            });
+            _dc.AddFile("tests/tests.json", JsonConvert.SerializeObject(tests));
+
+            var ecp = new EndpointCollectionProvider(_dc.DirectoryName);
+
+            var factory = new CustomWebApplicationFactory<Program>(ecp);
+            _client = factory.CreateClient(new WebApplicationFactoryClientOptions
+            {
+                AllowAutoRedirect = false,
+            });
+        }
+
+        public void Dispose()
+        {
+            _dc.Dispose();
+        }
+
+        [Fact]
+        async public Task ResponseHasUtf8EncodingIfNotConfigured()
+        {
+            var response = await _client.GetAsync("/endpoint1");
+            var bytes = await response.Content.ReadAsByteArrayAsync();
+            Assert.Equal("æøå", DecodeUtf8(bytes));
+            Assert.NotEqual("æøå", DecodeLatin1(bytes));
+        }
+
+        private string DecodeLatin1(byte[] bytes)
+        {
+            return Encoding.GetEncoding("ISO-8859-1").GetString(bytes);
+        }
+
+        private string DecodeUtf8(byte[] bytes)
+        {
+            return Encoding.UTF8.GetString(bytes);
+        }
+
+        [Fact]
+        async public Task ResponseCanBeLatin1IfConfigured()
+        {
+            var response = await _client.GetAsync("/endpoint2");
+            var bytes = await response.Content.ReadAsByteArrayAsync();
+            Assert.Equal("æøå", DecodeLatin1(bytes));
+            Assert.NotEqual("æøå", DecodeUtf8(bytes));
+        }
+
+        [Fact]
+        async public Task ResponseHasCharsetInHeader()
+        {
+            var response = await _client.GetAsync("/endpoint1");
+            Assert.Equal("text/plain", response.Content.Headers.ContentType.MediaType);
+            Assert.Equal("utf-8", response.Content.Headers.ContentType.CharSet);
+
+            response = await _client.GetAsync("/endpoint2");
+            Assert.Equal("text/plain", response.Content.Headers.ContentType.MediaType);
+            Assert.Equal("iso-8859-1", response.Content.Headers.ContentType.CharSet);
+        }
+    }
+}

UnitTests/UnitTests.csproj

@@ -5,6 +5,7 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.14" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
   </ItemGroup>

UnitTests/WebTestBase.cs

@@ -0,0 +1,29 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using netmockery;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+
+namespace UnitTests
+{
+    public class CustomWebApplicationFactory<TProgram> : WebApplicationFactory<TProgram> where TProgram : class
+    {
+        private EndpointCollectionProvider _endpointCollectionProvider;
+
+        public CustomWebApplicationFactory(EndpointCollectionProvider endpointCollectionProvider) : base()
+        {
+            _endpointCollectionProvider = endpointCollectionProvider;
+        }
+
+        protected override void ConfigureWebHost(IWebHostBuilder builder)
+        {
+            builder.UseSetting("command", "web");
+            builder.UseSetting("endpoints", ".."); // EndpointCollectionProvider is mocked anyway
+
+            builder.ConfigureServices(services =>
+            {
+                services.AddTransient(serviceProvider => _endpointCollectionProvider);
+            });
+        }
+    }
+}