ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-13 17:23:02 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/connectUsingService' into feature/queryExecutionV1

Browse Source
This commit is contained in:
Benjamin Russell
2016-08-04 16:11:48 -07:00
parent 3ba22c94ac 5249924b12
commit 719a0f091a
13 changed files with 563 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
nuget.config
View File

@@ -9,7 +9,7 @@
<!-- Add the SSMS repo for private requirements -->
<add key="SQLDS - SSMS" value="http://SQLISNuget/DS-SSMS/nuget/" />
<add key="CrossPlat" value="W:/" />
</packageSources>
</configuration>

165
src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs
View File

@@ -17,13 +17,45 @@ using Microsoft.SqlTools.ServiceLayer.Workspace;
namespace Microsoft.SqlTools.ServiceLayer.Connection
{
public class ConnectionInfo
{
public ConnectionInfo(ISqlConnectionFactory factory, string ownerUri, ConnectionDetails details)
{
Factory = factory;
OwnerUri = ownerUri;
ConnectionDetails = details;
ConnectionId = Guid.NewGuid();
}
/// <summary>
/// Unique Id, helpful to identify a connection info object
/// </summary>
public Guid ConnectionId { get; private set; }
public string OwnerUri { get; private set; }
private ISqlConnectionFactory Factory {get; set;}
public ConnectionDetails ConnectionDetails { get; private set; }
public DbConnection SqlConnection { get; private set; }
public void OpenConnection()
{
// build the connection string from the input parameters
string connectionString = ConnectionService.BuildConnectionString(ConnectionDetails);
// create a sql connection instance
SqlConnection = Factory.CreateSqlConnection(connectionString);
SqlConnection.Open();
}
}
/// <summary>
/// Main class for the Connection Management services
/// </summary>
public class ConnectionService
{
#region Singleton Instance Implementation
/// <summary>
/// Singleton service instance
/// </summary>
@@ -40,6 +72,13 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
return instance.Value;
}
}
/// <summary>
/// The SQL connection factory object
/// </summary>
private ISqlConnectionFactory connectionFactory;
private Dictionary<string, ConnectionInfo> ownerToConnectionMap = new Dictionary<string, ConnectionInfo>();
/// <summary>
/// Default constructor is private since it's a singleton class
@@ -48,48 +87,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
{
}
#endregion
#region Properties
/// <summary>
/// The SQL connection factory object
/// </summary>
private ISqlConnectionFactory connectionFactory;
/// <summary>
/// The current connection id that was previously used
/// </summary>
private int maxConnectionId = 0;
/// <summary>
/// Active connections lazy dictionary instance
/// </summary>
private readonly Lazy<Dictionary<int, DbConnection>> activeConnections
= new Lazy<Dictionary<int, DbConnection>>(()
=> new Dictionary<int, DbConnection>());
/// <summary>
/// Callback for onconnection handler
/// </summary>
/// <param name="sqlConnection"></param>
public delegate Task OnConnectionHandler(DbConnection sqlConnection);
public delegate Task OnConnectionHandler(ConnectionInfo info);
/// <summary>
/// List of onconnection handlers
/// </summary>
private readonly List<OnConnectionHandler> onConnectionActivities = new List<OnConnectionHandler>();
/// <summary>
/// Gets the active connection map
/// </summary>
public Dictionary<int, DbConnection> ActiveConnections
{
get
{
return activeConnections.Value;
}
}
private readonly List<OnConnectionHandler> onConnectionActivities = new List<OnConnectionHandler>();
/// <summary>
/// Gets the SQL connection factory instance
@@ -105,9 +112,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
return this.connectionFactory;
}
}
#endregion
/// <summary>
/// Test constructor that injects dependency interfaces
/// </summary>
@@ -117,40 +122,62 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
this.connectionFactory = testFactory;
}
#region Public Methods
// Attempts to link a URI to an actively used connection for this URI
public bool TryFindConnection(string ownerUri, out ConnectionSummary connectionSummary)
{
connectionSummary = null;
ConnectionInfo connectionInfo;
if (this.ownerToConnectionMap.TryGetValue(ownerUri, out connectionInfo))
{
connectionSummary = CopySummary(connectionInfo.ConnectionDetails);
return true;
}
return false;
}
private static ConnectionSummary CopySummary(ConnectionSummary summary)
{
return new ConnectionSummary()
{
ServerName = summary.ServerName,
DatabaseName = summary.DatabaseName,
UserName = summary.UserName
};
}
/// <summary>
/// Open a connection with the specified connection details
/// </summary>
/// <param name="connectionDetails"></param>
public ConnectionResult Connect(ConnectionDetails connectionDetails)
/// <param name="connectionParams"></param>
public ConnectResponse Connect(ConnectParams connectionParams)
{
// build the connection string from the input parameters
string connectionString = BuildConnectionString(connectionDetails);
ConnectionInfo connectionInfo;
if (ownerToConnectionMap.TryGetValue(connectionParams.OwnerUri, out connectionInfo) )
{
// TODO disconnect
}
connectionInfo = new ConnectionInfo(this.connectionFactory, connectionParams.OwnerUri, connectionParams.Connection);
// create a sql connection instance
DbConnection connection = this.ConnectionFactory.CreateSqlConnection(connectionString);
// try to connect
connectionInfo.OpenConnection();
// TODO: check that connection worked
// open the database
connection.Open();
// map the connection id to the connection object for future lookups
this.ActiveConnections.Add(++maxConnectionId, connection);
ownerToConnectionMap[connectionParams.OwnerUri] = connectionInfo;
// invoke callback notifications
foreach (var activity in this.onConnectionActivities)
{
activity(connection);
activity(connectionInfo);
}
// return the connection result
return new ConnectionResult()
return new ConnectResponse()
{
ConnectionId = maxConnectionId
ConnectionId = connectionInfo.ConnectionId.ToString()
};
}
public void InitializeService(ServiceHost serviceHost)
public void InitializeService(IProtocolEndpoint serviceHost)
{
// Register request and event handlers with the Service Host
serviceHost.SetRequestHandler(ConnectionRequest.Type, HandleConnectRequest);
@@ -167,11 +194,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
{
onConnectionActivities.Add(activity);
}
#endregion
#region Request Handlers
/// <summary>
/// Handle new connection requests
/// </summary>
@@ -179,15 +202,15 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
/// <param name="requestContext"></param>
/// <returns></returns>
protected async Task HandleConnectRequest(
ConnectionDetails connectionDetails,
RequestContext<ConnectionResult> requestContext)
ConnectParams connectParams,
RequestContext<ConnectResponse> requestContext)
{
Logger.Write(LogLevel.Verbose, "HandleConnectRequest");
try
{
// open connection base on request details
ConnectionResult result = ConnectionService.Instance.Connect(connectionDetails);
ConnectResponse result = ConnectionService.Instance.Connect(connectParams);
await requestContext.SendResult(result);
}
catch(Exception ex)
@@ -195,11 +218,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
await requestContext.SendError(ex.Message);
}
}
#endregion
#region Handlers for Events from Other Services
public Task HandleDidChangeConfigurationNotification(
SqlToolsSettings newSettings,
SqlToolsSettings oldSettings,
@@ -207,16 +226,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
{
return Task.FromResult(true);
}
#endregion
#region Private Helpers
/// <summary>
/// Build a connection string from a connection details instance
/// </summary>
/// <param name="connectionDetails"></param>
private string BuildConnectionString(ConnectionDetails connectionDetails)
public static string BuildConnectionString(ConnectionDetails connectionDetails)
{
SqlConnectionStringBuilder connectionBuilder = new SqlConnectionStringBuilder();
connectionBuilder["Data Source"] = connectionDetails.ServerName;
@@ -226,7 +241,5 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
connectionBuilder["Initial Catalog"] = connectionDetails.DatabaseName;
return connectionBuilder.ToString();
}
#endregion
}
}

