public void CreateSqlTaskGivenInvalidArgumentShouldThrowException()
{
DatabaseOperationStub operation = new DatabaseOperationStub();
Assert.Throws <ArgumentNullException>(() => new SqlTask(null, operation.FunctionToRun, operation.FunctionToCancel));
Assert.Throws <ArgumentNullException>(() => new SqlTask(new TaskMetadata(), null, null));
}
public async Task ToTaskInfoShouldReturnTaskInfo()
{
SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded;
DatabaseOperationStub operation = new DatabaseOperationStub();
operation.TaskResult = new TaskResult
{
TaskStatus = expectedStatus
};
SqlTask sqlTask = new SqlTask(new TaskMetadata
{
ServerName = "server name",
DatabaseName = "database name"
}, operation.FunctionToRun, operation.FunctionToCancel);
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
{
var taskInfo = sqlTask.ToTaskInfo();
Assert.Equal(taskInfo.TaskId, sqlTask.TaskId.ToString());
Assert.Equal(taskInfo.ServerName, "server name");
Assert.Equal(taskInfo.DatabaseName, "database name");
});
operation.Stop();
await taskToVerify;
}
public async Task CancelTaskShouldCancelTheOperationAndSendNotification()
{
serviceHostMock.AddEventHandling(TaskCreatedNotification.Type, null);
serviceHostMock.AddEventHandling(TaskStatusChangedNotification.Type, null);
DatabaseOperationStub operation = new DatabaseOperationStub();
SqlTask sqlTask = service.TaskManager.CreateTask(taskMetaData, operation.FunctionToRun, operation.FunctionToCancel);
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
{
serviceHostMock.Verify(x => x.SendEvent(TaskStatusChangedNotification.Type,
It.Is <TaskProgressInfo>(t => t.Status == SqlTaskStatus.Canceled)), Times.AtLeastOnce());
});
CancelTaskParams cancelParams = new CancelTaskParams
{
TaskId = sqlTask.TaskId.ToString()
};
await RunAndVerify <bool>(
test : (requestContext) => service.HandleCancelTaskRequest(cancelParams, requestContext),
verify : ((result) =>
{
}));
serviceHostMock.Verify(x => x.SendEvent(TaskCreatedNotification.Type,
It.Is <TaskInfo>(t => t.TaskId == sqlTask.TaskId.ToString())), Times.Once());
await taskToVerify;
}
public async Task VerifyScriptTask()
{
using (SqlTaskManager manager = new SqlTaskManager())
{
DatabaseOperationStub operation = new DatabaseOperationStub();
operation.TaskResult = new TaskResult
{
TaskStatus = SqlTaskStatus.Succeeded
};
SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToScript);
bool scriptAddedEventRaised = false;
string script = null;
sqlTask.ScriptAdded += (object sender, TaskEventArgs <TaskScript> e) =>
{
scriptAddedEventRaised = true;
script = e.TaskData.Script;
};
Assert.NotNull(sqlTask);
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
{
Assert.True(scriptAddedEventRaised);
Assert.True(!string.IsNullOrEmpty(script));
Assert.True(manager.HasCompletedTasks());
manager.RemoveCompletedTask(sqlTask);
});
operation.Stop();
await taskToVerify;
}
}
public async Task VerifyCreateAndRunningTask()
{
using (SqlTaskManager manager = new SqlTaskManager())
{
bool taskAddedEventRaised = false;
manager.TaskAdded += (object sender, TaskEventArgs <SqlTask> e) =>
{
taskAddedEventRaised = true;
};
DatabaseOperationStub operation = new DatabaseOperationStub();
operation.TaskResult = new TaskResult
{
TaskStatus = SqlTaskStatus.Succeeded
};
SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToRun);
Assert.NotNull(sqlTask);
Assert.True(taskAddedEventRaised);
Assert.False(manager.HasCompletedTasks());
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
{
Assert.True(manager.HasCompletedTasks());
manager.RemoveCompletedTask(sqlTask);
});
operation.Stop();
await taskToVerify;
}
}
public void NewTaskShouldSendNotification()
{
serviceHostMock.AddEventHandling(TaskCreatedNotification.Type, null);
serviceHostMock.AddEventHandling(TaskStatusChangedNotification.Type, null);
DatabaseOperationStub operation = new DatabaseOperationStub();
SqlTask sqlTask = service.TaskManager.CreateTask(taskMetaData, operation.FunctionToRun);
sqlTask.Run();
serviceHostMock.Verify(x => x.SendEvent(TaskCreatedNotification.Type,
It.Is <TaskInfo>(t => t.TaskId == sqlTask.TaskId.ToString() && t.ProviderName == "MSSQL")), Times.Once());
operation.Stop();
Thread.Sleep(2000);
serviceHostMock.Verify(x => x.SendEvent(TaskStatusChangedNotification.Type,
It.Is <TaskProgressInfo>(t => t.TaskId == sqlTask.TaskId.ToString())), Times.AtLeastOnce());
}
public async Task RunScriptShouldReturnScriptContent()
{
SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded;
DatabaseOperationStub operation = new DatabaseOperationStub();
operation.TaskResult = new TaskResult
{
TaskStatus = expectedStatus
};
SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToScript, null);
Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted);
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => {
Assert.Equal(sqlTask.TaskStatus, expectedStatus);
Assert.Equal(sqlTask.IsCompleted, true);
Assert.NotNull(operation.TaskScript);
Assert.True(!string.IsNullOrEmpty(operation.TaskScript.Script));
});
await taskToVerify;
}
public async Task TaskListTaskShouldReturnAllTasks()
{
serviceHostMock.AddEventHandling(TaskCreatedNotification.Type, null);
serviceHostMock.AddEventHandling(TaskStatusChangedNotification.Type, null);
DatabaseOperationStub operation = new DatabaseOperationStub();
SqlTask sqlTask = service.TaskManager.CreateTask(taskMetaData, operation.FunctionToRun);
sqlTask.Run();
ListTasksParams listParams = new ListTasksParams
{
};
await RunAndVerify <ListTasksResponse>(
test : (requestContext) => service.HandleListTasksRequest(listParams, requestContext),
verify : ((result) =>
{
Assert.True(result.Tasks.Any(x => x.TaskId == sqlTask.TaskId.ToString()));
}));
operation.Stop();
}
public async Task FailedOperationShouldFailTheTask()
{
SqlTaskStatus expectedStatus = SqlTaskStatus.Failed;
DatabaseOperationStub operation = new DatabaseOperationStub();
operation.TaskResult = new TaskResult
{
};
SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun, operation.FunctionToCancel);
Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted);
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => {
Assert.Equal(sqlTask.TaskStatus, expectedStatus);
Assert.True(sqlTask.Duration > 0);
});
Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress);
Thread.Sleep(1000);
operation.FailTheOperation();
await taskToVerify;
}
public async Task CancelTaskShouldCancelTheOperation()
{
using (SqlTaskManager manager = new SqlTaskManager())
{
SqlTaskStatus expectedStatus = SqlTaskStatus.Canceled;
DatabaseOperationStub operation = new DatabaseOperationStub();
operation.TaskResult = new TaskResult
{
};
SqlTask sqlTask = manager.CreateTask(taskMetaData, operation.FunctionToRun, operation.FunctionToCancel);
Assert.NotNull(sqlTask);
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task =>
{
Assert.Equal(expectedStatus, sqlTask.TaskStatus);
Assert.Equal(sqlTask.IsCancelRequested, true);
manager.Reset();
});
manager.CancelTask(sqlTask.TaskId);
await taskToVerify;
}
}
public async Task RunShouldRunTheFunctionAndGetTheResult()
{
SqlTaskStatus expectedStatus = SqlTaskStatus.Succeeded;
DatabaseOperationStub operation = new DatabaseOperationStub();
operation.TaskResult = new TaskResult
{
TaskStatus = expectedStatus
};
SqlTask sqlTask = new SqlTask(new TaskMetadata(), operation.FunctionToRun, null);
Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.NotStarted);
Task taskToVerify = sqlTask.RunAsync().ContinueWith(task => {
Assert.Equal(sqlTask.TaskStatus, expectedStatus);
Assert.Equal(sqlTask.IsCompleted, true);
Assert.True(sqlTask.Duration > 0);
});
Assert.Equal(sqlTask.TaskStatus, SqlTaskStatus.InProgress);
Thread.Sleep(1000);
operation.Stop();
await taskToVerify;
}
