ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-14 01:25:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

Second batch of unit tests

Browse Source 
Making slight changes to RequestContext to make it easier to mock
This commit is contained in:
Benjamin Russell
2016-08-09 11:10:54 -07:00
parent 9f371cd0bc
commit d783fd505b
7 changed files with 387 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/Microsoft.SqlTools.ServiceLayer/Hosting/Protocol/RequestContext.cs
View File

@@ -20,7 +20,9 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting.Protocol
this.messageWriter = messageWriter;
}
public async Task SendResult(TResult resultDetails)
public RequestContext() { }
public virtual async Task SendResult(TResult resultDetails)
{
await this.messageWriter.WriteResponse<TResult>(
resultDetails,
@@ -28,14 +30,14 @@ namespace Microsoft.SqlTools.ServiceLayer.Hosting.Protocol
requestMessage.Id);
}
public async Task SendEvent<TParams>(EventType<TParams> eventType, TParams eventParams)
public virtual async Task SendEvent<TParams>(EventType<TParams> eventType, TParams eventParams)
{
await this.messageWriter.WriteEvent(
eventType,
eventParams);
}
public async Task SendError(object errorDetails)
public virtual async Task SendError(object errorDetails)
{
await this.messageWriter.WriteMessage(
Message.ResponseError(

20
src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs
View File

@@ -19,7 +19,15 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
get { return instance.Value; }
}
private QueryExecutionService() { }
private QueryExecutionService()
{
ConnectionService = ConnectionService.Instance;
}
internal QueryExecutionService(ConnectionService connService)
{
ConnectionService = connService;
}
#endregion
@@ -33,6 +41,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
get { return queries.Value; }
}
private ConnectionService ConnectionService { get; set; }
#endregion
#region Public Methods
@@ -55,12 +65,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
#region Request Handlers
private async Task HandleExecuteRequest(QueryExecuteParams executeParams,
public async Task HandleExecuteRequest(QueryExecuteParams executeParams,
RequestContext<QueryExecuteResult> requestContext)
{
// Attempt to get the connection for the editor
ConnectionInfo connectionInfo;
if(!ConnectionService.Instance.TryFindConnection(executeParams.OwnerUri, out connectionInfo))
if(!ConnectionService.TryFindConnection(executeParams.OwnerUri, out connectionInfo))
{
await requestContext.SendError("This editor is not connected to a database.");
return;
@@ -94,7 +104,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
await requestContext.SendEvent(QueryExecuteCompleteEvent.Type, eventParams);
}
private async Task HandleResultSubsetRequest(QueryExecuteSubsetParams subsetParams,
public async Task HandleResultSubsetRequest(QueryExecuteSubsetParams subsetParams,
RequestContext<QueryExecuteSubsetResult> requestContext)
{
// Attempt to load the query
@@ -129,7 +139,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
}
}
private async Task HandleDisposeRequest(QueryDisposeParams disposeParams,
public async Task HandleDisposeRequest(QueryDisposeParams disposeParams,
RequestContext<QueryDisposeResult> requestContext)
{
// Attempt to remove the query for the owner uri

142
test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/Common.cs Normal file
View File

@@ -0,0 +1,142 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
using Microsoft.SqlTools.ServiceLayer.QueryExecution;
using Microsoft.SqlTools.ServiceLayer.Test.Utility;
using Moq;
using Moq.Protected;
namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
{
public class Common
{
public static readonly Dictionary<string, string>[] StandardTestData =
{
new Dictionary<string, string> { {"col1", "val11"}, { "col2", "val12"}, { "col3", "val13"}, { "col4", "col14"} },
new Dictionary<string, string> { {"col1", "val21"}, { "col2", "val22"}, { "col3", "val23"}, { "col4", "col24"} },
new Dictionary<string, string> { {"col1", "val31"}, { "col2", "val32"}, { "col3", "val33"}, { "col4", "col34"} },
new Dictionary<string, string> { {"col1", "val41"}, { "col2", "val42"}, { "col3", "val43"}, { "col4", "col44"} },
new Dictionary<string, string> { {"col1", "val51"}, { "col2", "val52"}, { "col3", "val53"}, { "col4", "col54"} },
};
public static Dictionary<string, string>[] GetTestData(int columns, int rows)
{
Dictionary<string, string>[] output = new Dictionary<string, string>[rows];
for (int row = 0; row < rows; row++)
{
Dictionary<string, string> rowDictionary = new Dictionary<string, string>();
for (int column = 0; column < columns; column++)
{
rowDictionary.Add(String.Format("column{0}", column), String.Format("val{0}{1}", column, row));
}
output[row] = rowDictionary;
}
return output;
}
public static Query GetBasicExecutedQuery()
{
Query query = new Query("SIMPLE QUERY", CreateTestConnectionInfo(new[] { StandardTestData }, false));
query.Execute().Wait();
return query;
}
#region Mocking
//private static DbDataReader CreateTestReader(int columnCount, int rowCount)
//{
// var readerMock = new Mock<DbDataReader> { CallBase = true };
// // Setup for column reads
// // TODO: We can't test columns because of oddities with how datatable/GetColumn
// // Setup for row reads
// var readSequence = readerMock.SetupSequence(dbReader => dbReader.Read());
// for (int i = 0; i < rowCount; i++)
// {
// readSequence.Returns(true);
// }
// readSequence.Returns(false);
// // Make sure that if we call for data from the reader it works
// readerMock.Setup(dbReader => dbReader[InColumnRange(columnCount)])
// .Returns<object>(i => i.ToString());
// readerMock.Setup(dbReader => dbReader[NotInColumnRange(columnCount)])
// .Throws(new ArgumentOutOfRangeException());
// readerMock.Setup(dbReader => dbReader.HasRows)
// .Returns(rowCount > 0);
// return readerMock.Object;
//}
//private static int InColumnRange(int columnCount)
//{
// return Match.Create<int>(i => i < columnCount && i > 0);
//}
//private static int NotInColumnRange(int columnCount)
//{
// return Match.Create<int>(i => i >= columnCount || i < 0);
//}
public static DbCommand CreateTestCommand(Dictionary<string, string>[][] data, bool throwOnRead)
{
var commandMock = new Mock<DbCommand> { CallBase = true };
var commandMockSetup = commandMock.Protected()
.Setup<DbDataReader>("ExecuteDbDataReader", It.IsAny<CommandBehavior>());
// Setup the expected behavior
if (throwOnRead)
{
commandMockSetup.Throws(new Mock<DbException>().Object);
}
else
{
commandMockSetup.Returns(new TestDbDataReader(data));
}
return commandMock.Object;
}
public static DbConnection CreateTestConnection(Dictionary<string, string>[][] data, bool throwOnRead)
{
var connectionMock = new Mock<DbConnection> { CallBase = true };
connectionMock.Protected()
.Setup<DbCommand>("CreateDbCommand")
.Returns(CreateTestCommand(data, throwOnRead));
return connectionMock.Object;
}
public static ISqlConnectionFactory CreateMockFactory(Dictionary<string, string>[][] data, bool throwOnRead)
{
var mockFactory = new Mock<ISqlConnectionFactory>();
mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny<string>()))
.Returns(CreateTestConnection(data, throwOnRead));
return mockFactory.Object;
}
public static ConnectionInfo CreateTestConnectionInfo(Dictionary<string, string>[][] data, bool throwOnRead)
{
// Create connection info
ConnectionDetails connDetails = new ConnectionDetails
{
UserName = "sa",
Password = "Yukon900",
DatabaseName = "AdventureWorks2016CTP3_2",
ServerName = "sqltools11"
};
return new ConnectionInfo(CreateMockFactory(data, throwOnRead), "test://test", connDetails);
}
#endregion
}
}

137
test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/ExecuteTests.cs
View File

@@ -1,35 +1,18 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Data.Common;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
using Microsoft.SqlTools.ServiceLayer.QueryExecution;
using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
using Microsoft.SqlTools.ServiceLayer.Test.Utility;
using Moq;
using Moq.Protected;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
{
public class ExecuteTests
{
private static Dictionary<string, string>[] testData =
{
new Dictionary<string, string> { {"col1", "val11"}, { "col2", "val12"}, { "col3", "val13"}, { "col4", "col14"} },
new Dictionary<string, string> { {"col1", "val21"}, { "col2", "val22"}, { "col3", "val23"}, { "col4", "col24"} },
new Dictionary<string, string> { {"col1", "val31"}, { "col2", "val32"}, { "col3", "val33"}, { "col4", "col34"} },
new Dictionary<string, string> { {"col1", "val41"}, { "col2", "val42"}, { "col3", "val43"}, { "col4", "col44"} },
new Dictionary<string, string> { {"col1", "val51"}, { "col2", "val52"}, { "col3", "val53"}, { "col4", "col54"} },
};
[Fact]
public void QueryCreationTest()
{
// If I create a new query...
Query query = new Query("NO OP", CreateTestConnectionInfo(null));
Query query = new Query("NO OP", Common.CreateTestConnectionInfo(null, false));
// Then:
// ... It should not have executed
@@ -44,7 +27,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
public void QueryExecuteNoResultSets()
{
// If I execute a query that should get no result sets
Query query = new Query("Query with no result sets", CreateTestConnectionInfo(null));
Query query = new Query("Query with no result sets", Common.CreateTestConnectionInfo(null, false));
query.Execute().Wait();
// Then:
@@ -63,7 +46,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
[Fact]
public void QueryExecuteQueryOneResultSet()
{
ConnectionInfo ci = CreateTestConnectionInfo(new[] {testData});
ConnectionInfo ci = Common.CreateTestConnectionInfo(new[] {Common.StandardTestData}, false);
// If I execute a query that should get one result set
int resultSets = 1;
@@ -99,11 +82,11 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
[Fact]
public void QueryExecuteQueryTwoResultSets()
{
var dataset = new[] {testData, testData};
var dataset = new[] {Common.StandardTestData, Common.StandardTestData};
int resultSets = dataset.Length;
int rows = testData.Length;
int columns = testData[0].Count;
ConnectionInfo ci = CreateTestConnectionInfo(dataset);
int rows = Common.StandardTestData.Length;
int columns = Common.StandardTestData[0].Count;
ConnectionInfo ci = Common.CreateTestConnectionInfo(dataset, false);
// If I execute a query that should get two result sets
Query query = new Query("Query with two result sets", ci);
@@ -139,87 +122,43 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
}
}
#region Mocking
//private static DbDataReader CreateTestReader(int columnCount, int rowCount)
//{
// var readerMock = new Mock<DbDataReader> { CallBase = true };
// // Setup for column reads
// // TODO: We can't test columns because of oddities with how datatable/GetColumn
// // Setup for row reads
// var readSequence = readerMock.SetupSequence(dbReader => dbReader.Read());
// for (int i = 0; i < rowCount; i++)
// {
// readSequence.Returns(true);
// }
// readSequence.Returns(false);
// // Make sure that if we call for data from the reader it works
// readerMock.Setup(dbReader => dbReader[InColumnRange(columnCount)])
// .Returns<object>(i => i.ToString());
// readerMock.Setup(dbReader => dbReader[NotInColumnRange(columnCount)])
// .Throws(new ArgumentOutOfRangeException());
// readerMock.Setup(dbReader => dbReader.HasRows)
// .Returns(rowCount > 0);
// return readerMock.Object;
//}
//private static int InColumnRange(int columnCount)
//{
// return Match.Create<int>(i => i < columnCount && i > 0);
//}
//private static int NotInColumnRange(int columnCount)
//{
// return Match.Create<int>(i => i >= columnCount || i < 0);
//}
private static DbCommand CreateTestCommand(Dictionary<string, string>[][] data)
[Fact]
public void QueryExecuteInvalidQuery()
{
var commandMock = new Mock<DbCommand> {CallBase = true};
commandMock.Protected()
.Setup<DbDataReader>("ExecuteDbDataReader", It.IsAny<CommandBehavior>())
.Returns(new TestDbDataReader(data));
ConnectionInfo ci = Common.CreateTestConnectionInfo(null, true);
return commandMock.Object;
// If I execute a query that is invalid
Query query = new Query("Invalid query", ci);
// Then:
// ... It should throw an exception
Exception e = Assert.Throws<AggregateException>(() => query.Execute().Wait());
}
private static DbConnection CreateTestConnection(Dictionary<string, string>[][] data)
[Fact]
public void QueryExecuteExecutedQuery()
{
var connectionMock = new Mock<DbConnection> {CallBase = true};
connectionMock.Protected()
.Setup<DbCommand>("CreateDbCommand")
.Returns(CreateTestCommand(data));
ConnectionInfo ci = Common.CreateTestConnectionInfo(new[] {Common.StandardTestData}, false);
return connectionMock.Object;
// If I execute a query
Query query = new Query("Any query", ci);
query.Execute().Wait();
// Then:
// ... It should have executed
Assert.True(query.HasExecuted, "The query should have been marked executed.");
// If I execute it again
// Then:
// ... It should throw an invalid operation exception wrapped in an aggregate exception
AggregateException ae = Assert.Throws<AggregateException>(() => query.Execute().Wait());
Assert.Equal(1, ae.InnerExceptions.Count);
Assert.IsType<InvalidOperationException>(ae.InnerExceptions[0]);
// ... The data should still be available
Assert.True(query.HasExecuted, "The query should still be marked executed.");
Assert.NotEmpty(query.ResultSets);
Assert.NotEmpty(query.ResultSummary);
}
private static ISqlConnectionFactory CreateMockFactory(Dictionary<string, string>[][] data)
{
var mockFactory = new Mock<ISqlConnectionFactory>();
mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny<string>()))
.Returns(CreateTestConnection(data));
return mockFactory.Object;
}
private static ConnectionInfo CreateTestConnectionInfo(Dictionary<string, string>[][] data)
{
// Create connection info
ConnectionDetails connDetails = new ConnectionDetails
{
UserName = "sa",
Password = "Yukon900",
DatabaseName = "AdventureWorks2016CTP3_2",
ServerName = "sqltools11"
};
return new ConnectionInfo(CreateMockFactory(data), "test://test", connDetails);
}
#endregion
}
}

138
test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/ServiceTests.cs Normal file
View File

@@ -0,0 +1,138 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.SqlTools.ServiceLayer.Connection;
using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol;
using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
using Microsoft.SqlTools.ServiceLayer.QueryExecution;
using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
using Microsoft.SqlTools.Test.Utility;
using Moq;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
{
public class ServiceTests
{
[Fact]
public void QueryExecuteValidNoResultsTest()
{
// If:
// ... I request to execute a valid query with no results
var queryService = GetPrimedExecutionService(Common.CreateMockFactory(null, false));
var queryParams = new QueryExecuteParams
{
QueryText = "Doesn't Matter",
OwnerUri = "testFile"
};
QueryExecuteResult result = null;
QueryExecuteCompleteParams completeParams = null;
var requestContext = GetQueryExecuteResultContextMock(qer => result = qer, (et, cp) => completeParams = cp, null);
queryService.HandleExecuteRequest(queryParams, requestContext.Object).Wait();
// Then:
// ... No Errors should have been sent
// ... A successful result should have been sent with no messages
// ... A completion event should have been fired with empty results
VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Never());
Assert.Null(result.Messages);
Assert.Empty(completeParams.Messages);
Assert.Empty(completeParams.ResultSetSummaries);
Assert.False(completeParams.Error);
}
[Fact]
public void QueryExecuteValidResultsTest()
{
// If:
// ... I request to execute a valid query with results
var queryService = GetPrimedExecutionService(Common.CreateMockFactory(new [] {Common.StandardTestData}, false));
var queryParams = new QueryExecuteParams {OwnerUri = "testFile", QueryText = "Doesn't Matter"};
QueryExecuteResult result = null;
QueryExecuteCompleteParams completeParams = null;
var requestContext = GetQueryExecuteResultContextMock(qer => result = qer, (et, cp) => completeParams = cp, null);
queryService.HandleExecuteRequest(queryParams, requestContext.Object).Wait();
// Then:
// ... No errors should have been send
// ... A successful result should have been sent with no messages
// ... A completion event should hvae been fired with one result
VerifyQueryExecuteCallCount(requestContext, Times.Once(), Times.Once(), Times.Never());
Assert.Null(result.Messages);
Assert.Empty(completeParams.Messages);
Assert.NotEmpty(completeParams.ResultSetSummaries);
Assert.False(completeParams.Error);
}
private ConnectionDetails GetTestConnectionDetails()
{
return new ConnectionDetails
{
DatabaseName = "123",
Password = "456",
ServerName = "789",
UserName = "012"
};
}
private QueryExecutionService GetPrimedExecutionService(ISqlConnectionFactory factory)
{
var connectionService = new ConnectionService(factory);
connectionService.Connect(new ConnectParams {Connection = GetTestConnectionDetails(), OwnerUri = "testFile"});
return new QueryExecutionService(connectionService);
}
private Mock<RequestContext<QueryExecuteResult>> GetQueryExecuteResultContextMock(
Action<QueryExecuteResult> resultCallback,
Action<EventType<QueryExecuteCompleteParams>, QueryExecuteCompleteParams> eventCallback,
Action<object> errorCallback)
{
var requestContext = new Mock<RequestContext<QueryExecuteResult>>();
// Setup the mock for SendResult
var sendResultFlow = requestContext
.Setup(rc => rc.SendResult(It.IsAny<QueryExecuteResult>()))
.Returns(Task.FromResult(0));
if (resultCallback != null)
{
sendResultFlow.Callback(resultCallback);
}
// Setup the mock for SendEvent
var sendEventFlow = requestContext.Setup(rc => rc.SendEvent(
It.Is<EventType<QueryExecuteCompleteParams>>(m => m == QueryExecuteCompleteEvent.Type),
It.IsAny<QueryExecuteCompleteParams>()))
.Returns(Task.FromResult(0));
if (eventCallback != null)
{
sendEventFlow.Callback(eventCallback);
}
// Setup the mock for SendError
var sendErrorFlow = requestContext.Setup(rc => rc.SendError(It.IsAny<object>()))
.Returns(Task.FromResult(0));
if (errorCallback != null)
{
sendErrorFlow.Callback(errorCallback);
}
return requestContext;
}
private void VerifyQueryExecuteCallCount(Mock<RequestContext<QueryExecuteResult>> mock, Times sendResultCalls, Times sendEventCalls, Times sendErrorCalls)
{
mock.Verify(rc => rc.SendResult(It.IsAny<QueryExecuteResult>()), sendResultCalls);
mock.Verify(rc => rc.SendEvent(
It.Is<EventType<QueryExecuteCompleteParams>>(m => m == QueryExecuteCompleteEvent.Type),
It.IsAny<QueryExecuteCompleteParams>()), sendEventCalls);
mock.Verify(rc => rc.SendError(It.IsAny<object>()), sendErrorCalls);
}
}
}

52
test/Microsoft.SqlTools.ServiceLayer.Test/QueryExecution/SubsetTests.cs
View File

@@ -1,11 +1,57 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.SqlTools.ServiceLayer.QueryExecution;
using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
using Xunit;
namespace Microsoft.SqlTools.ServiceLayer.Test.QueryExecution
{
public class SubsetTests
{
[Theory]
[InlineData(2)]
[InlineData(20)]
public void SubsetValidTest(int rowCount)
{
// If I have an executed query
Query q = Common.GetBasicExecutedQuery();
// ... And I ask for a subset with valid arguments
ResultSetSubset subset = q.GetSubset(0, 0, rowCount);
// Then:
// I should get the requested number of rows
Assert.Equal(Math.Min(rowCount, Common.StandardTestData.Length), subset.RowCount);
Assert.Equal(Math.Min(rowCount, Common.StandardTestData.Length), subset.Rows.Length);
}
[Fact]
public void SubsetUnexecutedQueryTest()
{
// If I have a query that has *not* been executed
Query q = new Query("NO OP", Common.CreateTestConnectionInfo(null, false));
// ... And I ask for a subset with valid arguments
// Then:
// ... It should throw an exception
Assert.Throws<InvalidOperationException>(() => q.GetSubset(0, 0, 2));
}
[Theory]
[InlineData(-1, 0, 2)] // Invalid result set, too low
[InlineData(2, 0, 2)] // Invalid result set, too high
[InlineData(0, -1, 2)] // Invalid start index, too low
[InlineData(0, 10, 2)] // Invalid start index, too high
[InlineData(0, 0, -1)] // Invalid row count, too low
[InlineData(0, 0, 0)] // Invalid row count, zero
public void SubsetInvalidParamsTest(int resultSetIndex, int rowStartInex, int rowCount)
{
// If I have an executed query
Query q = Common.GetBasicExecutedQuery();
// ... And I ask for a subset with an invalid result set index
// Then:
// ... It should throw an exception
Assert.Throws<ArgumentOutOfRangeException>(() => q.GetSubset(resultSetIndex, rowStartInex, rowCount));
}
}
}

8
test/Microsoft.SqlTools.ServiceLayer.Test/Utility/TestDbDataReader.cs
View File

@@ -23,14 +23,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Test.Utility
private IEnumerator<Dictionary<string, string>> Rows { get; set; }
private const string tableNameTestCommand = "SELECT name FROM sys.tables";
private List<Dictionary<string, string>> tableNamesTest = new List<Dictionary<string, string>>
{
new Dictionary<string, string> { {"name", "table1"} },
new Dictionary<string, string> { {"name", "table2"} }
};
public TestDbDataReader(Dictionary<string, string>[][] data)
{
Data = data;