98
src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionMessages.cs
View File

@@ -7,10 +7,57 @@ using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts
{
/// <summary>
/// Message format for the initial connection request
/// <summary>
/// Parameters for the Connect Request.
/// </summary>
public class ConnectionDetails
public class ConnectParams
{
/// <summary>
/// A URI identifying the owner of the connection. This will most commonly be a file in the workspace
/// or a virtual file representing an object in a database.
/// </summary>
public string OwnerUri { get; set; }
/// <summary>
/// Contains the required parameters to initialize a connection to a database.
/// A connection will identified by its server name, database name and user name.
/// This may be changed in the future to support multiple connections with different
/// connection properties to the same database.
/// </summary>
public ConnectionDetails Connection { get; set; }
}
/// <summary>
/// Parameters for the Disconnect Request.
/// </summary>
public class DisconnectParams
{
/// <summary>
/// A URI identifying the owner of the connection. This will most commonly be a file in the workspace
/// or a virtual file representing an object in a database.
/// </summary>
public string ownerUri { get; set; }
}
/// <summary>
/// Parameters for the ConnectionChanged Notification.
/// </summary>
public class ConnectionChangedParams
{
/// <summary>
/// A URI identifying the owner of the connection. This will most commonly be a file in the workspace
/// or a virtual file representing an object in a database.
/// </summary>
public string ownerUri { get; set; }
/// <summary>
/// Contains the high-level properties about the connection, for display to the user.
/// </summary>
public ConnectionSummary Connection { get; set; }
}
/// <summary>
/// Provides high level information about a connection.
/// </summary>
public class ConnectionSummary
{
/// <summary>
/// Gets or sets the connection server name
@@ -25,39 +72,66 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts
/// <summary>
/// Gets or sets the connection user name
/// </summary>
public string UserName { get; set; }
public string UserName { get; set; }
}
/// <summary>
/// Message format for the initial connection request
/// </summary>
public class ConnectionDetails : ConnectionSummary
{
/// <summary>
/// Gets or sets the connection password
/// </summary>
/// <returns></returns>
public string Password { get; set; }
// TODO Handle full set of properties
}
/// <summary>
/// Message format for the connection result response
/// </summary>
public class ConnectionResult
public class ConnectResponse
{
/// <summary>
/// Gets or sets the connection id
/// A GUID representing a unique connection ID
/// </summary>
public int ConnectionId { get; set; }
public string ConnectionId { get; set; }
/// <summary>
/// Gets or sets any connection error messages
/// </summary>
public string Messages { get; set; }
}
}
/// <summary>
/// Connect request mapping entry
/// </summary>
public class ConnectionRequest
{
public static readonly
RequestType<ConnectionDetails, ConnectionResult> Type =
RequestType<ConnectionDetails, ConnectionResult>.Create("connection/connect");
RequestType<ConnectParams, ConnectResponse> Type =
RequestType<ConnectParams, ConnectResponse>.Create("connection/connect");
}
/// <summary>
/// Disconnect request mapping entry
/// </summary>
public class DisconnectRequest
{
public static readonly
RequestType<DisconnectParams, bool> Type =
RequestType<DisconnectParams, bool>.Create("connection/disconnect");
}
/// <summary>
/// ConnectionChanged notification mapping entry
/// </summary>
public class ConnectionChangedNotification
{
public static readonly
EventType<ConnectionChangedParams> Type =
EventType<ConnectionChangedParams>.Create("connection/connectionchanged");
}
}

