/// <summary>
/// Performs an internal consistency check on the methods (requests/responses) in the documentation.
/// Prints the results of the tests to the console.
/// </summary>
/// <param name="options"></param>
/// <param name="docset"></param>
/// <returns></returns>
private static async Task <CheckResults> CheckMethodsAsync(BasicCheckOptions options, DocSet docset)
{
MethodDefinition[] methods = FindTestMethods(options, docset);
CheckResults results = new CheckResults();
foreach (var method in methods)
{
var testName = "check-method-syntax: " + method.Identifier;
TestReport.StartTest(testName, method.SourceFile.DisplayName);
if (string.IsNullOrEmpty(method.ExpectedResponse))
{
await TestReport.FinishTestAsync(testName, TestOutcome.Failed, "Null response where one was expected.");
results.FailureCount++;
continue;
}
var parser = new HttpParser();
var expectedResponse = parser.ParseHttpResponse(method.ExpectedResponse);
ValidationError[] errors;
method.ValidateResponse(expectedResponse, null, null, out errors);
await WriteOutErrorsAndFinishTestAsync(errors, options.SilenceWarnings, " ", "No errors.", false, testName, "Warnings detected", "Errors detected");
results.IncrementResultCount(errors);
}
return(results);
}
/// <summary>
/// Validate that the CSDL metadata defined for a service matches the documentation.
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
private static async Task <bool> CheckServiceMetadataAsync(CheckMetadataOptions options)
{
List <Schema> schemas = await TryGetMetadataSchemasAsync(options);
if (null == schemas)
{
return(false);
}
FancyConsole.WriteLine(FancyConsole.ConsoleSuccessColor, " found {0} schema definitions: {1}", schemas.Count, (from s in schemas select s.Namespace).ComponentsJoinedByString(", "));
var docSet = await GetDocSetAsync(options);
if (null == docSet)
{
return(false);
}
const string testname = "validate-service-metadata";
TestReport.StartTest(testname);
List <ResourceDefinition> foundResources = ODataParser.GenerateResourcesFromSchemas(schemas);
CheckResults results = new CheckResults();
List <ValidationError> collectedErrors = new List <ValidationError>();
foreach (var resource in foundResources)
{
FancyConsole.WriteLine();
FancyConsole.Write(FancyConsole.ConsoleHeaderColor, "Checking resource: {0}...", resource.Metadata.ResourceType);
FancyConsole.VerboseWriteLine();
FancyConsole.VerboseWriteLine(resource.JsonExample);
FancyConsole.VerboseWriteLine();
// Verify that this resource matches the documentation
ValidationError[] errors;
docSet.ResourceCollection.ValidateJsonExample(resource.Metadata, resource.JsonExample, out errors, new ValidationOptions {
RelaxedStringValidation = true
});
results.IncrementResultCount(errors);
collectedErrors.AddRange(errors);
await WriteOutErrorsAndFinishTestAsync(errors, options.SilenceWarnings, successMessage : " no errors.");
}
if (options.IgnoreWarnings)
{
results.ConvertWarningsToSuccess();
}
var output = (from e in collectedErrors select e.ErrorText).ComponentsJoinedByString("\r\n");
await TestReport.FinishTestAsync(testname, results.WereFailures?TestOutcome.Failed : TestOutcome.Passed, stdOut : output);
results.PrintToConsole();
return(!results.WereFailures);
}
/// <summary>
/// Print a collection of ValidationError objects to the console. Also shuts down the test runner
/// for the current test.
/// </summary>
/// <param name="errors"></param>
/// <param name="silenceWarnings"></param>
/// <param name="indent"></param>
/// <param name="successMessage"></param>
/// <param name="endLineBeforeWriting"></param>
/// <param name="testName"></param>
/// <param name="warningsMessage"></param>
/// <param name="errorsMessage"></param>
/// <returns></returns>
private static async Task <bool> WriteOutErrorsAndFinishTestAsync(IEnumerable <ValidationError> errors, bool silenceWarnings, string indent = "", string successMessage = null, bool endLineBeforeWriting = false, string testName = null, string warningsMessage = null, string errorsMessage = null)
{
var validationErrors = errors as ValidationError[] ?? errors.ToArray();
WriteMessages(validationErrors, silenceWarnings, indent, endLineBeforeWriting);
TestOutcome outcome = TestOutcome.None;
string outputMessage = null;
var errorMessages = validationErrors.Where(x => x.IsError);
var warningMessages = validationErrors.Where(x => x.IsWarning);
if (errorMessages.Any())
{
// Write failure message
var singleError = errorMessages.First();
if (errorMessages.Count() == 1)
{
outputMessage = singleError.Message.FirstLineOnly();
}
else
{
outputMessage = "Multiple errors occured.";
}
outcome = TestOutcome.Failed;
}
else if (!silenceWarnings && warningMessages.Any())
{
// Write warning message
var singleWarning = warningMessages.First();
if (warningMessages.Count() == 1)
{
outputMessage = singleWarning.Message.FirstLineOnly();
}
else
{
outputMessage = "Multiple warnings occured.";
}
outcome = TestOutcome.Passed;
}
else
{
// write success message!
outputMessage = successMessage;
outcome = TestOutcome.Passed;
}
// Record this test's outcome in the build worker API
if (null != testName)
{
var errorMessage = (from e in validationErrors select e.ErrorText).ComponentsJoinedByString("\r\n");
await TestReport.FinishTestAsync(testName, outcome, outputMessage, stdOut : errorMessage);
}
return(outcome == TestOutcome.Passed);
}
