Feat/monorepo (#734)

* copied everything from repos back to ocelot repo

* added src projects to sln

* removed all test projects that have no tests

* added all test projects to sln

* removed test not on master

* merged unit tests

* merged acceptance tests

* merged integration tests

* fixed namepaces

* build script creates packages for all projects

* updated docs to make sure no references to external repos that we will remove

* +semver: breaking

test/Ocelot.UnitTests/Rafty/OcelotAdministrationBuilderExtensionsTests.cs

@@ -0,0 +1,78 @@
+namespace Ocelot.UnitTests.Rafty
+{
+    using System;
+    using System.Collections.Generic;
+    using Microsoft.AspNetCore.Hosting;
+    using Microsoft.AspNetCore.Hosting.Internal;
+    using Microsoft.Extensions.Configuration;
+    using Microsoft.Extensions.DependencyInjection;
+    using Ocelot.Administration;
+    using Ocelot.DependencyInjection;
+    using Provider.Rafty;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class OcelotAdministrationBuilderExtensionsTests
+    {
+        private readonly IServiceCollection _services;
+        private IServiceProvider _serviceProvider;
+        private readonly IConfiguration _configRoot;
+        private IOcelotBuilder _ocelotBuilder;
+        private Exception _ex;
+
+        public OcelotAdministrationBuilderExtensionsTests()
+        {
+            _configRoot = new ConfigurationRoot(new List<IConfigurationProvider>());
+            _services = new ServiceCollection();
+            _services.AddSingleton<IHostingEnvironment, HostingEnvironment>();
+            _services.AddSingleton(_configRoot);
+        }
+
+        [Fact]
+        public void should_set_up_rafty()
+        {
+            this.Given(x => WhenISetUpOcelotServices())
+                .When(x => WhenISetUpRafty())
+                .Then(x => ThenAnExceptionIsntThrown())
+                .Then(x => ThenTheCorrectAdminPathIsRegitered())
+                .BDDfy();
+        }
+
+        private void WhenISetUpRafty()
+        {
+            try
+            {
+                _ocelotBuilder.AddAdministration("/administration", "secret").AddRafty();
+            }
+            catch (Exception e)
+            {
+                _ex = e;
+            }
+        }
+
+        private void WhenISetUpOcelotServices()
+        {
+            try
+            {
+                _ocelotBuilder = _services.AddOcelot(_configRoot);
+            }
+            catch (Exception e)
+            {
+                _ex = e;
+            }
+        }
+
+        private void ThenAnExceptionIsntThrown()
+        {
+            _ex.ShouldBeNull();
+        }
+
+        private void ThenTheCorrectAdminPathIsRegitered()
+        {
+            _serviceProvider = _services.BuildServiceProvider();
+            var path = _serviceProvider.GetService<IAdministrationPath>();
+            path.Path.ShouldBe("/administration");
+        }
+    }
+}

test/Ocelot.UnitTests/Rafty/OcelotFiniteStateMachineTests.cs

@@ -0,0 +1,45 @@
+namespace Ocelot.UnitTests.Rafty
+{
+    using Moq;
+    using Ocelot.Configuration.Setter;
+    using Provider.Rafty;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class OcelotFiniteStateMachineTests
+    {
+        private UpdateFileConfiguration _command;
+        private readonly OcelotFiniteStateMachine _fsm;
+        private readonly Mock<IFileConfigurationSetter> _setter;
+
+        public OcelotFiniteStateMachineTests()
+        {
+            _setter = new Mock<IFileConfigurationSetter>();
+            _fsm = new OcelotFiniteStateMachine(_setter.Object);
+        }
+
+        [Fact]
+        public void should_handle_update_file_configuration_command()
+        {
+            this.Given(x => GivenACommand(new UpdateFileConfiguration(new Ocelot.Configuration.File.FileConfiguration())))
+                .When(x => WhenTheCommandIsHandled())
+                .Then(x => ThenTheStateIsUpdated())
+                .BDDfy();
+        }
+
+        private void GivenACommand(UpdateFileConfiguration command)
+        {
+            _command = command;
+        }
+
+        private void WhenTheCommandIsHandled()
+        {
+            _fsm.Handle(new global::Rafty.Log.LogEntry(_command, _command.GetType(), 0)).Wait();
+        }
+
+        private void ThenTheStateIsUpdated()
+        {
+            _setter.Verify(x => x.Set(_command.Configuration), Times.Once);
+        }
+    }
+}

test/Ocelot.UnitTests/Rafty/RaftyFileConfigurationSetterTests.cs

@@ -0,0 +1,52 @@
+namespace Ocelot.UnitTests.Rafty
+{
+    using System.Threading.Tasks;
+    using global::Rafty.Concensus.Node;
+    using global::Rafty.Infrastructure;
+    using Moq;
+    using Ocelot.Configuration.File;
+    using Provider.Rafty;
+    using Shouldly;
+    using Xunit;
+
+    public class RaftyFileConfigurationSetterTests
+    {
+        private readonly RaftyFileConfigurationSetter _setter;
+        private readonly Mock<INode> _node;
+
+        public RaftyFileConfigurationSetterTests()
+        {
+            _node = new Mock<INode>();
+            _setter = new RaftyFileConfigurationSetter(_node.Object);
+        }
+
+        [Fact]
+        public async Task should_return_ok()
+        {
+            var fileConfig = new FileConfiguration();
+
+            var response = new OkResponse<UpdateFileConfiguration>(new UpdateFileConfiguration(fileConfig));
+
+            _node.Setup(x => x.Accept(It.IsAny<UpdateFileConfiguration>()))
+                .ReturnsAsync(response);
+
+            var result = await _setter.Set(fileConfig);
+            result.IsError.ShouldBeFalse();
+        }
+
+        [Fact]
+        public async Task should_return_not_ok()
+        {
+            var fileConfig = new FileConfiguration();
+
+            var response = new ErrorResponse<UpdateFileConfiguration>("error", new UpdateFileConfiguration(fileConfig));
+
+            _node.Setup(x => x.Accept(It.IsAny<UpdateFileConfiguration>()))
+                .ReturnsAsync(response);
+
+            var result = await _setter.Set(fileConfig);
+
+            result.IsError.ShouldBeTrue();
+        }
+    }
+}