Object Explorer Service (#311)

* moving OE service from an old branch

test/Microsoft.SqlTools.ServiceLayer.UnitTests/ObjectExplorer/NodeTests.cs

@@ -0,0 +1,369 @@
+//
+// 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.Collections.Generic;
+using System.Data.SqlClient;
+using System.Globalization;
+using Microsoft.SqlServer.Management.Common;
+using Microsoft.SqlServer.Management.Smo;
+using Microsoft.SqlTools.Extensibility;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer.Contracts;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer.Nodes;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer.SmoModel;
+using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
+using Moq;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ObjectExplorer
+{
+    /// <summary>
+    /// Tests covering basic operation of Node based classes
+    /// </summary>
+    public class NodeTests : ObjectExplorerTestBase
+    {
+        private string defaultOwnerUri = "objectexplorer://myserver";
+        private ServerInfo defaultServerInfo;
+        private ConnectionDetails defaultConnectionDetails;
+        private ConnectionCompleteParams defaultConnParams;
+        private string fakeConnectionString = "Data Source=server;Initial Catalog=database;Integrated Security=False;User Id=user";
+
+        public NodeTests()
+        {
+            defaultServerInfo = TestObjects.GetTestServerInfo();
+
+            defaultConnectionDetails = new ConnectionDetails()
+            {
+                DatabaseName = "master",
+                ServerName = "localhost",
+                UserName = "serverAdmin",
+                Password = "..."
+            };
+            defaultConnParams = new ConnectionCompleteParams()
+            {
+                ServerInfo = defaultServerInfo,
+                ConnectionSummary = defaultConnectionDetails,
+                OwnerUri = defaultOwnerUri
+            };
+
+            // TODO can all tests use the standard service provider?
+            ServiceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
+        }
+        
+        [Fact]
+        public void ServerNodeConstructorValidatesFields()
+        {
+            Assert.Throws<ArgumentNullException>(() => new ServerNode(null, ServiceProvider));
+            Assert.Throws<ArgumentNullException>(() => new ServerNode(defaultConnParams, null));
+        }
+
+        [Fact]
+        public void ServerNodeConstructorShouldSetValuesCorrectly()
+        {
+            // Given a server node with valid inputs
+            ServerNode node = new ServerNode(defaultConnParams, ServiceProvider);
+            // Then expect all fields set correctly
+            Assert.False(node.IsAlwaysLeaf, "Server node should never be a leaf");
+            Assert.Equal(defaultConnectionDetails.ServerName, node.NodeValue);
+
+            string expectedLabel = defaultConnectionDetails.ServerName + " (SQL Server " + defaultServerInfo.ServerVersion + " - "
+                + defaultConnectionDetails.UserName + ")";
+            Assert.Equal(expectedLabel, node.Label);
+
+            Assert.Equal(NodeTypes.ServerInstance.ToString(), node.NodeType);
+            string[] nodePath = node.GetNodePath().Split(TreeNode.PathPartSeperator);
+            Assert.Equal(1, nodePath.Length);
+            Assert.Equal(defaultConnectionDetails.ServerName, nodePath[0]);
+        }
+
+        [Fact]
+        public void ServerNodeLabelShouldIgnoreUserNameIfEmptyOrNull()
+        {
+            // Given no username set
+            ConnectionSummary integratedAuthSummary = new ConnectionSummary()
+            {
+                DatabaseName = defaultConnectionDetails.DatabaseName,
+                ServerName = defaultConnectionDetails.ServerName,
+                UserName = null
+            };
+            ConnectionCompleteParams connParams = new ConnectionCompleteParams()
+            {
+                ConnectionSummary = integratedAuthSummary,
+                ServerInfo = defaultServerInfo,
+                OwnerUri = defaultOwnerUri
+            };
+            // When querying label
+            string label = new ServerNode(connParams, ServiceProvider).Label;
+            // Then only server name and version shown
+            string expectedLabel = defaultConnectionDetails.ServerName + " (SQL Server " + defaultServerInfo.ServerVersion + ")";
+            Assert.Equal(expectedLabel, label);
+        }
+
+        [Fact]
+        public void ServerNodeConstructorShouldShowDbNameForCloud()
+        {
+            defaultServerInfo.IsCloud = true;
+
+            // Given a server node for a cloud DB, with master name
+            ServerNode node = new ServerNode(defaultConnParams, ServiceProvider);
+            // Then expect label to not include db name
+            string expectedLabel = defaultConnectionDetails.ServerName + " (SQL Server " + defaultServerInfo.ServerVersion + " - "
+                + defaultConnectionDetails.UserName + ")";
+            Assert.Equal(expectedLabel, node.Label);
+
+            // But given a server node for a cloud DB that's not master
+            defaultConnectionDetails.DatabaseName = "NotMaster";
+            node = new ServerNode(defaultConnParams, ServiceProvider);
+
+            // Then expect label to include db name 
+            expectedLabel = defaultConnectionDetails.ServerName + " (SQL Server " + defaultServerInfo.ServerVersion + " - "
+                + defaultConnectionDetails.UserName + ", " + defaultConnectionDetails.DatabaseName + ")";
+            Assert.Equal(expectedLabel, node.Label);
+        }
+
+        [Fact]
+        public void ToNodeInfoIncludeAllFields()
+        {
+            // Given a server connection
+            ServerNode node = new ServerNode(defaultConnParams, ServiceProvider);
+            // When converting to NodeInfo
+            NodeInfo info = node.ToNodeInfo();
+            // Then all fields should match
+            Assert.Equal(node.IsAlwaysLeaf, info.IsLeaf);
+            Assert.Equal(node.Label, info.Label);
+            Assert.Equal(node.NodeType, info.NodeType);
+            string[] nodePath = node.GetNodePath().Split(TreeNode.PathPartSeperator);
+            string[] nodeInfoPathParts = info.NodePath.Split(TreeNode.PathPartSeperator);
+            Assert.Equal(nodePath.Length, nodeInfoPathParts.Length);
+            for (int i = 0; i < nodePath.Length; i++)
+            {
+                Assert.Equal(nodePath[i], nodeInfoPathParts[i]);
+            }
+        }
+
+        [Fact]
+        public void AddChildShouldSetParent()
+        {
+            TreeNode parent = new TreeNode("parent");
+            TreeNode child = new TreeNode("child");
+            Assert.Null(child.Parent);
+            parent.AddChild(child);
+            Assert.Equal(parent, child.Parent);
+        }
+
+        [Fact]
+        public void GetChildrenShouldReturnReadonlyList()
+        {
+            TreeNode node = new TreeNode("parent");
+            IList<TreeNode> children = node.GetChildren();
+            Assert.Throws<NotSupportedException>(() => children.Add(new TreeNode("child")));
+        }
+
+        [Fact]
+        public void GetChildrenShouldReturnAddedNodesInOrder()
+        {
+            TreeNode parent = new TreeNode("parent");
+            TreeNode[] expectedKids = new TreeNode[] { new TreeNode("1"), new TreeNode("2") };
+            foreach (TreeNode child in expectedKids)
+            {
+                parent.AddChild(child);
+            }
+            IList<TreeNode> children = parent.GetChildren();
+            Assert.Equal(expectedKids.Length, children.Count);
+            for (int i = 0; i < expectedKids.Length; i++)
+            {
+                Assert.Equal(expectedKids[i], children[i]);
+            }
+        }
+
+        public void MultiLevelTreeShouldFormatPath()
+        {
+            TreeNode root = new TreeNode("root");
+            Assert.Equal("/root" , root.GetNodePath());
+
+            TreeNode level1Child1 = new TreeNode("L1C1");
+            TreeNode level1Child2 = new TreeNode("L1C2");
+            root.AddChild(level1Child1);
+            root.AddChild(level1Child2);
+            Assert.Equal("/root/L1C1" , level1Child1.GetNodePath());
+            Assert.Equal("/root/L1C2", level1Child2.GetNodePath());
+
+            TreeNode level2Child1 = new TreeNode("L2C2");
+            level1Child1.AddChild(level2Child1);
+            Assert.Equal("/root/L1C1/L2C2", level2Child1.GetNodePath());
+        }
+        
+        [Fact]
+        public void ServerNodeContextShouldIncludeServer()
+        {
+            // given a successful Server creation
+            SetupAndRegisterTestConnectionService();
+            Server smoServer = new Server(new ServerConnection(new SqlConnection(fakeConnectionString)));
+            ServerNode node = SetupServerNodeWithServer(smoServer);
+
+            // When I get the context for a ServerNode
+            var context = node.GetContextAs<SmoQueryContext>();
+
+            // Then I expect it to contain the server I created 
+            Assert.NotNull(context);
+            Assert.Equal(smoServer, context.Server);
+            // And the server should be the parent
+            Assert.Equal(smoServer, context.Parent);
+            Assert.Null(context.Database);
+        }
+
+        [Fact]
+        public void ServerNodeContextShouldSetErrorMessageIfSqlConnectionIsNull()
+        {
+            // given a connectionInfo with no SqlConnection to use for queries
+            ConnectionService connService = SetupAndRegisterTestConnectionService();
+            connService.OwnerToConnectionMap.Remove(defaultOwnerUri);
+
+            Server smoServer = new Server(new ServerConnection(new SqlConnection(fakeConnectionString)));
+            ServerNode node = SetupServerNodeWithServer(smoServer);
+
+            // When I get the context for a ServerNode
+            var context = node.GetContextAs<SmoQueryContext>();
+
+            // Then I expect it to be in an error state 
+            Assert.Null(context);
+            Assert.Equal(
+                string.Format(CultureInfo.CurrentCulture, SR.ServerNodeConnectionError, defaultConnectionDetails.ServerName), 
+                node.ErrorStateMessage);
+        }
+
+        [Fact]
+        public void ServerNodeContextShouldSetErrorMessageIfConnFailureExceptionThrown()
+        {
+            // given a connectionInfo with no SqlConnection to use for queries
+            SetupAndRegisterTestConnectionService();
+
+            Server smoServer = new Server(new ServerConnection(new SqlConnection(fakeConnectionString)));
+            string expectedMsg = "ConnFailed!";
+            ServerNode node = SetupServerNodeWithExceptionCreator(new ConnectionFailureException(expectedMsg));
+
+            // When I get the context for a ServerNode
+            var context = node.GetContextAs<SmoQueryContext>();
+
+            // Then I expect it to be in an error state 
+            Assert.Null(context);
+            Assert.Equal(
+                string.Format(CultureInfo.CurrentCulture, SR.TreeNodeError, expectedMsg),
+                node.ErrorStateMessage);
+        }
+
+        [Fact]
+        public void ServerNodeContextShouldSetErrorMessageIfExceptionThrown()
+        {
+            // given a connectionInfo with no SqlConnection to use for queries
+            SetupAndRegisterTestConnectionService();
+
+            Server smoServer = new Server(new ServerConnection(new SqlConnection(fakeConnectionString)));
+            string expectedMsg = "Failed!";
+            ServerNode node = SetupServerNodeWithExceptionCreator(new Exception(expectedMsg));
+
+            // When I get the context for a ServerNode
+            var context = node.GetContextAs<SmoQueryContext>();
+
+            // Then I expect it to be in an error state 
+            Assert.Null(context);
+            Assert.Equal(
+                string.Format(CultureInfo.CurrentCulture, SR.TreeNodeError, expectedMsg),
+                node.ErrorStateMessage);
+        }
+
+        private ConnectionService SetupAndRegisterTestConnectionService()
+        {
+            ConnectionService connService = TestObjects.GetTestConnectionService();
+            ConnectionInfo connectionInfo = new ConnectionInfo(TestObjects.GetTestSqlConnectionFactory(),
+                defaultOwnerUri, defaultConnectionDetails);
+            connectionInfo.AddConnection("Default", new SqlConnection());
+
+            connService.OwnerToConnectionMap.Add(defaultOwnerUri, connectionInfo);
+            ServiceProvider.RegisterSingleService(connService);
+            return connService;
+        }
+
+        private ServerNode SetupServerNodeWithServer(Server smoServer)
+        {
+            Mock<SmoServerCreator> creator = new Mock<SmoServerCreator>();
+            creator.Setup(c => c.Create(It.IsAny<SqlConnection>()))
+                .Returns(() => smoServer);
+            ServerNode node = SetupServerNodeWithCreator(creator.Object);
+            return node;
+        }
+
+        private ServerNode SetupServerNodeWithExceptionCreator(Exception ex)
+        {
+            Mock<SmoServerCreator> creator = new Mock<SmoServerCreator>();
+            creator.Setup(c => c.Create(It.IsAny<SqlConnection>()))
+                .Throws(ex);
+
+            ServerNode node = SetupServerNodeWithCreator(creator.Object);
+            return node;
+        }
+
+        private ServerNode SetupServerNodeWithCreator(SmoServerCreator creator)
+        {
+            ServerNode node = new ServerNode(defaultConnParams, ServiceProvider);
+            node.ServerCreator = creator;
+            return node;
+        }
+
+        [Fact]
+        public void ServerNodeChildrenShouldIncludeFoldersAndDatabases()
+        {
+            // Given a server with 1 database
+            SetupAndRegisterTestConnectionService();
+            ServiceProvider.RegisterSingleService(new ObjectExplorerService());
+
+            string dbName = "DB1";
+            Mock<NamedSmoObject> smoObjectMock = new Mock<NamedSmoObject>();
+            smoObjectMock.SetupGet(s => s.Name).Returns(dbName);
+
+            Mock<SqlDatabaseQuerier> querierMock = new Mock<SqlDatabaseQuerier>();
+            querierMock.Setup(q => q.Query(It.IsAny<SmoQueryContext>()))
+                .Returns(smoObjectMock.Object.SingleItemAsEnumerable());
+
+            ServiceProvider.Register<SmoQuerier>(() => new[] { querierMock.Object });
+
+            Server smoServer = new Server(new ServerConnection(new SqlConnection(fakeConnectionString)));
+            ServerNode node = SetupServerNodeWithServer(smoServer);
+
+            // When I populate its children
+            IList<TreeNode> children = node.Expand();
+
+            // Then I expect it to contain server-level folders 
+            Assert.Equal(3, children.Count);
+            VerifyTreeNode<FolderNode>(children[0], "Folder", SR.SchemaHierarchy_Databases);
+            VerifyTreeNode<FolderNode>(children[1], "Folder", SR.SchemaHierarchy_Security);
+            VerifyTreeNode<FolderNode>(children[2], "Folder", SR.SchemaHierarchy_ServerObjects);
+            // And the database is contained under it
+            TreeNode databases = children[0];
+            IList<TreeNode> dbChildren = databases.Expand();
+            Assert.Equal(2, dbChildren.Count);
+            Assert.Equal("System Databases", dbChildren[0].NodeValue);
+
+            TreeNode dbNode = dbChildren[1];
+            Assert.Equal(dbName, dbNode.NodeValue);
+            Assert.Equal(dbName, dbNode.Label);
+            Assert.False(dbNode.IsAlwaysLeaf);
+            
+            // Note: would like to verify Database in the context, but cannot since it's a Sealed class and isn't easily mockable
+        }
+
+        private void VerifyTreeNode<T>(TreeNode node, string nodeType, string folderValue)
+            where T : TreeNode
+        {
+            T nodeAsT = node as T;
+            Assert.NotNull(nodeAsT);
+            Assert.Equal(nodeType, nodeAsT.NodeType);
+            Assert.Equal(folderValue, nodeAsT.NodeValue);
+        }
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.UnitTests/ObjectExplorer/ObjectExplorerServiceTests.cs

@@ -0,0 +1,151 @@
+//
+// 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.Threading.Tasks;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer.Contracts;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer.Nodes;
+using Microsoft.SqlTools.ServiceLayer.Test.Common;
+using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
+using Moq;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ObjectExplorer
+{
+
+    public class ObjectExplorerServiceTests : ObjectExplorerTestBase
+    {
+        private ObjectExplorerService service;
+        private Mock<ConnectionService> connectionServiceMock;
+        private Mock<IProtocolEndpoint> serviceHostMock;
+        public ObjectExplorerServiceTests()
+        {
+            connectionServiceMock = new Mock<ConnectionService>();
+            serviceHostMock = new Mock<IProtocolEndpoint>();
+            service = CreateOEService(connectionServiceMock.Object);
+            service.InitializeService(serviceHostMock.Object);
+        }
+
+        [Fact]
+        public async Task CreateSessionRequestErrorsIfConnectionDetailsIsNull()
+        {
+            object errorResponse = null;
+            var contextMock = RequestContextMocks.Create<CreateSessionResponse>(null)
+                                                 .AddErrorHandling((errorMessage, errorCode, obj) => errorResponse = errorMessage);
+
+            await service.HandleCreateSessionRequest(null, contextMock.Object);
+            VerifyErrorSent(contextMock);
+            Assert.True(((string)errorResponse).Contains("ArgumentNullException"));
+        }
+        
+        [Fact]
+        public async Task CreateSessionRequestReturnsFalseOnConnectionFailure()
+        {
+            // Given the connection service fails to connect
+            ConnectionDetails details = TestObjects.GetTestConnectionDetails();
+            ConnectionCompleteParams completeParams = null;
+            serviceHostMock.AddEventHandling(ConnectionCompleteNotification.Type, (et, p) => completeParams = p);
+
+            string expectedExceptionText = "Error!!!";
+            connectionServiceMock.Setup(c => c.Connect(It.IsAny<ConnectParams>()))
+                .Throws(new Exception(expectedExceptionText));
+
+            // when creating a new session
+            // then expect the create session request to return false
+            await RunAndVerify<CreateSessionResponse>(
+                test: (requestContext) => service.HandleCreateSessionRequest(details, requestContext),
+                verify: (actual =>
+                {
+                    Assert.False(actual.Success);
+                    Assert.Null(actual.SessionId);
+                    Assert.Null(actual.RootNode);
+                }));
+
+            // And expect error notification to be sent
+            serviceHostMock.Verify(x => x.SendEvent(ConnectionCompleteNotification.Type, It.IsAny<ConnectionCompleteParams>()), Times.Once());
+            Assert.NotNull(completeParams);
+            Assert.True(completeParams.Messages.Contains(expectedExceptionText));
+        }
+
+
+        [Fact]
+        public async Task CreateSessionRequestReturnsSuccessAndNodeInfo()
+        {
+            // Given the connection service fails to connect
+            ConnectionDetails details = TestObjects.GetTestConnectionDetails();
+            serviceHostMock.AddEventHandling(ConnectionCompleteNotification.Type, null);
+            
+            connectionServiceMock.Setup(c => c.Connect(It.IsAny<ConnectParams>()))
+                .Returns((ConnectParams connectParams) => Task.FromResult(GetCompleteParamsForConnection(connectParams.OwnerUri, details)));
+            
+            // when creating a new session
+            // then expect the create session request to return false
+            await RunAndVerify<CreateSessionResponse>(
+                test: (requestContext) => service.HandleCreateSessionRequest(details, requestContext),
+                verify: (actual =>
+                {
+                    Assert.True(actual.Success);
+                    Assert.NotNull(actual.SessionId);
+                    VerifyServerNode(actual.RootNode, details);
+                }));
+
+            // And expect no error notification to be sent
+            serviceHostMock.Verify(x => x.SendEvent(ConnectionCompleteNotification.Type, 
+                It.IsAny<ConnectionCompleteParams>()), Times.Never());
+        }
+
+        private void VerifyServerNode(NodeInfo serverNode, ConnectionDetails details)
+        {
+            Assert.NotNull(serverNode);
+            Assert.Equal(NodeTypes.ServerInstance.ToString(), serverNode.NodeType);
+            string[] pathParts = serverNode.NodePath.Split(TreeNode.PathPartSeperator);
+            Assert.Equal(1, pathParts.Length);
+            Assert.Equal(details.ServerName, pathParts[0]);
+            Assert.True(serverNode.Label.Contains(details.ServerName));
+            Assert.False(serverNode.IsLeaf);
+        }
+
+        private static ConnectionCompleteParams GetCompleteParamsForConnection(string uri, ConnectionDetails details)
+        {
+            return new ConnectionCompleteParams()
+            {
+                OwnerUri = uri,
+                ConnectionSummary = new ConnectionSummary()
+                {
+                    ServerName = details.ServerName,
+                    DatabaseName = details.DatabaseName,
+                    UserName = details.UserName
+                },
+                ServerInfo = TestObjects.GetTestServerInfo()
+            };
+        }
+
+        private async Task RunAndVerify<T>(Func<RequestContext<T>, Task> test, Action<T> verify)
+        {
+            T result = default(T);
+            var contextMock = RequestContextMocks.Create<T>(r => result = r).AddErrorHandling(null);
+            await test(contextMock.Object);
+            VerifyResult(contextMock, verify, result);
+        }
+        
+        private void VerifyResult<T>(Mock<RequestContext<T>> contextMock, Action<T> verify, T actual)
+        {
+            contextMock.Verify(c => c.SendResult(It.IsAny<T>()), Times.Once);
+            contextMock.Verify(c => c.SendError(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<object>()), Times.Never);
+            verify(actual);
+        }
+
+        private void VerifyErrorSent<T>(Mock<RequestContext<T>> contextMock)
+        {
+            contextMock.Verify(c => c.SendResult(It.IsAny<T>()), Times.Never);
+            contextMock.Verify(c => c.SendError(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<object>()), Times.Once);
+        }
+
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.UnitTests/ObjectExplorer/ObjectExplorerTestBase.cs

@@ -0,0 +1,45 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.Extensibility;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ObjectExplorer
+{
+    // Base class providing common test functionality for OE tests
+    public abstract class ObjectExplorerTestBase
+    {
+        protected RegisteredServiceProvider ServiceProvider
+        {
+            get;
+            set;
+        }
+
+        protected RegisteredServiceProvider CreateServiceProviderWithMinServices()
+        {
+            return CreateProvider()
+                .RegisterSingleService(new ConnectionService())
+                .RegisterSingleService(new ObjectExplorerService());
+        }
+
+        protected RegisteredServiceProvider CreateProvider()
+        {
+            ServiceProvider = new RegisteredServiceProvider();
+            return ServiceProvider;
+        }
+        
+        protected ObjectExplorerService CreateOEService(ConnectionService connService)
+        {
+            CreateProvider()
+                .RegisterSingleService(connService)
+                .RegisterSingleService(new ObjectExplorerService());
+
+            // Create the service using the service provider, which will initialize dependencies
+            return ServiceProvider.GetService<ObjectExplorerService>();
+        }
+
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.UnitTests/ObjectExplorer/SmoQueryModelTests.cs

@@ -0,0 +1,65 @@
+//
+// 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.SqlServer.Management.Smo;
+using Microsoft.SqlTools.Extensibility;
+using Microsoft.SqlTools.ServiceLayer.ObjectExplorer.SmoModel;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ObjectExplorer
+{
+    public class SmoQueryModelTests
+    {
+
+        [Fact]
+        public void ShouldFindDatabaseQuerierFromRealPath()
+        {
+            // Given the extension type loader is set to find SmoCollectionQuerier objects
+            IMultiServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
+            // When I request a database compatible querier
+            SmoQuerier querier = serviceProvider.GetService<SmoQuerier>(q => q.SupportedObjectTypes.Contains(typeof(Database)));
+            // Then I expect to get back the SqlDatabaseQuerier
+            Assert.NotNull(querier);
+            Assert.Equal(typeof(SqlDatabaseQuerier), querier.GetType());
+
+            // And I expect the service provider to have been set by the extension code
+            Assert.NotNull(querier.ServiceProvider);
+        }
+        
+        [Fact]
+        public void ShouldFindQuerierIfInExtensionList()
+        {
+            VerifyQuerierLookup(typeof(Table), typeof(SqlTableQuerier), expectExists: true);
+        }
+
+        [Fact]
+        public void ShouldNotFindQuerierIfNotInExtensionList()
+        {
+            VerifyQuerierLookup(typeof(Database), null, expectExists: false);
+        }
+
+        private static void VerifyQuerierLookup(Type smoType, Type querierType, bool expectExists)
+        {
+            ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.Create(new Type[] {
+                typeof(SqlTableQuerier),
+                typeof(SqlLinkedServerQuerier)
+            });
+            SmoQuerier querier = serviceProvider.GetService<SmoQuerier>(q => q.SupportedObjectTypes.Contains(smoType));
+            if (expectExists)
+            {
+                Assert.NotNull(querier);
+                Assert.Equal(querierType, querier.GetType());
+                Assert.NotNull(querier.ServiceProvider);
+            }
+            else
+            {
+                Assert.Null(querier);
+            }
+        }
+
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.UnitTests/ServiceHost/SrTests.cs

@@ -43,6 +43,169 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ServiceHost
             var queryServiceErrorFormat = SR.QueryServiceErrorFormat(1, 1, 1, 1, "\n", "..");
             var queryServiceQueryFailed = SR.QueryServiceQueryFailed("..");
             var workspaceServiceBufferPositionOutOfOrder = SR.WorkspaceServiceBufferPositionOutOfOrder(1, 2, 3, 4);
+            var treeNodeError = SR.TreeNodeError;
+            var serverNodeConnectionError = SR.ServerNodeConnectionError;
+            var schemaHierarchyAggregates = SR.SchemaHierarchy_Aggregates;
+            var SchemaHierarchy_ServerRoles = SR.SchemaHierarchy_ServerRoles;
+            var SchemaHierarchy_ApplicationRoles = SR.SchemaHierarchy_ApplicationRoles;
+            var SchemaHierarchy_Assemblies = SR.SchemaHierarchy_Assemblies;
+            var SchemaHierarchy_AssemblyFiles = SR.SchemaHierarchy_AssemblyFiles;
+            var SchemaHierarchy_AsymmetricKeys = SR.SchemaHierarchy_AsymmetricKeys;
+            var SchemaHierarchy_DatabaseAsymmetricKeys = SR.SchemaHierarchy_DatabaseAsymmetricKeys;
+            var SchemaHierarchy_DataCompressionOptions = SR.SchemaHierarchy_DataCompressionOptions;
+            var SchemaHierarchy_Certificates = SR.SchemaHierarchy_Certificates;
+            var SchemaHierarchy_FileTables = SR.SchemaHierarchy_FileTables;
+            var SchemaHierarchy_DatabaseCertificates = SR.SchemaHierarchy_DatabaseCertificates;
+            var SchemaHierarchy_CheckConstraints = SR.SchemaHierarchy_CheckConstraints;
+            var SchemaHierarchy_Columns = SR.SchemaHierarchy_Columns;
+            var SchemaHierarchy_Constraints = SR.SchemaHierarchy_Constraints;
+            var SchemaHierarchy_Contracts = SR.SchemaHierarchy_Contracts;
+            var SchemaHierarchy_Credentials = SR.SchemaHierarchy_Credentials;
+            var SchemaHierarchy_ErrorMessages = SR.SchemaHierarchy_ErrorMessages;
+            var SchemaHierarchy_ServerRoleMembership = SR.SchemaHierarchy_ServerRoleMembership;
+            var SchemaHierarchy_DatabaseOptions = SR.SchemaHierarchy_DatabaseOptions;
+            var SchemaHierarchy_DatabaseRoles = SR.SchemaHierarchy_DatabaseRoles;
+            var SchemaHierarchy_RoleMemberships = SR.SchemaHierarchy_RoleMemberships;
+            var SchemaHierarchy_DatabaseTriggers = SR.SchemaHierarchy_DatabaseTriggers;
+            var SchemaHierarchy_DefaultConstraints = SR.SchemaHierarchy_DefaultConstraints;
+            var SchemaHierarchy_Defaults = SR.SchemaHierarchy_Defaults;
+            var SchemaHierarchy_Sequences = SR.SchemaHierarchy_Sequences;
+            var SchemaHierarchy_Endpoints = SR.SchemaHierarchy_Endpoints;
+            var SchemaHierarchy_EventNotifications = SR.SchemaHierarchy_EventNotifications;
+            var SchemaHierarchy_ServerEventNotifications = SR.SchemaHierarchy_ServerEventNotifications;
+            var SchemaHierarchy_ExtendedProperties = SR.SchemaHierarchy_ExtendedProperties;
+            var SchemaHierarchy_FileGroups = SR.SchemaHierarchy_FileGroups;
+            var SchemaHierarchy_ForeignKeys = SR.SchemaHierarchy_ForeignKeys;
+            var SchemaHierarchy_FullTextCatalogs = SR.SchemaHierarchy_FullTextCatalogs;
+            var SchemaHierarchy_FullTextIndexes = SR.SchemaHierarchy_FullTextIndexes;
+            var SchemaHierarchy_Functions = SR.SchemaHierarchy_Functions;
+            var SchemaHierarchy_Indexes = SR.SchemaHierarchy_Indexes;
+            var SchemaHierarchy_InlineFunctions = SR.SchemaHierarchy_InlineFunctions;
+            var SchemaHierarchy_Keys = SR.SchemaHierarchy_Keys;
+            var SchemaHierarchy_LinkedServers = SR.SchemaHierarchy_LinkedServers;
+            var SchemaHierarchy_LinkedServerLogins = SR.SchemaHierarchy_LinkedServerLogins;
+            var SchemaHierarchy_Logins = SR.SchemaHierarchy_Logins;
+            var SchemaHierarchy_MasterKey = SR.SchemaHierarchy_MasterKey;
+            var SchemaHierarchy_MasterKeys = SR.SchemaHierarchy_MasterKeys;
+            var SchemaHierarchy_MessageTypes = SR.SchemaHierarchy_MessageTypes;
+            var SchemaHierarchy_MultiSelectFunctions = SR.SchemaHierarchy_MultiSelectFunctions;
+            var SchemaHierarchy_Parameters = SR.SchemaHierarchy_Parameters;
+            var SchemaHierarchy_PartitionFunctions = SR.SchemaHierarchy_PartitionFunctions;
+            var SchemaHierarchy_PartitionSchemes = SR.SchemaHierarchy_PartitionSchemes;
+            var SchemaHierarchy_Permissions = SR.SchemaHierarchy_Permissions;
+            var SchemaHierarchy_PrimaryKeys = SR.SchemaHierarchy_PrimaryKeys;
+            var schemaHierarchyPrimaryKeys = SR.SchemaHierarchy_PrimaryKeys;
+            var schemaHierarchyProgrammability = SR.SchemaHierarchy_Programmability;
+            var schemaHierarchyQueues = SR.SchemaHierarchy_Queues;
+            var schemaHierarchyRemoteServiceBindings = SR.SchemaHierarchy_RemoteServiceBindings;
+            var schemaHierarchyReturnedColumns = SR.SchemaHierarchy_ReturnedColumns;
+            var schemaHierarchyRoles = SR.SchemaHierarchy_Roles;
+            var schemaHierarchyRoutes = SR.SchemaHierarchy_Routes;
+            var schemaHierarchyRules = SR.SchemaHierarchy_Rules;
+            var schemaHierarchySchemas = SR.SchemaHierarchy_Schemas;
+            var schemaHierarchySecurity = SR.SchemaHierarchy_Security;
+            var schemaHierarchyServerObjects = SR.SchemaHierarchy_ServerObjects;
+            var schemaHierarchyManagement = SR.SchemaHierarchy_Management;
+            var schemaHierarchyServerTriggers = SR.SchemaHierarchy_ServerTriggers;
+            var schemaHierarchyServiceBroker = SR.SchemaHierarchy_ServiceBroker;
+            var schemaHierarchyServices = SR.SchemaHierarchy_Services;
+            var schemaHierarchySignatures = SR.SchemaHierarchy_LogFiles;
+            var schemaHierarchyStatistics = SR.SchemaHierarchy_Statistics;
+            var schemaHierarchyStorage = SR.SchemaHierarchy_Storage;
+            var schemaHierarchyStoredProcedures = SR.SchemaHierarchy_StoredProcedures;
+            var schemaHierarchySymmetricKeys = SR.SchemaHierarchy_SymmetricKeys;
+            var schemaHierarchySynonyms = SR.SchemaHierarchy_Synonyms;
+            var schemaHierarchyTables = SR.SchemaHierarchy_Tables;
+            var schemaHierarchyTriggers = SR.SchemaHierarchy_Triggers;
+            var schemaHierarchyTypes = SR.SchemaHierarchy_Types;
+            var schemaHierarchyUniqueKeys = SR.SchemaHierarchy_UniqueKeys;
+            var schemaHierarchyUserDefinedDataTypes = SR.SchemaHierarchy_UserDefinedDataTypes;
+            var schemaHierarchyUserDefinedTypes = SR.SchemaHierarchy_UserDefinedTypes;
+            var schemaHierarchyUsers = SR.SchemaHierarchy_Users;
+            var schemaHierarchyViews = SR.SchemaHierarchy_Views;
+            var schemaHierarchyXmlIndexes = SR.SchemaHierarchy_XmlIndexes;
+            var schemaHierarchyXMLSchemaCollections = SR.SchemaHierarchy_XMLSchemaCollections;
+            var schemaHierarchyUserDefinedTableTypes = SR.SchemaHierarchy_UserDefinedTableTypes;
+            var schemaHierarchyFilegroupFiles = SR.SchemaHierarchy_FilegroupFiles;
+            var missingCaption = SR.MissingCaption;
+            var schemaHierarchyBrokerPriorities = SR.SchemaHierarchy_BrokerPriorities;
+            var schemaHierarchyCryptographicProviders = SR.SchemaHierarchy_CryptographicProviders;
+            var schemaHierarchyDatabaseAuditSpecifications = SR.SchemaHierarchy_DatabaseAuditSpecifications;
+            var schemaHierarchyDatabaseEncryptionKeys = SR.SchemaHierarchy_DatabaseEncryptionKeys;
+            var schemaHierarchyEventSessions = SR.SchemaHierarchy_EventSessions;
+            var schemaHierarchyFullTextStopLists = SR.SchemaHierarchy_FullTextStopLists;
+            var schemaHierarchyResourcePools = SR.SchemaHierarchy_ResourcePools;
+            var schemaHierarchyServerAudits = SR.SchemaHierarchy_ServerAudits;
+            var schemaHierarchyServerAuditSpecifications = SR.SchemaHierarchy_ServerAuditSpecifications;
+            var schemaHierarchySpatialIndexes = SR.SchemaHierarchy_SpatialIndexes;
+            var schemaHierarchyWorkloadGroups = SR.SchemaHierarchy_WorkloadGroups;
+            var schemaHierarchySqlFiles = SR.SchemaHierarchy_SqlFiles;
+            var schemaHierarchyServerFunctions = SR.SchemaHierarchy_ServerFunctions;
+            var schemaHierarchySqlType = SR.SchemaHierarchy_SqlType;
+            var schemaHierarchyServerOptions = SR.SchemaHierarchy_ServerOptions;
+            var schemaHierarchyDatabaseDiagrams = SR.SchemaHierarchy_DatabaseDiagrams;
+            var schemaHierarchySystemTables = SR.SchemaHierarchy_SystemTables;
+            var schemaHierarchyDatabases = SR.SchemaHierarchy_Databases;
+            var schemaHierarchySystemContracts = SR.SchemaHierarchy_SystemContracts;
+            var schemaHierarchySystemDatabases = SR.SchemaHierarchy_SystemDatabases;
+            var schemaHierarchySystemMessageTypes = SR.SchemaHierarchy_SystemMessageTypes;
+            var schemaHierarchySystemQueues = SR.SchemaHierarchy_SystemQueues;
+            var schemaHierarchySystemServices = SR.SchemaHierarchy_SystemServices;
+            var schemaHierarchySystemStoredProcedures = SR.SchemaHierarchy_SystemStoredProcedures;
+            var schemaHierarchySystemViews = SR.SchemaHierarchy_SystemViews;
+            var schemaHierarchyDataTierApplications = SR.SchemaHierarchy_DataTierApplications;
+            var schemaHierarchyExtendedStoredProcedures = SR.SchemaHierarchy_ExtendedStoredProcedures;
+            var schemaHierarchySystemAggregateFunctions = SR.SchemaHierarchy_SystemAggregateFunctions;
+            var schemaHierarchySystemApproximateNumerics = SR.SchemaHierarchy_SystemApproximateNumerics;
+            var schemaHierarchySystemBinaryStrings = SR.SchemaHierarchy_SystemBinaryStrings;
+            var schemaHierarchySystemCharacterStrings = SR.SchemaHierarchy_SystemCharacterStrings;
+            var schemaHierarchySystemCLRDataTypes = SR.SchemaHierarchy_SystemCLRDataTypes;
+            var schemaHierarchySystemConfigurationFunctions = SR.SchemaHierarchy_SystemConfigurationFunctions;
+            var schemaHierarchySystemCursorFunctions = SR.SchemaHierarchy_SystemCursorFunctions;
+            var schemaHierarchySystemDataTypes = SR.SchemaHierarchy_SystemDataTypes;
+            var schemaHierarchySystemDateAndTime = SR.SchemaHierarchy_SystemDateAndTime;
+            var schemaHierarchySystemDateAndTimeFunctions = SR.SchemaHierarchy_SystemDateAndTimeFunctions;
+            var schemaHierarchySystemExactNumerics = SR.SchemaHierarchy_SystemExactNumerics;
+            var schemaHierarchySystemFunctions = SR.SchemaHierarchy_SystemFunctions;
+            var schemaHierarchySystemHierarchyIdFunctions = SR.SchemaHierarchy_SystemHierarchyIdFunctions;
+            var schemaHierarchySystemMathematicalFunctions = SR.SchemaHierarchy_SystemMathematicalFunctions;
+            var schemaHierarchySystemMetadataFunctionions = SR.SchemaHierarchy_SystemMetadataFunctions;
+            var schemaHierarchySystemOtherDataTypes = SR.SchemaHierarchy_SystemOtherDataTypes;
+            var schemaHierarchySystemOtherFunctions = SR.SchemaHierarchy_SystemOtherFunctions;
+            var schemaHierarchySystemRowsetFunctions = SR.SchemaHierarchy_SystemRowsetFunctions;
+            var schemaHierarchySystemSecurityFunctions = SR.SchemaHierarchy_SystemSecurityFunctions;
+            var schemaHierarchySystemSpatialDataTypes = SR.SchemaHierarchy_SystemSpatialDataTypes;
+            var schemaHierarchySystemStringFunctions = SR.SchemaHierarchy_SystemStringFunctions;
+            var schemaHierarchySystemSystemStatisticalFunctions = SR.SchemaHierarchy_SystemSystemStatisticalFunctions;
+            var schemaHierarchySystemTextAndImageFunctions = SR.SchemaHierarchy_SystemTextAndImageFunctions;
+            var schemaHierarchySystemUnicodeCharacterStrings = SR.SchemaHierarchy_SystemUnicodeCharacterStrings;
+            var schemaHierarchyAggregateFunctions = SR.SchemaHierarchy_AggregateFunctions;
+            var schemaHierarchyScalarValuedFunctions = SR.SchemaHierarchy_ScalarValuedFunctions;
+            var schemaHierarchyTableValuedFunctions = SR.SchemaHierarchy_TableValuedFunctions;
+            var schemaHierarchySystemExtendedStoredProcedures = SR.SchemaHierarchy_SystemExtendedStoredProcedures;
+            var schemaHierarchyBuiltInType = SR.SchemaHierarchy_BuiltInType;
+            var schemaHierarchyBuiltInServerRole = SR.SchemaHierarchy_BuiltInServerRole;
+            var schemaHierarchyUserWithPassword = SR.SchemaHierarchy_UserWithPassword;
+            var schemaHierarchySearchPropertyList = SR.SchemaHierarchy_SearchPropertyList;
+            var schemaHierarchySecurityPolicies = SR.SchemaHierarchy_SecurityPolicies;
+            var schemaHierarchySecurityPredicates = SR.SchemaHierarchy_SecurityPredicates;
+            var schemaHierarchyServerRole = SR.SchemaHierarchy_ServerRole;
+            var schemaHierarchySearchPropertyLists = SR.SchemaHierarchy_SearchPropertyLists;
+            var schemaHierarchyColumnStoreIndexes = SR.SchemaHierarchy_ColumnStoreIndexes;
+            var schemaHierarchyTableTypeIndexes = SR.SchemaHierarchy_TableTypeIndexes;
+            var schemaHierarchyServerInstance = SR.SchemaHierarchy_ServerInstance;
+            var schemaHierarchySelectiveXmlIndexes = SR.SchemaHierarchy_SelectiveXmlIndexes;
+            var schemaHierarchyXmlNamespaces = SR.SchemaHierarchy_XmlNamespaces;
+            var schemaHierarchyXmlTypedPromotedPaths = SR.SchemaHierarchy_XmlTypedPromotedPaths;
+            var schemaHierarchySqlTypedPromotedPaths = SR.SchemaHierarchy_SqlTypedPromotedPaths;
+            var schemaHierarchyDatabaseScopedCredentials = SR.SchemaHierarchy_DatabaseScopedCredentials;
+            var schemaHierarchyExternalDataSources = SR.SchemaHierarchy_ExternalDataSources;
+            var schemaHierarchyExternalFileFormats = SR.SchemaHierarchy_ExternalFileFormats;
+            var schemaHierarchyExternalResources = SR.SchemaHierarchy_ExternalResources;
+            var schemaHierarchyExternalTables = SR.SchemaHierarchy_ExternalTables;
+            var schemaHierarchyAlwaysEncryptedKeys = SR.SchemaHierarchy_AlwaysEncryptedKeys;
+            var schemaHierarchyColumnMasterKeys = SR.SchemaHierarchy_ColumnMasterKeys;
+            var schemaHierarchyColumnEncryptionKeys = SR.SchemaHierarchy_ColumnEncryptionKeys;
         }
 
         [Fact]

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Utility/ProtocolEndpointMocks.cs

@@ -0,0 +1,33 @@
+//
+// 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.Threading.Tasks;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.Hosting.Protocol.Contracts;
+using Moq;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Utility
+{
+    public static class ProtocolEndpointMocks
+    {
+        public static Mock<IProtocolEndpoint> AddEventHandling<TParams>(
+            this Mock<IProtocolEndpoint> mock,
+            EventType<TParams> expectedEvent,
+            Action<EventType<TParams>, TParams> eventCallback)
+        {
+            var flow = mock.Setup(h => h.SendEvent(
+                It.Is<EventType<TParams>>(m => m == expectedEvent),
+                It.IsAny<TParams>()))
+                .Returns(Task.FromResult(0));
+            if (eventCallback != null)
+            {
+                flow.Callback(eventCallback);
+            }
+
+            return mock;
+        }
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Utility/TestObjects.cs

@@ -53,6 +53,30 @@ namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Utility
             };
         }
 
+        public static ServerInfo GetTestServerInfo()
+        {
+            return new ServerInfo()
+            {
+                ServerVersion = "14.0.1.0",
+                ServerMajorVersion = 14,
+                ServerMinorVersion = 0,
+                EngineEditionId = 3,
+                OsVersion = "Linux (Ubuntu 15.10)",
+                IsCloud = false,
+                ServerEdition = "Developer Edition",
+                ServerLevel = ""
+            };
+        }
+
+        /// <summary>
+        /// Creates a test sql connection factory instance
+        /// </summary>
+        public static ISqlConnectionFactory GetTestSqlConnectionFactory()
+        {
+            // use mock database connection
+            return new TestSqlConnectionFactory();
+        }
+
         /// <summary>
         /// Creates a test connection details object
         /// </summary>