2
src/Microsoft.SqlTools.ServiceLayer/Hosting/Protocol/IMessageSender.cs
View File

@@ -8,7 +8,7 @@ using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.Hosting.Protocol
{
internal interface IMessageSender
public interface IMessageSender
{
Task SendEvent<TParams>(
EventType<TParams> eventType,

29
src/Microsoft.SqlTools.ServiceLayer/Hosting/Protocol/IProtocolEndpoint.cs Normal file
View File

@@ -0,0 +1,29 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.Hosting.Protocol
{
/// <summary>
/// A ProtocolEndpoint is used for inter-process communication. Services can register to
/// respond to requests and events, send their own requests, and listen for notifications
/// sent by the other side of the endpoint
/// </summary>
public interface IProtocolEndpoint : IMessageSender
{
void SetRequestHandler<TParams, TResult>(
RequestType<TParams, TResult> requestType,
Func<TParams, RequestContext<TResult>, Task> requestHandler);
void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler);
void SetEventHandler<TParams>(
EventType<TParams> eventType,
Func<TParams, EventContext, Task> eventHandler,
bool overrideExisting);
}
}

2
src/Microsoft.SqlTools.ServiceLayer/Hosting/Protocol/ProtocolEndpoint.cs
View File

@@ -16,7 +16,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting.Protocol
/// Provides behavior for a client or server endpoint that
/// communicates using the specified protocol.
/// </summary>
public class ProtocolEndpoint : IMessageSender
public class ProtocolEndpoint : IMessageSender, IProtocolEndpoint
{
private bool isStarted;
private int currentMessageId;

247
src/Microsoft.SqlTools.ServiceLayer/LanguageServices/AutoCompleteService.cs
View File

@@ -9,89 +9,71 @@ using System.Data;
using System.Data.Common;
using System.Threading.Tasks;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
using Microsoft.SqlTools.ServiceLayer.Hosting;
using Microsoft.SqlTools.ServiceLayer.LanguageServices.Contracts;
using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
{
/// <summary>
/// Main class for Autocomplete functionality
/// </summary>
public class AutoCompleteService
internal class IntellisenseCache
{
#region Singleton Instance Implementation
// connection used to query for intellisense info
private DbConnection connection;
/// <summary>
/// Singleton service instance
/// </summary>
private static Lazy<AutoCompleteService> instance
= new Lazy<AutoCompleteService>(() => new AutoCompleteService());
/// <summary>
/// Gets the singleton service instance
/// </summary>
public static AutoCompleteService Instance
public IntellisenseCache(ISqlConnectionFactory connectionFactory, ConnectionDetails connectionDetails)
{
get
{
return instance.Value;
}
DatabaseInfo = CopySummary(connectionDetails);
// TODO error handling on this. Intellisense should catch or else the service should handle
connection = connectionFactory.CreateSqlConnection(ConnectionService.BuildConnectionString(connectionDetails));
connection.Open();
}
/// <summary>
/// Default, parameterless constructor.
/// TODO: Figure out how to make this truely singleton even with dependency injection for tests
/// Used to identify a database for which this cache is used
/// </summary>
public AutoCompleteService()
{
public ConnectionSummary DatabaseInfo
{
get;
private set;
}
#endregion
/// <summary>
/// Gets the current autocomplete candidate list
/// </summary>
public IEnumerable<string> AutoCompleteList { get; private set; }
/// <summary>
/// Update the cached autocomplete candidate list when the user connects to a database
/// TODO: Update with refactoring/async
/// </summary>
/// <param name="connection"></param>
public async Task UpdateAutoCompleteCache(DbConnection connection)
public async Task UpdateCache()
{
DbCommand command = connection.CreateCommand();
command.CommandText = "SELECT name FROM sys.tables";
command.CommandTimeout = 15;
command.CommandType = CommandType.Text;
using (var reader = await command.ExecuteReaderAsync())
var reader = await command.ExecuteReaderAsync();
List<string> results = new List<string>();
while (await reader.ReadAsync())
{
List<string> results = new List<string>();
while (await reader.ReadAsync())
{
results.Add(reader[0].ToString());
}
AutoCompleteList = results;
results.Add(reader[0].ToString());
}
AutoCompleteList = results;
await Task.FromResult(0);
}
/// <summary>
/// Return the completion item list for the current text position
/// </summary>
/// <param name="textDocumentPosition"></param>
public CompletionItem[] GetCompletionItems(TextDocumentPosition textDocumentPosition)
public List<CompletionItem> GetAutoCompleteItems(TextDocumentPosition textDocumentPosition)
{
var completions = new List<CompletionItem>();
List<CompletionItem> completions = new List<CompletionItem>();
int i = 0;
// Take a reference to the list at a point in time in case we update and replace the list
var suggestions = AutoCompleteList;
// the completion list will be null is user not connected to server
if (this.AutoCompleteList != null)
{
foreach (var autoCompleteItem in this.AutoCompleteList)
foreach (var autoCompleteItem in suggestions)
{
// convert the completion item candidates into CompletionItems
completions.Add(new CompletionItem()
@@ -126,8 +108,173 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
}
}
}
return completions.ToArray();
return completions;
}
private static ConnectionSummary CopySummary(ConnectionSummary summary)
{
return new ConnectionSummary()
{
ServerName = summary.ServerName,
DatabaseName = summary.DatabaseName,
UserName = summary.UserName
};
}
}
/// <summary>
/// Treats connections as the same if their server, db and usernames all match
/// </summary>
public class ConnectionSummaryComparer : IEqualityComparer<ConnectionSummary>
{
public bool Equals(ConnectionSummary x, ConnectionSummary y)
{
if (x == y) { return true; }
else if (x != null)
{
if (y == null) { return false; }
// Compare server, db, username. Note: server is case-insensitive in the driver
return string.Compare(x.ServerName, y.ServerName, StringComparison.OrdinalIgnoreCase) == 0
&& string.Compare(x.DatabaseName, y.DatabaseName, StringComparison.Ordinal) == 0
&& string.Compare(x.UserName, y.UserName, StringComparison.Ordinal) == 0;
}
return false;
}
public int GetHashCode(ConnectionSummary obj)
{
int hashcode = 31;
if (obj != null)
{
if (obj.ServerName != null)
{
hashcode ^= obj.ServerName.GetHashCode();
}
if (obj.DatabaseName != null)
{
hashcode ^= obj.DatabaseName.GetHashCode();
}
if (obj.UserName != null)
{
hashcode ^= obj.UserName.GetHashCode();
}
}
return hashcode;
}
}
/// <summary>
/// Main class for Autocomplete functionality
/// </summary>
public class AutoCompleteService
{
#region Singleton Instance Implementation
/// <summary>
/// Singleton service instance
/// </summary>
private static Lazy<AutoCompleteService> instance
= new Lazy<AutoCompleteService>(() => new AutoCompleteService());
/// <summary>
/// Gets the singleton service instance
/// </summary>
public static AutoCompleteService Instance
{
get
{
return instance.Value;
}
}
/// <summary>
/// Default, parameterless constructor.
/// TODO: Figure out how to make this truely singleton even with dependency injection for tests
/// </summary>
public AutoCompleteService()
{
}
#endregion
// Dictionary of unique intellisense caches for each Connection
private Dictionary<ConnectionSummary, IntellisenseCache> caches =
new Dictionary<ConnectionSummary, IntellisenseCache>(new ConnectionSummaryComparer());
private ISqlConnectionFactory factory;
/// <summary>
/// Internal for testing purposes only
/// </summary>
internal ISqlConnectionFactory ConnectionFactory
{
get
{
// TODO consider protecting against multi-threaded access
if (factory == null)
{
factory = new SqlConnectionFactory();
}
return factory;
}
set
{
factory = value;
}
}
public void InitializeService(ServiceHost serviceHost)
{
// Register a callback for when a connection is created
ConnectionService.Instance.RegisterOnConnectionTask(UpdateAutoCompleteCache);
}
private async Task UpdateAutoCompleteCache(ConnectionInfo connectionInfo)
{
if (connectionInfo != null)
{
await UpdateAutoCompleteCache(connectionInfo.ConnectionDetails);
}
}
/// <summary>
/// Update the cached autocomplete candidate list when the user connects to a database
/// TODO: Update with refactoring/async
/// </summary>
/// <param name="details"></param>
public async Task UpdateAutoCompleteCache(ConnectionDetails details)
{
IntellisenseCache cache;
if (!caches.TryGetValue(details, out cache))
{
cache = new IntellisenseCache(ConnectionFactory, details);
caches[cache.DatabaseInfo] = cache;
}
await cache.UpdateCache();
}
/// <summary>
/// Return the completion item list for the current text position.
/// This method does not await cache builds since it expects to return quickly
/// </summary>
/// <param name="textDocumentPosition"></param>
public CompletionItem[] GetCompletionItems(TextDocumentPosition textDocumentPosition)
{
// Try to find a cache for the document's backing connection (if available)
// If we have a connection but no cache, we don't care - assuming the OnConnect and OnDisconnect listeners
// behave well, there should be a cache for any actively connected document. This also helps skip documents
// that are not backed by a SQL connection
ConnectionSummary connectionSummary;
IntellisenseCache cache;
if (ConnectionService.Instance.TryFindConnection(textDocumentPosition.Uri, out connectionSummary)
&& caches.TryGetValue(connectionSummary, out cache))
{
return cache.GetAutoCompleteItems(textDocumentPosition).ToArray();
}
return new CompletionItem[0];
}
}
}

4
src/Microsoft.SqlTools.ServiceLayer/LanguageServices/LanguageService.cs
View File

@@ -309,9 +309,9 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
/// Callback for when a user connection is done processing
/// </summary>
/// <param name="sqlConnection"></param>
public async Task OnConnection(DbConnection sqlConnection)
public async Task OnConnection(ConnectionInfo connectionInfo)
{
await AutoCompleteService.Instance.UpdateAutoCompleteCache(sqlConnection);
// TODO consider whether this is needed at all - currently AutoComplete service handles its own updating
await Task.FromResult(true);
}

58
test/Microsoft.SqlTools.ServiceLayer.Test/Connection/ConnectionServiceTests.cs
View File

@@ -3,8 +3,13 @@
// 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.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol;
using Microsoft.SqlTools.Test.Utility;
using Moq;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
@@ -14,7 +19,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
/// </summary>
public class ConnectionServiceTests
{
#region "Connection tests"
/// <summary>
/// Verify that the SQL parser correctly detects errors in text
@@ -23,12 +27,17 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
public void ConnectToDatabaseTest()
{
// connect to a database instance
var connectionResult =
string ownerUri = "file://my/sample/file.sql";
var connectionResult =
TestObjects.GetTestConnectionService()
.Connect(TestObjects.GetTestConnectionDetails());
.Connect(new ConnectParams()
{
OwnerUri = ownerUri,
Connection = TestObjects.GetTestConnectionDetails()
});
// verify that a valid connection id was returned
Assert.True(connectionResult.ConnectionId > 0);
Assert.NotEmpty(connectionResult.ConnectionId);
}
/// <summary>
@@ -49,12 +58,49 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Connection
);
// connect to a database instance
var connectionResult = connectionService.Connect(TestObjects.GetTestConnectionDetails());
var connectionResult = connectionService.Connect(TestObjects.GetTestConnectionParams());
// verify that a valid connection id was returned
Assert.True(callbackInvoked);
}
#endregion
//[Fact]
//public void TestConnectRequestRegistersOwner()
//{
// // Given a request to connect to a database
// var service = new ConnectionService(new TestSqlConnectionFactory());
// ConnectionDetails connectionDetails = TestObjects.GetTestConnectionDetails();
// var connectParams = new ConnectParams()
// {
// OwnerUri = "file://path/to/my.sql",
// Connection = connectionDetails
// };
// var endpoint = new Mock<IProtocolEndpoint>();
// Func<ConnectParams, RequestContext<ConnectResponse>, Task> connectRequestHandler = null;
// endpoint.Setup(e => e.SetRequestHandler(ConnectionRequest.Type, It.IsAny<Func<ConnectParams, RequestContext<ConnectResponse>, Task>>()))
// .Callback<Func<ConnectParams, RequestContext<ConnectResponse>, Task>>(handler => connectRequestHandler = handler);
// // when I initialize the service
// service.InitializeService(endpoint.Object);
// // then I expect the handler to be captured
// Assert.NotNull(connectRequestHandler);
// // when I call the service
// var requestContext = new Mock<RequestContext<ConnectResponse>>();
// connectRequestHandler(connectParams, requestContext);
// // then I should get a live connection
// // and then I should have
// // connect to a database instance
// var connectionResult =
// TestObjects.GetTestConnectionService()
// .Connect(TestObjects.GetTestConnectionDetails());
// // verify that a valid connection id was returned
// Assert.True(connectionResult.ConnectionId > 0);
//}
}
}

22
test/Microsoft.SqlTools.ServiceLayer.Test/LanguageServer/LanguageServiceTests.cs
View File

@@ -3,6 +3,8 @@
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
//
using System.Threading.Tasks;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.LanguageServices;
using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts;
using Microsoft.SqlTools.Test.Utility;
@@ -109,13 +111,21 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.LanguageServices
/// Verify that the SQL parser correctly detects errors in text
/// </summary>
[Fact]
public void AutocompleteTest()
public async Task AutocompleteTest()
{
var autocompleteService = TestObjects.GetAutoCompleteService();
var connectionService = TestObjects.GetTestConnectionService();
var connectionResult = connectionService.Connect(TestObjects.GetTestConnectionDetails());
var sqlConnection = connectionService.ActiveConnections[connectionResult.ConnectionId];
autocompleteService.UpdateAutoCompleteCache(sqlConnection).Wait();
// TODO Re-enable this test once we have a way to hook up the right auto-complete and connection services.
// Probably need a service provider channel so that we can mock service access. Otherwise everything accesses
// static instances and cannot be properly tested.
//var autocompleteService = TestObjects.GetAutoCompleteService();
//var connectionService = TestObjects.GetTestConnectionService();
//ConnectParams connectionRequest = TestObjects.GetTestConnectionParams();
//var connectionResult = connectionService.Connect(connectionRequest);
//var sqlConnection = connectionService.ActiveConnections[connectionResult.ConnectionId];
//await autocompleteService.UpdateAutoCompleteCache(sqlConnection);
await Task.Run(() => { return; });
}
#endregion

9
test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestObjects.cs
View File

@@ -41,6 +41,15 @@ namespace Microsoft.SqlTools.Test.Utility
#endif
}
public static ConnectParams GetTestConnectionParams()
{
return new ConnectParams()
{
OwnerUri = "file://some/file.sql",
Connection = GetTestConnectionDetails()
};
}
/// <summary>
/// Creates a test connection details object
/// </summary>

