Ejemplo n.º 1
0
 public static MethodDefinition FromRequest(string request, CodeBlockAnnotation annotation, DocFile source)
 {
     var method = new MethodDefinition
     {
         Request = request,
         RequestMetadata = annotation,
         Identifier = annotation.MethodName,
         SourceFile = source
     };
     method.Title = method.Identifier;
     return method;
 }
Ejemplo n.º 2
0
        public static ScenarioDefinition[] ScenariosForMethod(this IEnumerable<ScenarioDefinition> scenarios, MethodDefinition method)
        {
            var id = method.Identifier;
            var query = from p in scenarios
                        where p.MethodName == id
                        select p;

            if (method.Scenarios != null && method.Scenarios.Count > 0)
            {
                query = query.Union(method.Scenarios);
            }

            return query.ToArray();
        }
        private static async Task ValidateMethodWithScenarioAsync(
            MethodDefinition method,
            ScenarioDefinition scenario,
            IServiceAccount account,
            AuthenicationCredentials credentials,
            ValidationResults results)
        {
            if (null == method)
                throw new ArgumentNullException("method");
            if (null == scenario)
                throw new ArgumentNullException("scenario");
            if (null == account)
                throw new ArgumentNullException("account");
            if (null == credentials)
                throw new ArgumentNullException("credentials");
            if (null == results)
                throw new ArgumentNullException("results");

            var actionName = scenario.Description;

            // Generate the tested request by "previewing" the request and executing
            // all test-setup procedures
            long startTicks = DateTimeOffset.UtcNow.Ticks;
            var requestPreviewResult = await method.GenerateMethodRequestAsync(scenario, account.BaseUrl, credentials, method.SourceFile.Parent);
            TimeSpan generateMethodDuration = new TimeSpan(DateTimeOffset.UtcNow.Ticks - startTicks);
            
            // Check to see if an error occured building the request, and abort if so.
            var generatorResults = results[actionName + " [test-setup requests]"];
            generatorResults.AddResults(requestPreviewResult.Messages, requestPreviewResult.IsWarningOrError ? ValidationOutcome.Error :  ValidationOutcome.Passed);
            generatorResults.Duration = generateMethodDuration;

            if (requestPreviewResult.IsWarningOrError)
            {
                return;
            }

            // We've done all the test-setup work, now we have the real request to make to the service
            HttpRequest requestPreview = requestPreviewResult.Value;

            results.AddResult(
                actionName,
                new ValidationMessage(null, "Generated Method HTTP Request:\r\n{0}", requestPreview.FullHttpText()));

            HttpParser parser = new HttpParser();
            HttpResponse expectedResponse = null;
            if (!string.IsNullOrEmpty(method.ExpectedResponse))
            {
                expectedResponse = parser.ParseHttpResponse(method.ExpectedResponse);
            }

            // Execute the actual tested method (the result of the method preview call, which made the test-setup requests)
            startTicks = DateTimeOffset.UtcNow.Ticks;
            var actualResponse = await requestPreview.GetResponseAsync(account.BaseUrl);
            TimeSpan actualMethodDuration = new TimeSpan(DateTimeOffset.UtcNow.Ticks - startTicks);

            var requestResults = results[actionName];
            if (actualResponse.RetryCount > 0)
            {
                requestResults.AddResults(
                    new ValidationError[]
                    { new ValidationWarning(ValidationErrorCode.RequestWasRetried, null, "HTTP request was retried {0} times.", actualResponse.RetryCount) });
            }


            requestResults.AddResults(
                new ValidationError[]
                { new ValidationMessage(null, "HTTP Response:\r\n{0}", actualResponse.FullText(false)) });
            requestResults.Duration = actualMethodDuration;
           

            // Perform validation on the method's actual response
            ValidationError[] errors;
            method.ValidateResponse(actualResponse, expectedResponse, scenario, out errors);

            requestResults.AddResults(errors);

            // TODO: If the method is defined as a long running operation, we need to go poll the status 
            // URL to make sure that the operation finished and the response type is valid.

            if (errors.WereErrors())
                results.SetOutcome(actionName, ValidationOutcome.Error);
            else if (errors.WereWarnings())
                results.SetOutcome(actionName, ValidationOutcome.Warning);
            else
                results.SetOutcome(actionName, ValidationOutcome.Passed);
        }
 private static object SwaggerPropertyForResponse(MethodDefinition definition)
 {
     string customDataType = definition.ExpectedResponseMetadata.ResourceType;
     var type = new ParameterDataType(customDataType, true);
     string description = null;
     return MakeSwaggerProperty(type, description);
 }
 private static object SwaggerPropertyForResponse(MethodDefinition definition)
 {
     JsonDataType type = JsonDataType.ODataType;
     string customDataType = definition.ExpectedResponseMetadata.ResourceType;
     string description = null;
     return MakeSwaggerProperty(type, customDataType, description);
 }
Ejemplo n.º 6
0
 private static void SetFoundTablesOnMethod(IEnumerable<TableDefinition> foundTables, MethodDefinition onlyMethod)
 {
     foreach (var table in foundTables)
     {
         switch (table.Type)
         {
             case TableBlockType.Unknown:
                 // Unknown table format, nothing we can do with it.
                 break;
             case TableBlockType.EnumerationValues:
                 // TODO: Support enumeration values
                 Console.WriteLine("Enumeration that wasn't handled: {0} on method {1} ", table.Title, onlyMethod.RequestMetadata.MethodName);
                 break;
             case TableBlockType.ErrorCodes:
                 onlyMethod.Errors = table.Rows.Cast<ErrorDefinition>().ToList();
                 break;
             case TableBlockType.HttpHeaders:
             case TableBlockType.PathParameters:
             case TableBlockType.QueryStringParameters:
                 onlyMethod.Parameters.AddRange(table.Rows.Cast<ParameterDefinition>());
                 break;
             case TableBlockType.RequestObjectProperties:
                 onlyMethod.RequestBodyParameters.AddRange(table.Rows.Cast<ParameterDefinition>());
                 break;
             case TableBlockType.ResourcePropertyDescriptions:
             case TableBlockType.ResponseObjectProperties:
                 Console.WriteLine("Object description that wasn't handled: {0} on method {1}", table.Title, onlyMethod.RequestMetadata.MethodName);
                 break;
             default:
                 Console.WriteLine("Something else that wasn't handled: type:{0}, title:{1} on method {2}", table.Type, table.Title, onlyMethod.RequestMetadata.MethodName);
                 break;
         }
     }
 }