public async Task QueryExecuteSingleBatchMultipleResultTest(TestResultSet testResultSet)
{
// If:
// ... I request to execute a valid query with one batch and multiple result sets
var workspaceService = GetDefaultWorkspaceService(Constants.StandardQuery);
var testDataSet = new[] { testResultSet, testResultSet };
var queryService = Common.GetPrimedExecutionService(testDataSet, true, false, false, workspaceService, sizeFactor: testResultSet.Rows.Count / Common.StandardRows + 1);
var queryParams = new ExecuteDocumentSelectionParams {
OwnerUri = Constants.OwnerUri, QuerySelection = Common.WholeDocument
};
List <ResultSetEventParams> collectedResultSetEventParams = new List <ResultSetEventParams>();
var efv = new EventFlowValidator <ExecuteRequestResult>()
.AddStandardQueryResultValidator()
.AddStandardBatchStartValidator()
.AddResultSetValidator(ResultSetAvailableEvent.Type, collectedResultSetEventParams)
.AddResultSetValidator(ResultSetUpdatedEvent.Type, collectedResultSetEventParams)
.AddResultSetValidator(ResultSetCompleteEvent.Type, collectedResultSetEventParams)
.AddStandardMessageValidator()
.AddStandardQueryCompleteValidator(1)
.Complete();
await Common.AwaitExecution(queryService, queryParams, efv.Object);
// Then:
// ... All events should have been called as per their flow validator
efv.ValidateResultSetSummaries(collectedResultSetEventParams).Validate();
// ... There should be one active query
Assert.Equal(1, queryService.ActiveQueries.Count);
}
public async Task UpdateRowSuccess()
{
// Setup:
// ... Create a standard result set with standard data
var fileFactory = MemoryFileSystem.GetFileStreamFactory();
var mockReader = GetReader(Common.StandardTestDataSet, false, Constants.StandardQuery);
ResultSet resultSet = new ResultSet(Common.Ordinal, Common.Ordinal, fileFactory);
await resultSet.ReadResultToEnd(mockReader, CancellationToken.None);
// ... Create a mock reader that has one row
object[] row = Enumerable.Range(0, Common.StandardColumns).Select(i => "QQQ").ToArray();
IEnumerable <object[]> rows = new List <object[]> {
row
};
TestResultSet[] results = { new TestResultSet(TestResultSet.GetStandardColumns(Common.StandardColumns), rows) };
var newRowReader = GetReader(results, false, Constants.StandardQuery);
// If: I add a new row to the result set
await resultSet.UpdateRow(0, newRowReader);
// Then:
// ... There should be the same number of rows
Assert.Equal(Common.StandardRows, resultSet.RowCount);
// ... The new row should be readable and all cells contain the test value
Assert.All(resultSet.GetRow(0), cell => Assert.Equal("QQQ", cell.RawObject));
}
public async Task WriteAsync(IConsole console, TestResultSet testResults)
{
if (console == null)
{
throw new ArgumentNullException(nameof(console));
}
if (testResults == null)
{
throw new ArgumentNullException(nameof(testResults));
}
await WriteResults(console, testResults);
console.Out.WriteLine($"SUMMARY:");
using (console.SetColorForOutcome(TestOutcome.Passed))
{
await console.Out.WriteAsync($"Passed: {testResults.Passed.Count}, ");
}
using (console.SetColorForOutcome(TestOutcome.Failed))
{
await console.Out.WriteAsync($"Failed: {testResults.Failed.Count}, ");
}
using (console.SetColorForOutcome(TestOutcome.NotExecuted))
{
await console.Out.WriteLineAsync($"Not run: {testResults.NotExecuted.Count}");
}
}
public static DbDataReader GetNewRowDataReader(DbColumn[] columns, bool includeIdentity)
{
object[][] rows = includeIdentity
? new[] { new object[] { "id", "q", "q", "q" } }
: new[] { new object[] { "q", "q", "q" } };
var testResultSet = new TestResultSet(columns, rows);
return(new TestDbDataReader(new [] { testResultSet }));
}
private static async Task <ResultSet> GetResultSet(DbColumn[] columns, object[] row)
{
object[][] rows = { row };
var testResultSet = new TestResultSet(columns, rows);
var testReader = new TestDbDataReader(new [] { testResultSet });
var resultSet = new ResultSet(0, 0, MemoryFileSystem.GetFileStreamFactory());
await resultSet.ReadResultToEnd(testReader, CancellationToken.None);
return(resultSet);
}
public async Task WriteAsync(IConsole console, TestResultSet testResults)
{
var json = JsonConvert.SerializeObject(
testResults,
Formatting.Indented,
new FileInfoJsonConverter(),
new DirectoryInfoJsonConverter());
await console.Out.WriteAsync(json);
}
public static async Task <ResultSet> GetResultSet(DbColumn[] columns, bool includeIdentity, int rowCount = 1)
{
IEnumerable <object[]> rows = includeIdentity
? Enumerable.Repeat(new object[] { "id", "1", "2", "3" }, rowCount)
: Enumerable.Repeat(new object[] { "1", "2", "3" }, rowCount);
var testResultSet = new TestResultSet(columns, rows);
var reader = new TestDbDataReader(new[] { testResultSet });
var resultSet = new ResultSet(0, 0, MemoryFileSystem.GetFileStreamFactory());
await resultSet.ReadResultToEnd(reader, CancellationToken.None);
return(resultSet);
}
public static async Task InvokeAsync(
OutputFormat format,
FileInfo[] file,
DirectoryInfo[] path,
string filter,
bool showTestOutput,
IConsole console = null)
{
var allFiles = new List <FileInfo>();
if (file != null && file.Any())
{
foreach (var fileInfo in file.Where(f => f.Exists))
{
allFiles.Add(fileInfo);
}
}
else
{
foreach (var directoryInfo in path)
{
if (directoryInfo.Exists)
{
allFiles.AddRange(SearchDirectory(directoryInfo.FullName));
}
}
}
var resultSet = Create(allFiles);
if (!string.IsNullOrWhiteSpace(filter))
{
var regex = new Regex($"^{filter.Replace("*", ".*")}$");
resultSet = new TestResultSet(
resultSet.Where(r => regex.IsMatch(r.FullyQualifiedTestName)));
}
IConsoleWriter writer = null;
switch (format)
{
case OutputFormat.Summary:
writer = new SummaryWriter(showTestOutput);
break;
case OutputFormat.Json:
writer = new JsonWriter();
break;
}
await writer.WriteAsync(console, resultSet);
}
public async Task GetVerifyQuery()
{
// Setup: Create a row update and set the first row cell to have values
// ... other than "1" for testing purposes (simulated select query result).
Common.TestDbColumnsWithTableMetadata data = new Common.TestDbColumnsWithTableMetadata(false, false, 0, 0);
var rs = await Common.GetResultSet(data.DbColumns, false);
RowUpdate ru = new RowUpdate(0, rs, data.TableMetadata);
object[][] rows =
{
new object[] { "2", "0", "0" },
};
var testResultSet = new TestResultSet(data.DbColumns, rows);
var newRowReader = new TestDbDataReader(new[] { testResultSet }, false);
await ru.ApplyChanges(newRowReader);
// ... Create a row delete.
RowDelete rd = new RowDelete(0, rs, data.TableMetadata);
int expectedKeys = 3;
// If: I generate a verify command
String verifyCommand = rd.GetVerifyScript();
// Then:
// ... The command should not be null
Assert.NotNull(verifyCommand);
// ... It should be formatted into an where script
string regexTest = @"SELECT COUNT \(\*\) FROM (.+) WHERE (.+)";
Regex r = new Regex(regexTest);
var m = r.Match(verifyCommand);
Assert.True(m.Success);
// ... There should be a table
string tbl = m.Groups[1].Value;
Assert.Equal(data.TableMetadata.EscapedMultipartName, tbl);
// ... There should be as many where components as there are keys
string[] whereComponents = m.Groups[2].Value.Split(new[] { "AND" }, StringSplitOptions.None);
Assert.Equal(expectedKeys, whereComponents.Length);
// ... Mock db connection for building the command
var mockConn = new TestSqlConnection(new[] { testResultSet });
// If: I attempt to get a command for a simulated delete of a row with duplicates.
// Then: The Command will throw an exception as it detects there are
// ... 2 or more rows with the same value in the simulated query results data.
Assert.Throws <EditDataDeleteException>(() => rd.GetCommand(mockConn));
}
public async Task ListDatabasesOnServerForCurrentConnectionReturnsDatabaseNames()
{
// Result set for the query of database names
TestDbColumn[] cols = { new TestDbColumn("name") };
object[][] rows =
{
new object[] { "master" },
new object[] { "model" },
new object[] { "msdb" },
new object[] { "tempdb" },
new object[] { "mydatabase" }
};
TestResultSet data = new TestResultSet(cols, rows);
// Setup mock connection factory to inject query results
var mockFactory = new Mock <ISqlConnectionFactory>();
mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny <string>()))
.Returns(CreateMockDbConnection(new[] { data }));
var connectionService = new ConnectionService(mockFactory.Object);
// connect to a database instance
string ownerUri = "file://my/sample/file.sql";
var connectionResult = await
connectionService
.Connect(new ConnectParams()
{
OwnerUri = ownerUri,
Connection = TestObjects.GetTestConnectionDetails()
});
// verify that a valid connection id was returned
Assert.NotEmpty(connectionResult.ConnectionId);
// list databases for the connection
ListDatabasesParams parameters = new ListDatabasesParams {
OwnerUri = ownerUri
};
var listDatabasesResult = connectionService.ListDatabases(parameters);
string[] databaseNames = listDatabasesResult.DatabaseNames;
Assert.Equal(databaseNames.Length, 5);
Assert.Equal(databaseNames[0], "master");
Assert.Equal(databaseNames[1], "model");
Assert.Equal(databaseNames[2], "msdb");
Assert.Equal(databaseNames[3], "tempdb");
Assert.Equal(databaseNames[4], "mydatabase");
}
private static void WriteRow(TextWriter output, int itemsCount, int documentSize, TestResultSet result, string name)
{
var cols = new List<object>();
cols.Add(name);
cols.Add(itemsCount);
cols.Add(documentSize);
cols.Add(result.Read1.ItemAvgMs);
cols.Add(result.Read2.ItemAvgMs);
cols.Add(result.Read3.ItemAvgMs);
cols.Add(result.Categories.Average(i => i.ItemAvgMs));
cols.Add(result.Write.ItemAvgMs);
cols.Add(result.CountItemsMs);
output.WriteLine(String.Join(",", cols));
}
public TestResultSetDrop MapToDrop(TestResultSet resultSet)
{
return(new TestResultSetDrop
{
Source = resultSet.Source,
Results = resultSet.Results.Select(MapToDrop).ToList(),
Duration = resultSet.Duration,
ExecutedTestsCount = resultSet.ExecutedTests,
NoneCount = resultSet.None,
PassedCount = resultSet.Passed,
FailedCount = resultSet.Failed,
SkippedCount = resultSet.Skipped,
NotFoundCount = resultSet.NotFound,
});
}
public void SetCellHasCorrections()
{
// Setup:
// ... Generate a result set with a single binary column
DbColumn[] cols =
{
new TestDbColumn
{
DataType = typeof(byte[]),
DataTypeName = "binary"
}
};
object[][] rows = { new object[] { new byte[] { 0x00 } } };
var testResultSet = new TestResultSet(cols, rows);
var testReader = new TestDbDataReader(new[] { testResultSet });
var rs = new ResultSet(0, 0, MemoryFileSystem.GetFileStreamFactory());
rs.ReadResultToEnd(testReader, CancellationToken.None).Wait();
// ... Generate the metadata
var etm = Common.GetStandardMetadata(cols);
// ... Create the row update
RowUpdate ru = new RowUpdate(0, rs, etm);
// If: I set a cell in the newly created row to something that will be corrected
EditUpdateCellResult eucr = ru.SetCell(0, "1000");
// Then:
// ... A edit cell was returned
Assert.NotNull(eucr);
Assert.NotNull(eucr.Cell);
// ... The value we used won't be returned
Assert.NotEmpty(eucr.Cell.DisplayValue);
Assert.NotEqual("1000", eucr.Cell.DisplayValue);
Assert.False(eucr.Cell.IsNull);
// ... The cell should be dirty
Assert.True(eucr.Cell.IsDirty);
// ... The row is still dirty
Assert.True(eucr.IsRowDirty);
// ... There should be a cell update in the cell list
Assert.Contains(0, ru.cellUpdates.Keys);
Assert.NotNull(ru.cellUpdates[0]);
}
private void TestResultHandler(object sender, TestResultEventArgs e)
{
var source = e.Result.TestCase.Source;
if (_testRun.Results.Contains(source))
{
var testResults = _testRun.Results[source];
testResults.Add(e.Result);
}
else
{
var resultSet = new TestResultSet(source);
resultSet.Add(e.Result);
_testRun.Results.Add(resultSet);
}
}
public async Task SetCellHasCorrections()
{
// Setup:
// ... Generate a result set with a single binary column
DbColumn[] cols = { new TestDbColumn
{
DataType = typeof(byte[]),
DataTypeName = "binary"
} };
object[][] rows = {};
var testResultSet = new TestResultSet(cols, rows);
var testReader = new TestDbDataReader(new[] { testResultSet }, false);
var rs = new ResultSet(0, 0, MemoryFileSystem.GetFileStreamFactory());
await rs.ReadResultToEnd(testReader, CancellationToken.None);
// ... Generate the metadata
var etm = Common.GetCustomEditTableMetadata(cols);
// ... Create the row create
RowCreate rc = new RowCreate(100, rs, etm);
// If: I set a cell in the newly created row to something that will be corrected
EditUpdateCellResult eucr = rc.SetCell(0, "1000");
// Then:
// ... The returned value should be equal to what we provided
Assert.NotNull(eucr);
Assert.NotNull(eucr.Cell);
Assert.NotEqual("1000", eucr.Cell.DisplayValue);
Assert.False(eucr.Cell.IsNull);
// ... The returned value should be dirty
Assert.NotNull(eucr.Cell.IsDirty);
// ... The row should still be dirty
Assert.True(eucr.IsRowDirty);
// ... There should be a cell update in the cell list
Assert.NotNull(rc.newCells[0]);
}
public TestResultSetDrop(TestResultSet resultSet)
{
_resultSet = resultSet;
}
