Isolate Shared Test Code (#252)

The goal of this make sure that test code is correctly organized to ensure that test suites aren't dependent on each other.
* UnitTests get their own project now (renaming Microsoft.SqlTools.ServiceLayer.Test to Microsoft.SqlTools.ServiceLayer.UnitTests) which is about 90% of the changes to the files.
* IntegrationTests no longer depends on UnitTests, only Test.Common
* Any shared components from TestObjects that spins up a "live" connection has been moved to IntegrationTests Utility/LiveConnectionHelper.cs
* The dictionary-based mock file stream factory has been moved to Test.Common since it is used by UnitTests and IntegrationTests
    * Added a overload that doesn't take a dictionary for when we don't care about monitoring the storage (about 90% of the time)
* The RunIf* wrapper methods have been moved to Test.Common
* OwnerUri and StandardQuery constants have been moved to Test.Common Constants file

* Updating to latest SDK version available at https://www.microsoft.com/net/core#windowscmd

* Moving unit tests to unit test folder

* Changing namespaces to UnitTests

* Moving some constants and shared functionality into common project, making the UnitTests reference it

* Unit tests are working!

* Integration tests are working

* Updating automated test runs

* Fixing one last broken unit test

* Exposing internals for other projects

* Moving edit data tests to UnitTest project

* Applying refactor fixes to unit tests

* Fixing flaky test that wasn't awaiting completion

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Extensibility/ExtensionTests.cs

@@ -0,0 +1,87 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Composition;
+using System.Linq;
+using System.Reflection;
+using Microsoft.SqlTools.ServiceLayer.Extensibility;
+using Microsoft.SqlTools.ServiceLayer.Formatter;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
+{
+    public class ExtensionTests
+    {
+
+        [Fact]
+        public void CreateAssemblyStoreShouldFindTypesInAssembly()
+        {
+            // Given a store for MyExportType
+            ExtensionStore store = ExtensionStore.CreateAssemblyStore<MyExportType>(GetType().GetTypeInfo().Assembly);
+            // Then should get any export for this type and subtypes
+            Assert.Equal(2, store.GetExports<MyExportType>().Count());
+
+            // But for a different type, expect throw as the store only contains MyExportType
+            Assert.Throws<InvalidCastException>(() => store.GetExports<MyOtherType>().Count());
+        }
+        
+        [Fact]
+        public void CreateDefaultLoaderShouldFindTypesOnlyInMainAssembly()
+        {
+            // Given a store created using CreateDefaultLoader
+            // Then not should find exports from a different assembly
+            ExtensionStore store = ExtensionStore.CreateDefaultLoader<MyExportType>();
+            Assert.Equal(0, store.GetExports<MyExportType>().Count());
+
+            // And should not find exports that are defined in the ServiceLayer assembly
+            store = ExtensionStore.CreateDefaultLoader<ASTNodeFormatterFactory>();
+            Assert.Empty(store.GetExports<ASTNodeFormatterFactory>());            
+        }
+
+        [Fact]
+        public void CreateDefaultServiceProviderShouldFindTypesInAllKnownAssemblies()
+        {
+            // Given a default ExtensionServiceProvider
+            // Then we should not find exports from a test assembly
+            ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
+            Assert.Empty(serviceProvider.GetServices<MyExportType>());
+
+            // But should find exports that are defined in the main assembly            
+            Assert.NotEmpty(serviceProvider.GetServices<ASTNodeFormatterFactory>());
+        }
+
+        [Fact]
+        public void CreateStoreForCurrentDirectoryShouldFindExportsInDirectory()
+        {
+            // Given stores created for types in different assemblies
+            ExtensionStore myStore = ExtensionStore.CreateStoreForCurrentDirectory<MyExportType>();
+            ExtensionStore querierStore = ExtensionStore.CreateStoreForCurrentDirectory<ASTNodeFormatterFactory>();
+
+            // When I query exports
+            // Then exports for all assemblies should be found
+            Assert.Equal(2, myStore.GetExports<MyExportType>().Count());
+            Assert.NotEmpty(querierStore.GetExports<ASTNodeFormatterFactory>());
+        }        
+    }
+
+    // Note: in order for the MEF lookup to succeed, one class must have 
+    [Export(typeof(MyExportType))]
+    public class MyExportType
+    {
+
+    }
+    
+    public class MyExportSubType : MyExportType
+    {
+
+    }
+
+    public class MyOtherType
+    {
+
+    }
+}
+

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Extensibility/ServiceProviderTests.cs

@@ -0,0 +1,115 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Linq;
+using Microsoft.SqlTools.ServiceLayer.Extensibility;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Extensibility
+{
+    public class ServiceProviderTests
+    {
+        private RegisteredServiceProvider provider;
+        public ServiceProviderTests()
+        {
+            provider = new RegisteredServiceProvider();
+        }
+
+        [Fact]
+        public void GetServiceShouldReturnNullIfNoServicesRegistered()
+        {
+            // Given no service registered
+            // When I call GetService
+            var service = provider.GetService<MyProviderService>();
+            // Then I expect null to be returned
+            Assert.Null(service);
+        }
+
+
+        [Fact]
+        public void GetSingleServiceThrowsMultipleServicesRegistered()
+        {
+            // Given 2 services registered
+            provider.Register<MyProviderService>(() => new[] { new MyProviderService(), new MyProviderService() });
+            // When I call GetService
+            // Then I expect to throw
+            Assert.Throws<InvalidOperationException>(() => provider.GetService<MyProviderService>());
+        }
+
+        [Fact]
+        public void GetServicesShouldReturnEmptyIfNoServicesRegistered()
+        {
+            // Given no service regisstered
+            // When I call GetService
+            var services = provider.GetServices<MyProviderService>();
+            // Then I expect empty enumerable to be returned
+            Assert.NotNull(services);
+            Assert.Equal(0, services.Count());
+        }
+
+        [Fact]
+        public void GetServiceShouldReturnRegisteredService()
+        {
+            MyProviderService service = new MyProviderService();
+            provider.RegisterSingleService(service);
+
+            var returnedService = provider.GetService<MyProviderService>();
+            Assert.Equal(service, returnedService);            
+        }
+
+        [Fact]
+        public void GetServicesShouldReturnRegisteredServiceWhenMultipleServicesRegistered()
+        {
+            MyProviderService service = new MyProviderService();
+            provider.RegisterSingleService(service);          
+
+            var returnedServices = provider.GetServices<MyProviderService>();
+            Assert.Equal(service, returnedServices.Single());
+        }
+
+        [Fact]
+        public void RegisterServiceProviderShouldThrowIfServiceIsIncompatible()
+        {
+            MyProviderService service = new MyProviderService();
+            Assert.Throws<InvalidOperationException>(() => provider.RegisterSingleService(typeof(OtherService), service));
+        }
+        [Fact]
+        public void RegisterServiceProviderShouldThrowIfServiceAlreadyRegistered()
+        {
+            MyProviderService service = new MyProviderService();
+            provider.RegisterSingleService(service);
+
+            Assert.Throws<InvalidOperationException>(() => provider.RegisterSingleService(service));
+        }
+        
+        [Fact]
+        public void RegisterShouldThrowIfServiceAlreadyRegistered()
+        {
+            MyProviderService service = new MyProviderService();
+            provider.RegisterSingleService(service);
+
+            Assert.Throws<InvalidOperationException>(() => provider.Register(() => service.SingleItemAsEnumerable()));
+        }
+
+        [Fact]
+        public void RegisterShouldThrowIfServicesAlreadyRegistered()
+        {
+            provider.Register<MyProviderService>(() => new [] { new MyProviderService(), new MyProviderService() });
+            Assert.Throws<InvalidOperationException>(() => provider.Register(() => new MyProviderService().SingleItemAsEnumerable()));
+        }
+    }
+
+
+    public class MyProviderService
+    {
+
+    }
+
+    public class OtherService
+    {
+
+    }
+}