mirror of
https://github.com/ckaczor/sqltoolsservice.git
synced 2026-01-14 01:25:40 -05:00
Include ManagedBatchParser tests to improve code coverage (#793)
* Include ManagedBatchParser test to improve code coverage * Fix some failing test cases and revert appveyor.yml
This commit is contained in:
Dhruva N
@@ -0,0 +1,126 @@
|
||||
//
|
||||
// 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 Microsoft.SqlTools.ServiceLayer.BatchParser.ExecutionEngineCode;
|
||||
|
||||
namespace Microsoft.SqlTools.ManagedBatchParser.IntegrationTests.TSQLExecutionEngine
|
||||
{
|
||||
internal class BatchEventHandler : IBatchEventsHandler
|
||||
{
|
||||
private List<int> resultCounts = new List<int>();
|
||||
private List<string> sqlMessages = new List<string>();
|
||||
private List<string> errorMessage = new List<string>();
|
||||
private int batchfinishedEventCounter = 0;
|
||||
private SqlDataReader dr = null;
|
||||
private bool cancelEventFired = false;
|
||||
|
||||
#region Public properties
|
||||
|
||||
public List<int> ResultCounts
|
||||
{
|
||||
get
|
||||
{
|
||||
return resultCounts;
|
||||
}
|
||||
}
|
||||
|
||||
public List<string> SqlMessages
|
||||
{
|
||||
get
|
||||
{
|
||||
return sqlMessages;
|
||||
}
|
||||
}
|
||||
|
||||
public List<string> ErrorMessages
|
||||
{
|
||||
get
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
}
|
||||
|
||||
public int BatchfinishedEventCounter
|
||||
{
|
||||
get
|
||||
{
|
||||
return batchfinishedEventCounter;
|
||||
}
|
||||
}
|
||||
|
||||
public bool CancelFired
|
||||
{
|
||||
get
|
||||
{
|
||||
return cancelEventFired;
|
||||
}
|
||||
}
|
||||
|
||||
#endregion Public properties
|
||||
|
||||
#region IBatchEventHandlers Members
|
||||
|
||||
public void OnBatchCancelling(object sender, EventArgs args)
|
||||
{
|
||||
Console.WriteLine("\tOnBatchCancelling:");
|
||||
cancelEventFired = true;
|
||||
}
|
||||
|
||||
public void OnBatchError(object sender, BatchErrorEventArgs args)
|
||||
{
|
||||
Console.WriteLine("\tOnBatchError:");
|
||||
Console.WriteLine("\t\tLine {0} has error: ", args.Line);
|
||||
Console.WriteLine("\t\tError description: " + args.Description);
|
||||
Console.WriteLine("\t\tError message: " + args.Message);
|
||||
Console.WriteLine("\t\tError Line: " + args.TextSpan.iStartLine);
|
||||
|
||||
errorMessage.Add(args.Description);
|
||||
}
|
||||
|
||||
public void OnBatchMessage(object sender, BatchMessageEventArgs args)
|
||||
{
|
||||
Console.WriteLine("\tOnBatchMessage ...");
|
||||
Console.WriteLine("\t\tMessage: " + args.Message);
|
||||
Console.WriteLine("\t\tDetail message:" + args.DetailedMessage);
|
||||
|
||||
if (args.DetailedMessage != "")
|
||||
{
|
||||
sqlMessages.Add(args.DetailedMessage);
|
||||
}
|
||||
else
|
||||
{
|
||||
SqlMessages.Add(null);
|
||||
}
|
||||
}
|
||||
|
||||
public void OnBatchResultSetFinished(object sender, EventArgs args)
|
||||
{
|
||||
Console.WriteLine("\tOnBatchResultSetFinished...");
|
||||
Console.WriteLine("\t\tBatch result set finished");
|
||||
batchfinishedEventCounter++;
|
||||
}
|
||||
|
||||
public void OnBatchResultSetProcessing(object sender, BatchResultSetEventArgs args)
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
Console.WriteLine("\tOnBatchResultProcessing...");
|
||||
dr = args.DataReader as SqlDataReader;
|
||||
int count = 0;
|
||||
while (dr.Read() && !cancelEventFired)
|
||||
{
|
||||
count++;
|
||||
}
|
||||
Console.WriteLine("\t\tOnBatchResultProcessing: Records returned: " + count);
|
||||
resultCounts.Add(count);
|
||||
}
|
||||
}
|
||||
|
||||
#endregion IBatchEventHandlers Members
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,901 @@
|
||||
//
|
||||
// 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.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.SqlTools.ManagedBatchParser.IntegrationTests.Utility;
|
||||
using Microsoft.SqlTools.ServiceLayer.BatchParser.ExecutionEngineCode;
|
||||
using Microsoft.SqlTools.ServiceLayer.Connection;
|
||||
using Microsoft.SqlTools.ServiceLayer.Test.Common;
|
||||
using Xunit;
|
||||
|
||||
namespace Microsoft.SqlTools.ManagedBatchParser.IntegrationTests.TSQLExecutionEngine
|
||||
{
|
||||
/// <summary>
|
||||
///This is a test class for Microsoft.Data.Tools.Schema.Common.ExecutionEngine.ExecutionEngine and is intended
|
||||
///to contain all Microsoft.Data.Tools.Schema.Common.ExecutionEngine.ExecutionEngine Unit Tests
|
||||
///</summary>
|
||||
|
||||
public class ExecutionEngineTest : IDisposable
|
||||
{
|
||||
private SqlConnection connection;
|
||||
private List<int> expResultCounts = new List<int>();
|
||||
private List<string> expErrorMessage = new List<string>();
|
||||
|
||||
#region Test Initialize And Cleanup
|
||||
|
||||
public ExecutionEngineTest()
|
||||
{
|
||||
TestInitialize();
|
||||
}
|
||||
|
||||
// Initialize the tests
|
||||
public void TestInitialize()
|
||||
{
|
||||
expResultCounts = new List<int>();
|
||||
expErrorMessage = new List<string>();
|
||||
connection = SetUpConnection("test");
|
||||
}
|
||||
|
||||
// helper method to set up a Sql Connection to a database
|
||||
private SqlConnection SetUpConnection(string name)
|
||||
{
|
||||
SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, name);
|
||||
ConnectionInfo connInfo = LiveConnectionHelper.InitLiveConnectionInfoForDefinition(testDb.DatabaseName);
|
||||
string connectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
|
||||
SqlConnection resultConnection = new SqlConnection(connectionString);
|
||||
resultConnection.Open();
|
||||
return resultConnection;
|
||||
}
|
||||
|
||||
// Helper method to close a connection completely
|
||||
private void CloseConnection(SqlConnection conn)
|
||||
{
|
||||
if (conn != null)
|
||||
{
|
||||
conn.Close();
|
||||
conn.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
//Use Dispose to close connection after each test has run
|
||||
//
|
||||
public void Dispose()
|
||||
{
|
||||
//Task.Run(() => SqlTestDb.DropDatabase(connection.Database));
|
||||
CloseConnection(connection);
|
||||
connection = null;
|
||||
}
|
||||
|
||||
#endregion Test Initialize And Cleanup
|
||||
|
||||
#region Valid scripts
|
||||
|
||||
/// <summary>
|
||||
///A test for a simple SQL script
|
||||
///</summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_SimpleTest()
|
||||
{
|
||||
string sqlStatement = "SELECT * FROM sysobjects";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success, executor.ExecutionResult);
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
Assert.Equal(1, executor.BatchFinshedEventCounter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with a valid script using default execution condition
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_DefaultCondition_ValidScript()
|
||||
{
|
||||
string sqlStatement = "select * from sysobjects\nGo\n";
|
||||
|
||||
//Use default execution condition
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, false);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success, executor.ExecutionResult);
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
// <summary>
|
||||
// Test with multiple valid scripts in multiple batches
|
||||
// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_MultiValidScripts()
|
||||
{
|
||||
string sqlStatement = "select * from sys.databases\ngo\nselect name from sys.databases\ngo\nprint 'test'\ngo";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, false);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success, executor.ExecutionResult);
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with SQL comment
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_TestComment()
|
||||
{
|
||||
string sqlStatement = "/*test comments*/";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success, executor.ExecutionResult);
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
#endregion Valid scripts
|
||||
|
||||
#region Invalid Scripts
|
||||
|
||||
/// <summary>
|
||||
/// Test with a invalid query using the default execution condition
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_DefaultCondition_InvalidScript()
|
||||
{
|
||||
string sqlStatement = "select ** from sysobjects";
|
||||
//Use default execution condition
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, false);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success | ScriptExecutionResult.Failure, executor.ExecutionResult);
|
||||
Assert.True(!executor.ParserExecutionError);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
Assert.Equal(0, executor.BatchFinshedEventCounter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with an invalid query using a defined execution condition
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_InvalidScriptWithCondition()
|
||||
{
|
||||
string sqlStatement = "select * from authors";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(executor.ExecutionResult, ScriptExecutionResult.Success | ScriptExecutionResult.Failure);
|
||||
Assert.True(!executor.ParserExecutionError);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with multiple invalid scripts in multiple batches
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_MultipleInvalidScript()
|
||||
{
|
||||
string sqlStatement = "select ** from products \ngo\n insert into products values (1,'abc')\n go \n";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(executor.ExecutionResult, ScriptExecutionResult.Success | ScriptExecutionResult.Failure);
|
||||
Assert.True(!executor.ParserExecutionError);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with invalid scripts within a single batch
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_MultipleInvalidScript_SingleBatch()
|
||||
{
|
||||
string sqlStatement = "select ** from products \n insert into products values (1,'abc')\n go \n";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success | ScriptExecutionResult.Failure, executor.ExecutionResult);
|
||||
Assert.True(!executor.ParserExecutionError);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with mixed valid and invalid scripts
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_MixedValidandInvalidScript()
|
||||
{
|
||||
string sqlStatement = "SELECT * FROM Authors \n Go\n select * from sysobjects \n go\nif exists (select * from sysobjects where id = object_id('MyTab')) DROP TABLE MyTab2";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(executor.ExecutionResult, ScriptExecutionResult.Success | ScriptExecutionResult.Failure);
|
||||
Assert.True(!executor.ParserExecutionError);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_DiscardConnection()
|
||||
{
|
||||
ExecutionEngine engine = new ExecutionEngine();
|
||||
Assert.True(ConnectionDiscardWrapper(engine));
|
||||
}
|
||||
|
||||
#endregion Invalid Scripts
|
||||
|
||||
#region Different execution conditions
|
||||
|
||||
/// <summary>
|
||||
/// Test HaltOnError execution condition
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_HaltOnError()
|
||||
{
|
||||
string sqlStatement = "select * from authors\n go\n select * from sysbojects \n go \n";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = true;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Halted | ScriptExecutionResult.Failure, executor.ExecutionResult);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
Assert.True(executor.ResultCountQueue.Count == 0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// HaltOnError with a single batch
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_HaltOnError_OneBatch()
|
||||
{
|
||||
string sqlStatement = "select * from authors\n go 30\n";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = true;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Halted | ScriptExecutionResult.Failure, executor.ExecutionResult);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
Assert.True(executor.ResultCountQueue.Count == 0);
|
||||
Assert.Equal(0, executor.BatchFinshedEventCounter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test ParseOnly execution condition with valid scripts
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_ParseOnly_ValidScript()
|
||||
{
|
||||
string sqlStatement = "select * from sysobjects";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = true;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success, executor.ExecutionResult);
|
||||
Assert.True(executor.ResultCountQueue.Count == 0);
|
||||
Assert.Equal(0, executor.BatchFinshedEventCounter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test HaltOnError execution condition with invalid scripts
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_ParseOnly_InvalidScript()
|
||||
{
|
||||
string sqlStatement = "select ** from authors";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = true;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success | ScriptExecutionResult.Failure, executor.ExecutionResult);
|
||||
Assert.True(!executor.ParserExecutionError);
|
||||
Assert.True(executor.ResultCountQueue.Count == 0);
|
||||
Assert.True(CompareTwoStringLists(executor.ErrorMessageQueue, expErrorMessage));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Parse script only without transaction wrapper
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_ParseOnly_ValidScriptWithoutTransaction()
|
||||
{
|
||||
string sqlStatement = "select * from sysobjects";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = false;
|
||||
conditions.IsParseOnly = true;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success, executor.ExecutionResult);
|
||||
Assert.True(executor.ResultCountQueue.Count == 0);
|
||||
Assert.Equal(0, executor.BatchFinshedEventCounter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with execution timeout value
|
||||
/// </summary>
|
||||
//TEST_DOESNOTWORK[TestMethod()]
|
||||
public void ExecutionEngineTest_TimeOut()
|
||||
{
|
||||
string sqlStatement = "select * from sysobjects\n go 10\n";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, -1);
|
||||
executor.Run();
|
||||
Assert.Equal(executor.ExecutionResult, ScriptExecutionResult.Success);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with invalid connection
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_InvalidConnection()
|
||||
{
|
||||
string sqlStatement = "select * from sysobjects\n go 100\n";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
connection.Close();
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions);
|
||||
executor.Run();
|
||||
|
||||
// Note: this used to also return Halted at some point in the distant past.
|
||||
// However since that gets mapped to Failure anyhow, consider "Failure" as acceptable here
|
||||
Assert.True(executor.ExecutionResult.HasFlag(ScriptExecutionResult.Failure), "Expected failure when invalid connection is present");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test with multiple conditions true
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void TestExecutionEngineConditions()
|
||||
{
|
||||
string sqlStatement = "select * from sys.databases\ngo\nselect name from sys.databases\ngo\nprint 'test'\ngo";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsNoExec = true;
|
||||
conditions.IsStatisticsIO = true;
|
||||
conditions.IsStatisticsTime = true;
|
||||
conditions.IsEstimatedShowPlan = true;
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, false);
|
||||
executor.Run();
|
||||
|
||||
//Get the expected values
|
||||
List<string> batchScripts = executor.BatchScripts;
|
||||
ExecuteSqlBatch(batchScripts, connection);
|
||||
|
||||
Assert.Equal(ScriptExecutionResult.Success, executor.ExecutionResult);
|
||||
Assert.True(CompareTwoIntLists(executor.ResultCountQueue, expResultCounts));
|
||||
}
|
||||
|
||||
#endregion Different execution conditions
|
||||
|
||||
#region SQL Commands
|
||||
|
||||
/// <summary>
|
||||
/// Test with SQL commands
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_SQLCmds()
|
||||
{
|
||||
string[] sqlStatements = {
|
||||
"select $(INVALIDVAR) from sysobjects",
|
||||
":help",
|
||||
"exit",
|
||||
"quit",
|
||||
"!! dir",
|
||||
"ed",
|
||||
"reset",
|
||||
":list",
|
||||
":listvar",
|
||||
":serverlist",
|
||||
":on error ignore",
|
||||
":connect hypothermia -t 300 -U foo -P bar",
|
||||
":out $(SystemDrive)\\test.txt",
|
||||
":r $(SystemDrive)\\test.txt",
|
||||
":error STDOUT",
|
||||
":perftrace STDOUT",
|
||||
"exit (Select count(*) from sysobjects)"
|
||||
};
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
|
||||
foreach (string stmt in sqlStatements)
|
||||
{
|
||||
TestExecutor executor = new TestExecutor(stmt, connection, conditions);
|
||||
executor.Run();
|
||||
Assert.True(executor.ResultCountQueue.Count == 0);
|
||||
}
|
||||
}
|
||||
|
||||
#endregion SQL Commands
|
||||
|
||||
#region Threading
|
||||
|
||||
/// <summary>
|
||||
/// Test synchronous cancel
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_SyncCancel()
|
||||
{
|
||||
string sqlStatement = "waitfor delay '0:0:10'";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, true);
|
||||
executor.CancelTimeOut = 3000;
|
||||
executor.Run();
|
||||
|
||||
Assert.NotNull(executor.ScriptExecuteThread);
|
||||
Assert.Equal(ScriptExecutionResult.Cancel, executor.ExecutionResult);
|
||||
Assert.True(executor.CancelEventFired);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test asynchronous cancel
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_ASyncCancel()
|
||||
{
|
||||
//string sqlStatement = "--This is a test\nSELECT * FROM sysobjects as t\nGO 50\n use pubsplus \n select * from titles\n go" ;
|
||||
|
||||
string sqlStatement = "waitfor delay '0:0:10'";
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, true);
|
||||
executor.SyncCancel = false;
|
||||
executor.Run();
|
||||
|
||||
Assert.True(executor.CancelEventFired);
|
||||
Assert.NotNull(executor.ScriptExecuteThread);
|
||||
if (executor.ScriptExecuteThread != null)
|
||||
Assert.True(!executor.ScriptExecuteThread.IsAlive);
|
||||
Assert.Equal(ScriptExecutionResult.Cancel, executor.ExecutionResult);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test sync cancel when the execution is done
|
||||
/// </summary>
|
||||
///
|
||||
/// Disabled test, has race condition where Sql statement will finish
|
||||
/// before harness has an opportunity to cancel.
|
||||
//TEST_DOESNOTWORK[TestMethod()]
|
||||
public void ExecutionEngineTest_SyncCancelAfterExecutionDone()
|
||||
{
|
||||
string sqlStatement = "select 1";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, true);
|
||||
executor.Run();
|
||||
|
||||
Assert.True(!executor.CancelEventFired);
|
||||
Assert.NotNull(executor.ScriptExecuteThread);
|
||||
if (executor.ScriptExecuteThread != null)
|
||||
Assert.True(!executor.ScriptExecuteThread.IsAlive);
|
||||
Assert.Equal(ScriptExecutionResult.Success | ScriptExecutionResult.Cancel, executor.ExecutionResult);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test async cancel when the execution is done
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ExecutionEngineTest_ASyncCancelAfterExecutionDone()
|
||||
{
|
||||
string sqlStatement = "select 1";
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
TestExecutor executor = new TestExecutor(sqlStatement, connection, conditions, true);
|
||||
executor.SyncCancel = false;
|
||||
executor.Run();
|
||||
|
||||
Assert.True(!executor.CancelEventFired);
|
||||
Assert.NotNull(executor.ScriptExecuteThread);
|
||||
if (executor.ScriptExecuteThread != null)
|
||||
Assert.True(!executor.ScriptExecuteThread.IsAlive);
|
||||
Assert.Equal(ScriptExecutionResult.Success | ScriptExecutionResult.Cancel, executor.ExecutionResult);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Test multiple threads of execution engine with cancel operation
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task ExecutionEngineTest_MultiThreading_WithCancel()
|
||||
{
|
||||
string[] sqlStatement = { "waitfor delay '0:0:10'",
|
||||
"waitfor delay '0:0:10'",
|
||||
"waitfor delay '0:0:10'"
|
||||
};
|
||||
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
conditions.IsTransactionWrapped = true;
|
||||
conditions.IsParseOnly = false;
|
||||
conditions.IsHaltOnError = false;
|
||||
|
||||
SqlConnection connection2 = SetUpConnection("test4");
|
||||
SqlConnection connection3 = SetUpConnection("test5");
|
||||
|
||||
TestExecutor executor1 = new TestExecutor(sqlStatement[0], connection, conditions, true);
|
||||
executor1.CancelTimeOut = 2000;
|
||||
TestExecutor executor2 = new TestExecutor(sqlStatement[1], connection2, conditions, true);
|
||||
executor1.CancelTimeOut = 2500;
|
||||
TestExecutor executor3 = new TestExecutor(sqlStatement[2], connection3, conditions, true);
|
||||
executor1.CancelTimeOut = 3000;
|
||||
|
||||
Thread t1 = new Thread(new ThreadStart(executor1.Run));
|
||||
Thread t2 = new Thread(new ThreadStart(executor2.Run));
|
||||
Thread t3 = new Thread(new ThreadStart(executor3.Run));
|
||||
|
||||
t1.Name = "Executor1";
|
||||
t1.Start();
|
||||
t2.Name = "Executor2";
|
||||
t2.Start();
|
||||
t3.Name = "Executor3";
|
||||
t3.Start();
|
||||
|
||||
while ((t1.ThreadState != ThreadState.Stopped) &&
|
||||
(t2.ThreadState != ThreadState.Stopped) &&
|
||||
(t3.ThreadState != ThreadState.Stopped))
|
||||
{
|
||||
Thread.Sleep(1000);
|
||||
}
|
||||
|
||||
Assert.True(!executor1.ScriptExecuteThread.IsAlive);
|
||||
Assert.True(!executor2.ScriptExecuteThread.IsAlive);
|
||||
Assert.True(!executor3.ScriptExecuteThread.IsAlive);
|
||||
|
||||
Assert.True(executor1.CancelEventFired);
|
||||
Assert.True(executor2.CancelEventFired);
|
||||
Assert.True(executor3.CancelEventFired);
|
||||
|
||||
CloseConnection(connection2);
|
||||
CloseConnection(connection3);
|
||||
await SqlTestDb.DropDatabase(connection2.Database);
|
||||
await SqlTestDb.DropDatabase(connection3.Database);
|
||||
}
|
||||
|
||||
#endregion Threading
|
||||
|
||||
#region Get/Set Methods
|
||||
|
||||
[Fact]
|
||||
public void TestShowStatements()
|
||||
{
|
||||
Assert.NotNull(ExecutionEngineConditions.ShowPlanXmlStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.ShowPlanAllStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.ShowPlanTextStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.StatisticsXmlStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.StatisticsProfileStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.ParseOnlyStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.NoExecStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.StatisticsIOStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.StatisticsTimeStatement(true));
|
||||
Assert.NotNull(ExecutionEngineConditions.ResetStatement);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestExecutionEngineConditionsSetMethods()
|
||||
{
|
||||
ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
bool getValue = conditions.IsScriptExecutionTracked;
|
||||
conditions.IsScriptExecutionTracked = !getValue;
|
||||
Assert.Equal(conditions.IsScriptExecutionTracked, !getValue);
|
||||
|
||||
getValue = conditions.IsEstimatedShowPlan;
|
||||
conditions.IsEstimatedShowPlan = !getValue;
|
||||
Assert.Equal(conditions.IsEstimatedShowPlan, !getValue);
|
||||
|
||||
getValue = conditions.IsActualShowPlan;
|
||||
conditions.IsActualShowPlan = !getValue;
|
||||
Assert.Equal(conditions.IsActualShowPlan, !getValue);
|
||||
|
||||
getValue = conditions.IsSuppressProviderMessageHeaders;
|
||||
conditions.IsSuppressProviderMessageHeaders = !getValue;
|
||||
Assert.Equal(conditions.IsSuppressProviderMessageHeaders, !getValue);
|
||||
|
||||
getValue = conditions.IsNoExec;
|
||||
conditions.IsNoExec = !getValue;
|
||||
Assert.Equal(conditions.IsNoExec, !getValue);
|
||||
|
||||
getValue = conditions.IsStatisticsIO;
|
||||
conditions.IsStatisticsIO = !getValue;
|
||||
Assert.Equal(conditions.IsStatisticsIO, !getValue);
|
||||
|
||||
getValue = conditions.IsShowPlanText;
|
||||
conditions.IsShowPlanText = !getValue;
|
||||
Assert.Equal(conditions.IsShowPlanText, !getValue);
|
||||
|
||||
getValue = conditions.IsStatisticsTime;
|
||||
conditions.IsStatisticsTime = !getValue;
|
||||
Assert.Equal(conditions.IsStatisticsTime, !getValue);
|
||||
|
||||
getValue = conditions.IsSqlCmd;
|
||||
conditions.IsSqlCmd = !getValue;
|
||||
Assert.Equal(conditions.IsSqlCmd, !getValue);
|
||||
|
||||
conditions.BatchSeparator = "GO";
|
||||
Assert.Equal(conditions.BatchSeparator, "GO");
|
||||
}
|
||||
|
||||
#endregion Get/Set Methods
|
||||
|
||||
#region Private methods
|
||||
|
||||
/// <summary>
|
||||
/// Connection to a database
|
||||
/// </summary>
|
||||
/// <param name="server">Server name</param>
|
||||
/// <param name="database">DB name</param>
|
||||
/// <returns></returns>
|
||||
private SqlConnection ConnectToDB(string server, string database)
|
||||
{
|
||||
return new SqlConnection(string.Format("Data Source={0};Initial Catalog={1};Integrated Security=True;", server, database));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Execution a script batch
|
||||
/// </summary>
|
||||
/// <param name="sqlBatch">A list of SQL queries</param>
|
||||
/// <param name="connection">SQL connection</param>
|
||||
private void ExecuteSqlBatch(List<string> sqlBatch, SqlConnection connection)
|
||||
{
|
||||
foreach (string script in sqlBatch)
|
||||
{
|
||||
ExecuteSqlCommand(script, connection);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Execution one sql command
|
||||
/// </summary>
|
||||
/// <param name="sqlCmdTxt">SQL query</param>
|
||||
/// <param name="connection">SQL connection</param>
|
||||
private void ExecuteSqlCommand(string sqlCmdTxt, SqlConnection connection)
|
||||
{
|
||||
SqlCommand cmd = new SqlCommand(sqlCmdTxt, connection);
|
||||
SqlTransaction transaction = connection.BeginTransaction();
|
||||
cmd.Transaction = transaction;
|
||||
|
||||
try
|
||||
{
|
||||
using (SqlDataReader dr = cmd.ExecuteReader())
|
||||
{
|
||||
int count = 0;
|
||||
while (dr.Read())
|
||||
{
|
||||
count++;
|
||||
}
|
||||
if (count > 0)
|
||||
{
|
||||
expResultCounts.Add(count);
|
||||
}
|
||||
}
|
||||
transaction.Commit();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
Console.WriteLine("Executing command throws exception: " + e.Message);
|
||||
expErrorMessage.Add(e.Message);
|
||||
try
|
||||
{
|
||||
transaction.Rollback();
|
||||
}
|
||||
catch (Exception e2)
|
||||
{
|
||||
Console.WriteLine("Rollback throws exception");
|
||||
Console.WriteLine("Message: " + e2.Message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Compare two string lists
|
||||
/// </summary>
|
||||
/// <param name="l1">first list</param>
|
||||
/// <param name="l2">second list</param>
|
||||
/// <returns>True if the contents are same, otherwise false</returns>
|
||||
private bool CompareTwoStringLists(List<string> l1, List<string> l2)
|
||||
{
|
||||
bool isSame = true;
|
||||
if (l1.Count != l2.Count)
|
||||
{
|
||||
isSame = false;
|
||||
Console.WriteLine("The count of elements in two lists are not the same");
|
||||
return isSame;
|
||||
}
|
||||
|
||||
for (int i = 0; i < l1.Count; i++)
|
||||
{
|
||||
if (l1[i] != l2[i])
|
||||
{
|
||||
isSame = false;
|
||||
Console.WriteLine("l1: {0}, l2: {1}", l1[i], l2[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return isSame;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Compare with integer list
|
||||
/// </summary>
|
||||
/// <param name="l1">first list</param>
|
||||
/// <param name="l2">second list</param>
|
||||
/// <returns>True if the two list's contents are same, otherwise false</returns>
|
||||
private bool CompareTwoIntLists(List<int> l1, List<int> l2)
|
||||
{
|
||||
bool isSame = true;
|
||||
if (l1.Count != l2.Count)
|
||||
{
|
||||
isSame = false;
|
||||
Console.WriteLine("The count of elements in two lists are not the same");
|
||||
return isSame;
|
||||
}
|
||||
|
||||
for (int i = 0; i < l1.Count; i++)
|
||||
{
|
||||
if (l1[i] != l2[i])
|
||||
{
|
||||
isSame = false;
|
||||
Console.WriteLine("l1: {0}, l2: {1}", l1[i], l2[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return isSame;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Wrapper to test the Close method in ExecutionEngine
|
||||
/// </summary>
|
||||
/// <param name="engine"></param>
|
||||
/// <returns></returns>
|
||||
private bool ConnectionDiscardWrapper(ExecutionEngine engine)
|
||||
{
|
||||
if (engine == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
engine.Close(false, true, true);
|
||||
return true;
|
||||
}
|
||||
|
||||
#endregion Private methods
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,372 @@
|
||||
//
|
||||
// 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.Threading;
|
||||
using Microsoft.SqlTools.ServiceLayer.BatchParser.ExecutionEngineCode;
|
||||
using Microsoft.SqlTools.Utility;
|
||||
|
||||
namespace Microsoft.SqlTools.ManagedBatchParser.IntegrationTests.TSQLExecutionEngine
|
||||
{
|
||||
internal class TestExecutor : IDisposable
|
||||
{
|
||||
#region Private variables
|
||||
|
||||
private string sqlStatement;
|
||||
private ExecutionEngineConditions conditions = new ExecutionEngineConditions();
|
||||
private BatchEventHandler eventHandler = new BatchEventHandler();
|
||||
private SqlConnection connection = null;
|
||||
private static Thread _executionThread;
|
||||
private bool _syncCancel = true;
|
||||
private bool _isFinished = false;
|
||||
private bool _cancel = false;
|
||||
private int _cancelTimeout = 500;
|
||||
private int exeTimeOut = 0;
|
||||
|
||||
//For verification
|
||||
private List<int> resultCounts = new List<int>();
|
||||
|
||||
private List<string> sqlMessages = new List<string>();
|
||||
private List<string> errorMessage = new List<string>();
|
||||
private List<bool> batchFinished = new List<bool>();
|
||||
private static ScriptExecutionResult execResult = ScriptExecutionResult.All;
|
||||
private static List<string> batchScripts = new List<string>();
|
||||
private static Thread exeThread = null;
|
||||
private static bool parserExecutionError = false;
|
||||
|
||||
#endregion Private variables
|
||||
|
||||
#region private methods
|
||||
|
||||
/// <summary>
|
||||
/// Execute the script
|
||||
/// </summary>
|
||||
/// <param name="exec">Execution Engine</param>
|
||||
/// <param name="connection">SQL connection</param>
|
||||
/// <param name="script">script text</param>
|
||||
/// <param name="conditions">Execution condition</param>
|
||||
/// <param name="batchHandler">Batch event handler</param>
|
||||
/// <param name="timeout">time out value</param>
|
||||
private static void ExecuteScript(ExecutionEngine exec, SqlConnection connection, string script, ExecutionEngineConditions conditions, IBatchEventsHandler batchHandler, int timeout)
|
||||
{
|
||||
Validate.IsNotNull(nameof(exec), exec);
|
||||
Validate.IsNotNull(nameof(connection), connection);
|
||||
Validate.IsNotNullOrEmptyString(nameof(script), script);
|
||||
Validate.IsNotNull(nameof(conditions), conditions);
|
||||
|
||||
Console.WriteLine("------------------------ Executing Script ----------------------");
|
||||
|
||||
//exec.BeginScriptExecution(script, connection, timeout, conditions, batchConsumer);
|
||||
ScriptExecutionArgs args = new ScriptExecutionArgs(script, connection, timeout, conditions, batchHandler);
|
||||
//exec.ExecuteScript(args);
|
||||
|
||||
_executionThread = new Thread(new ParameterizedThreadStart(exec.ExecuteScript));
|
||||
_executionThread.Start(args);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Cancel the execution
|
||||
/// </summary>
|
||||
/// <param name="exec">Execution Engine</param>
|
||||
/// <param name="isSynchronous">Cancel the execution synchronously or not</param>
|
||||
/// <param name="timeout">sycn canceo timeout</param>
|
||||
private static void Cancel(ExecutionEngine exec, bool isSynchronous, int millisecondsTimeOut)
|
||||
{
|
||||
//exec.BeginCancellingExecution(isSynchronous, timeout);
|
||||
|
||||
if (_executionThread == null ||
|
||||
_executionThread.ThreadState == System.Threading.ThreadState.Unstarted ||
|
||||
_executionThread.ThreadState == System.Threading.ThreadState.Stopped)
|
||||
{
|
||||
exec.Close(isSynchronous, /* isDiscard */ false, /* isFinishExecution */ true);
|
||||
}
|
||||
else
|
||||
{
|
||||
// activates the cancel thread
|
||||
Thread cancelThread = new Thread(new ThreadStart(exec.CancelCurrentBatch));
|
||||
cancelThread.Name = "Cancelling thread";
|
||||
cancelThread.Start();
|
||||
|
||||
// in a syncrhonous call, we need to block and wait until the thread is stopped
|
||||
if (isSynchronous)
|
||||
{
|
||||
int totalSleep = 0;
|
||||
while (totalSleep < millisecondsTimeOut && _executionThread != null && _executionThread.IsAlive)
|
||||
{
|
||||
Thread.Sleep(50);
|
||||
totalSleep += 50;
|
||||
}
|
||||
|
||||
if (_executionThread != null && _executionThread.IsAlive)
|
||||
{
|
||||
exec.Close(isSynchronous, /* isDiscard */ true);
|
||||
}
|
||||
else
|
||||
{
|
||||
exec.Close(/* isCloseConnection */ true);
|
||||
}
|
||||
}
|
||||
}
|
||||
Thread.Sleep(5000);
|
||||
}
|
||||
|
||||
#endregion private methods
|
||||
|
||||
#region Public properties
|
||||
|
||||
public bool SyncCancel
|
||||
{
|
||||
get
|
||||
{
|
||||
return _syncCancel;
|
||||
}
|
||||
set
|
||||
{
|
||||
_syncCancel = value;
|
||||
}
|
||||
}
|
||||
|
||||
public int CancelTimeOut
|
||||
{
|
||||
get
|
||||
{
|
||||
return _cancelTimeout;
|
||||
}
|
||||
set
|
||||
{
|
||||
_cancelTimeout = value;
|
||||
}
|
||||
}
|
||||
|
||||
public ScriptExecutionResult ExecutionResult
|
||||
{
|
||||
get
|
||||
{
|
||||
return execResult;
|
||||
}
|
||||
}
|
||||
|
||||
public List<int> ResultCountQueue
|
||||
{
|
||||
get
|
||||
{
|
||||
return resultCounts;
|
||||
}
|
||||
}
|
||||
|
||||
public List<string> SQLMessageQueue
|
||||
{
|
||||
get
|
||||
{
|
||||
return sqlMessages;
|
||||
}
|
||||
}
|
||||
|
||||
public List<String> ErrorMessageQueue
|
||||
{
|
||||
get
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
}
|
||||
|
||||
public List<string> BatchScripts
|
||||
{
|
||||
get
|
||||
{
|
||||
return batchScripts;
|
||||
}
|
||||
}
|
||||
|
||||
public int BatchFinshedEventCounter
|
||||
{
|
||||
get
|
||||
{
|
||||
return eventHandler.BatchfinishedEventCounter;
|
||||
}
|
||||
}
|
||||
|
||||
public Thread ScriptExecuteThread
|
||||
{
|
||||
get
|
||||
{
|
||||
return exeThread;
|
||||
}
|
||||
}
|
||||
|
||||
public bool CancelEventFired
|
||||
{
|
||||
get
|
||||
{
|
||||
return eventHandler.CancelFired;
|
||||
}
|
||||
}
|
||||
|
||||
public bool ParserExecutionError
|
||||
{
|
||||
get
|
||||
{
|
||||
return parserExecutionError;
|
||||
}
|
||||
}
|
||||
|
||||
#endregion Public properties
|
||||
|
||||
#region Constructors
|
||||
|
||||
public TestExecutor(string batch, SqlConnection conn, ExecutionEngineConditions exeCondition) : this(batch, conn, exeCondition, false)
|
||||
{
|
||||
}
|
||||
|
||||
public TestExecutor(string batch, SqlConnection conn, ExecutionEngineConditions exeCondition, bool cancelExecution)
|
||||
{
|
||||
sqlStatement = batch;
|
||||
conditions.IsHaltOnError = exeCondition.IsHaltOnError;
|
||||
conditions.IsParseOnly = exeCondition.IsParseOnly;
|
||||
conditions.IsTransactionWrapped = exeCondition.IsTransactionWrapped;
|
||||
conditions.IsNoExec = exeCondition.IsNoExec;
|
||||
conditions.IsStatisticsIO = exeCondition.IsStatisticsIO;
|
||||
conditions.IsStatisticsTime = exeCondition.IsStatisticsTime;
|
||||
|
||||
_cancel = cancelExecution;
|
||||
connection = conn;
|
||||
|
||||
//Initialize the static variables
|
||||
execResult = ScriptExecutionResult.All;
|
||||
batchScripts = new List<string>();
|
||||
exeThread = null;
|
||||
parserExecutionError = false;
|
||||
}
|
||||
|
||||
public TestExecutor(string batch, SqlConnection conn, ExecutionEngineConditions exeCondition, int timeOut)
|
||||
: this(batch, conn, exeCondition, false)
|
||||
{
|
||||
exeTimeOut = timeOut;
|
||||
}
|
||||
|
||||
#endregion Constructors
|
||||
|
||||
#region public methods
|
||||
|
||||
/// <summary>
|
||||
/// Execute the test engine
|
||||
/// </summary>
|
||||
public void Run()
|
||||
{
|
||||
Console.WriteLine("Executing scripts {0} ...", sqlStatement);
|
||||
|
||||
using (ExecutionEngine exec = new ExecutionEngine())
|
||||
{
|
||||
_isFinished = false;
|
||||
exec.BatchParserExecutionStart += new EventHandler<BatchParserExecutionStartEventArgs>(OnBatchParserExecutionStart);
|
||||
exec.BatchParserExecutionFinished += new EventHandler<BatchParserExecutionFinishedEventArgs>(OnBatchParserExecutionFinished);
|
||||
exec.BatchParserExecutionError += new EventHandler<BatchParserExecutionErrorEventArgs>(OnBatchParserExecutionError);
|
||||
exec.ScriptExecutionFinished += new EventHandler<ScriptExecutionFinishedEventArgs>(OnExecutionFinished);
|
||||
|
||||
ExecuteScript(exec, connection, sqlStatement, conditions, eventHandler, exeTimeOut);
|
||||
|
||||
if (!_cancel)
|
||||
{
|
||||
//Do not cancel the execution engine
|
||||
while (!_isFinished)
|
||||
{
|
||||
Thread.Sleep(1000);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!_isFinished)
|
||||
{
|
||||
Console.WriteLine("Need to cancel while the batch execution is not finished!");
|
||||
Thread.Sleep(1000);
|
||||
}
|
||||
else
|
||||
{
|
||||
Console.WriteLine("Canceling after the exe engine is disposed...");
|
||||
}
|
||||
Cancel(exec, _syncCancel, _cancelTimeout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endregion public methods
|
||||
|
||||
#region ParserEvent
|
||||
|
||||
/// <summary>
|
||||
/// Called when batch is called
|
||||
/// </summary>
|
||||
/// <param name="sender"></param>
|
||||
/// <param name="e"></param>
|
||||
private static void OnBatchParserExecutionStart(object sender, BatchParserExecutionStartEventArgs e)
|
||||
{
|
||||
Console.WriteLine("****************");
|
||||
Console.WriteLine(e.Batch.Text);
|
||||
batchScripts.Add(e.Batch.Text);
|
||||
Console.WriteLine("****************");
|
||||
|
||||
Console.WriteLine("ON_BATCH_PARSER_EXECUTION_START : Start executing batch... " + e.Batch + " at line " + e.TextSpan.iStartLine);
|
||||
exeThread = Thread.CurrentThread;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called when batch is done
|
||||
/// </summary>
|
||||
/// <param name="sender"></param>
|
||||
/// <param name="e"></param>
|
||||
private static void OnBatchParserExecutionFinished(object sender, BatchParserExecutionFinishedEventArgs e)
|
||||
{
|
||||
Console.WriteLine("ON_BATCH_PARSER_EXECUTION_FINISHED : Done executing batch \n\t{0}\n\t with result... {1} ", e.Batch.Text, e.ExecutionResult);
|
||||
if (execResult == ScriptExecutionResult.All)
|
||||
execResult = e.ExecutionResult;
|
||||
else
|
||||
execResult = execResult | e.ExecutionResult;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called when batch pasing found a warning/error
|
||||
/// </summary>
|
||||
/// <param name="sender"></param>
|
||||
/// <param name="e"></param>
|
||||
private static void OnBatchParserExecutionError(object sender, BatchParserExecutionErrorEventArgs e)
|
||||
{
|
||||
Console.WriteLine("ON_BATCH_PARSER_EXECUTION_ERROR : {0} found... at line {1}: {2}", e.MessageType.ToString(), e.Line.ToString(), e.Message);
|
||||
Console.WriteLine("\t Error Description: " + e.Description);
|
||||
parserExecutionError = true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called when script is done
|
||||
/// </summary>
|
||||
/// <param name="sender"></param>
|
||||
/// <param name="e"></param>
|
||||
private void OnExecutionFinished(object sender, ScriptExecutionFinishedEventArgs e)
|
||||
{
|
||||
Console.WriteLine("ON_EXECUTION_FINISHED : Script execution done with result ..." + e.ExecutionResult);
|
||||
_isFinished = true;
|
||||
|
||||
if (execResult == ScriptExecutionResult.All)
|
||||
execResult = e.ExecutionResult;
|
||||
else
|
||||
execResult = execResult | e.ExecutionResult;
|
||||
|
||||
resultCounts = eventHandler.ResultCounts;
|
||||
sqlMessages = eventHandler.SqlMessages;
|
||||
errorMessage = eventHandler.ErrorMessages;
|
||||
}
|
||||
|
||||
#endregion ParserEvent
|
||||
|
||||
#region IDisposable Members
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
}
|
||||
|
||||
#endregion IDisposable Members
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user