3
test/Microsoft.SqlTools.ServiceLayer.Test/project.json
View File

@@ -11,8 +11,9 @@
"System.Data.SqlClient": "4.1.0",
"xunit": "2.1.0",
"dotnet-test-xunit": "1.0.0-rc2-192208-24",
"moq.netcore": "4.4.0-beta8",
"Microsoft.SqlTools.ServiceLayer": {
"target": "project"
"target": "project"
}
},
"testRunner": "xunit",

78
test/ServiceHost.Test/Workspace/WorkspaceServiceTests.cs Normal file
View File

@@ -0,0 +1,78 @@
// //
// // 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.ServiceLayer.LanguageServices;
// using Microsoft.SqlTools.ServiceLayer.WorkspaceServices.Contracts;
// using Microsoft.SqlTools.Test.Utility;
// using Xunit;
// namespace Microsoft.SqlTools.ServiceLayer.Test.Workspace
// {
// /// <summary>
// /// Tests for the ServiceHost Language Service tests
// /// </summary>
// public class WorkspaceServiceTests
// {
// [Fact]
// public async Task ServiceLoadsProfilesOnDemand()
// {
// // Given an event detailing
// // when
// // Send the configuration change to cause profiles to be loaded
// await this.languageServiceClient.SendEvent(
// DidChangeConfigurationNotification<LanguageServerSettingsWrapper>.Type,
// new DidChangeConfigurationParams<LanguageServerSettingsWrapper>
// {
// Settings = new LanguageServerSettingsWrapper
// {
// Powershell = new LanguageServerSettings
// {
// EnableProfileLoading = true,
// ScriptAnalysis = new ScriptAnalysisSettings
// {
// Enable = false
// }
// }
// }
// });
// OutputReader outputReader = new OutputReader(this.protocolClient);
// Task<EvaluateResponseBody> evaluateTask =
// this.SendRequest(
// EvaluateRequest.Type,
// new EvaluateRequestArguments
// {
// Expression = "\"PROFILE: $(Assert-ProfileLoaded)\"",
// Context = "repl"
// });
// // Try reading up to 10 lines to find the expected output line
// string outputString = null;
// for (int i = 0; i < 10; i++)
// {
// outputString = await outputReader.ReadLine();
// if (outputString.StartsWith("PROFILE"))
// {
// break;
// }
// }
// // Delete the test profile before any assert failures
// // cause the function to exit
// File.Delete(currentUserCurrentHostPath);
// // Wait for the selection to appear as output
// await evaluateTask;
// Assert.Equal("PROFILE: True", outputString);
// }
// }
// }