public async void InvokeSqlAssessmentServerTest()
{
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master");
var connection = liveConnection.ConnectionInfo.AllConnections.FirstOrDefault();
Debug.Assert(connection != null, "Live connection is always expected providing a connection");
var serverInfo = ReliableConnectionHelper.GetServerVersion(connection);
var response = await CallAssessment <AssessmentResultItem>(
nameof(SqlAssessmentService.InvokeSqlAssessment),
SqlObjectType.Server,
liveConnection);
Assert.All(
response.Items,
i =>
{
Assert.NotNull(i.Message);
Assert.NotEmpty(i.Message);
Assert.Equal(serverInfo.ServerName, i.TargetName);
if (i.Kind == 0)
{
AssertInfoPresent(i);
}
});
}
private async Task QueryExecuteAllBatchesNoOp()
{
// If:
// ... I request to execute a valid query with all batches as no op
var workspaceService = GetDefaultWorkspaceService(string.Format("{0}\r\nGO\r\n{0}", Common.NoOpQuery));
var queryService = Common.GetPrimedExecutionService(null, true, false, false, workspaceService);
var queryParams = new ExecuteDocumentSelectionParams {
QuerySelection = Common.WholeDocument, OwnerUri = Constants.OwnerUri
};
var efv = new EventFlowValidator <ExecuteRequestResult>()
.AddStandardQueryResultValidator()
.AddStandardBatchStartValidator()
.AddStandardMessageValidator()
.AddStandardBatchCompleteValidator()
.AddStandardBatchCompleteValidator()
.AddStandardMessageValidator()
.AddStandardBatchCompleteValidator()
.AddEventValidation(QueryCompleteEvent.Type, p =>
{
// Validate OwnerURI matches
Assert.Equal(Constants.OwnerUri, p.OwnerUri);
Assert.NotNull(p.BatchSummaries);
Assert.Equal(2, p.BatchSummaries.Length);
Assert.All(p.BatchSummaries, bs => Assert.Equal(0, bs.ResultSetSummaries.Length));
}).Complete();
await Common.AwaitExecution(queryService, queryParams, efv.Object);
// Then:
// ... All events should have been called as per their flow validator
efv.Validate();
// ... There should be one active query
Assert.Equal(1, queryService.ActiveQueries.Count);
}
private static async Task <AssessmentResult <TResult> > CallAssessment <TResult>(
string methodName,
SqlObjectType sqlObjectType,
LiveConnectionHelper.TestConnectionResult liveConnection)
where TResult : AssessmentItemInfo
{
var connInfo = liveConnection.ConnectionInfo;
AssessmentResult <TResult> response;
using (var service = new SqlAssessmentService(
TestServiceProvider.Instance.ConnectionService,
TestServiceProvider.Instance.WorkspaceService))
{
AddTestRules(service);
string randomUri = Guid.NewGuid().ToString();
AssessmentParams requestParams =
new AssessmentParams {
OwnerUri = randomUri, TargetType = sqlObjectType
};
ConnectParams connectParams = new ConnectParams
{
OwnerUri = requestParams.OwnerUri,
Connection = connInfo.ConnectionDetails,
Type = ConnectionType.Default
};
var methodInfo = typeof(SqlAssessmentService).GetMethod(
methodName,
BindingFlags.Instance | BindingFlags.NonPublic);
Assert.NotNull(methodInfo);
var func = (AssessmentMethod <TResult>)Delegate.CreateDelegate(
typeof(AssessmentMethod <TResult>),
service,
methodInfo);
response = await service.CallAssessmentEngine <TResult>(
requestParams,
connectParams,
randomUri,
t => func(t));
}
Assert.NotNull(response);
if (response.Success)
{
Assert.All(
response.Items,
i =>
{
Assert.Equal(sqlObjectType, i.TargetType);
Assert.Contains(i.Level, AllowedSeverityLevels);
});
}
return(response);
}
public void Assertions()
{
var condition = false;
var text = "something";
var obj = new Auto();
var tokens = new List <string> {
"public", "void", "return"
};
var zero = 8 - 8;
var someEnumerable = new List <string>();
Assert.False(condition);
Assert.Equal("something", text);
Assert.NotEqual("something else", text);
Assert.Contains("tech", "technology"); // also DoesNotContain
Assert.Matches(".*thing$", "something");
Assert.Throws <DivideByZeroException>(() => 4 / zero);
Assert.Empty(someEnumerable); // also NotEmpty
Assert.IsType <Auto>(obj);
Assert.Collection(new List <int> {
2, 4
},
n => Assert.Equal(2, n),
n => Assert.Equal(4, n)
);
Assert.All(new List <string> {
"a", "ab", "abc"
},
s => s.StartsWith("a"));
}
private void AssertInfoPresent(AssessmentItemInfo item)
{
Assert.NotNull(item.CheckId);
Assert.NotEmpty(item.CheckId);
Assert.NotNull(item.DisplayName);
Assert.NotEmpty(item.DisplayName);
Assert.NotNull(item.Description);
Assert.NotEmpty(item.Description);
Assert.NotNull(item.Tags);
Assert.All(item.Tags, t =>
{
Assert.NotNull(t);
Assert.NotEmpty(t);
});
}
public async Task GetTopStreams(string gameName)
{
var topStreamsQuery = new TopStreamQuery()
{
Skip = 0, Take = 100, GameName = gameName
};
var topStreams = await sut.GetTopStreams(topStreamsQuery);
Assert.NotNull(topStreams);
Assert.NotEmpty(topStreams);
if (topStreamsQuery.GameName != null)
{
Assert.All(topStreams, stream => Assert.Contains(topStreamsQuery.GameName, stream.Game, StringComparison.OrdinalIgnoreCase));
}
}
public async void GetAssessmentItemsDatabaseTest()
{
const string DatabaseName = "tempdb";
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(DatabaseName);
var response = await CallAssessment <CheckInfo>(
nameof(SqlAssessmentService.GetAssessmentItems),
SqlObjectType.Database,
liveConnection);
Assert.All(
response.Items,
i =>
{
StringAssert.EndsWith(":" + DatabaseName, i.TargetName);
AssertInfoPresent(i);
});
}
public async void GetAssessmentItemsServerTest()
{
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master");
var connection = liveConnection.ConnectionInfo.AllConnections.FirstOrDefault();
Debug.Assert(connection != null, "Live connection is always expected providing a connection");
var serverInfo = ReliableConnectionHelper.GetServerVersion(connection);
var response = await CallAssessment <CheckInfo>(
nameof(SqlAssessmentService.GetAssessmentItems),
SqlObjectType.Server,
liveConnection);
Assert.All(
response.Items,
i =>
{
AssertInfoPresent(i);
Assert.Equal(serverInfo.ServerName, i.TargetName);
});
}
public async void InvokeSqlAssessmentIDatabaseTest()
{
const string DatabaseName = "tempdb";
var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(DatabaseName);
var response = await CallAssessment <AssessmentResultItem>(
nameof(SqlAssessmentService.InvokeSqlAssessment),
SqlObjectType.Database,
liveConnection);
Assert.All(
response.Items,
i =>
{
StringAssert.EndsWith(":" + DatabaseName, i.TargetName);
Assert.NotNull(i.Message);
Assert.NotEmpty(i.Message);
if (i.Kind == 0)
{
AssertInfoPresent(i);
}
});
}
