/// <summary>
/// Based on data in the codeBlock, see if we can infer what kind of block this is
/// </summary>
/// <param name="codeBlock"></param>
/// <returns></returns>
private static CodeBlockType InferBlockType(Block codeBlock, string resourceTypeName = null)
{
if (codeBlock.CodeLanguage == "http")
{
// See if this is an HTTP request or HTTP response
Http.HttpParser parser = new Http.HttpParser();
try
{
parser.ParseHttpRequest(codeBlock.Content);
return(CodeBlockType.Request);
}
catch { }
try
{
parser.ParseHttpResponse(codeBlock.Content);
return(CodeBlockType.Response);
}
catch { }
}
else if (codeBlock.CodeLanguage == "json" && !string.IsNullOrEmpty(resourceTypeName))
{
return(CodeBlockType.Resource);
}
return(CodeBlockType.Unknown);
}
public void SplitRequestUrl(out string relativePath, out string queryString, out string httpMethod)
{
var parser = new HttpParser();
var request = parser.ParseHttpRequest(this.Request);
httpMethod = request.Method;
request.Url.SplitUrlComponents(out relativePath, out queryString);
}
/// <summary>
/// Check to ensure the http request is valid
/// </summary>
/// <param name="detectedErrors"></param>
internal void VerifyHttpRequest(List<ValidationError> detectedErrors)
{
HttpParser parser = new HttpParser();
HttpRequest request;
try
{
request = parser.ParseHttpRequest(this.Request);
}
catch (Exception ex)
{
detectedErrors.Add(new ValidationError(ValidationErrorCode.HttpParserError, null, "Exception while parsing HTTP request: {0}", ex.Message));
return;
}
if (null != request.ContentType)
{
if (request.IsMatchingContentType(MimeTypeJson))
{
// Verify that the request is valid JSON
try
{
JsonConvert.DeserializeObject(request.Body);
}
catch (Exception ex)
{
detectedErrors.Add(new ValidationError(ValidationErrorCode.JsonParserException, null, "Invalid JSON format: {0}", ex.Message));
}
}
else if (request.IsMatchingContentType(MimeTypeMultipartRelated))
{
// TODO: Parse the multipart/form-data body to ensure it's properly formatted
}
else if (request.IsMatchingContentType(MimeTypePlainText))
{
// Ignore this, because it isn't something we can verify
}
else
{
detectedErrors.Add(new ValidationWarning(ValidationErrorCode.UnsupportedContentType, null, "Unvalidated request content type: {0}", request.ContentType));
}
}
var verifyApiRequirementsResponse = request.IsRequestValid(this.SourceFile.DisplayName, this.SourceFile.Parent.Requirements);
detectedErrors.AddRange(verifyApiRequirementsResponse.Messages);
}
/// <summary>
/// Take a scenario definition and convert the prototype request into a fully formed request. This includes appending
/// the base URL to the request URL, executing any test-setup requests, and replacing the placeholders in the prototype
/// request with proper values.
/// </summary>
/// <param name="scenario"></param>
/// <param name="documents"></param>
/// <param name="account"></param>
/// <returns></returns>
public async Task<ValidationResult<HttpRequest>> GenerateMethodRequestAsync(ScenarioDefinition scenario, DocSet documents, IServiceAccount account)
{
var parser = new HttpParser();
var request = parser.ParseHttpRequest(this.Request);
AddAccessTokenToRequest(account.CreateCredentials(), request);
AddTestHeaderToRequest(scenario, request);
AddAdditionalHeadersToRequest(account, request);
List<ValidationError> errors = new List<ValidationError>();
if (null != scenario)
{
var storedValuesForScenario = new Dictionary<string, string>();
if (null != scenario.TestSetupRequests)
{
foreach (var setupRequest in scenario.TestSetupRequests)
{
var result = await setupRequest.MakeSetupRequestAsync(storedValuesForScenario, documents, scenario, account);
errors.AddRange(result.Messages);
if (result.IsWarningOrError)
{
// If we can an error or warning back from a setup method, we fail the whole request.
return new ValidationResult<HttpRequest>(null, errors);
}
}
}
try
{
var placeholderValues = scenario.RequestParameters.ToPlaceholderValuesArray(storedValuesForScenario);
request.RewriteRequestWithParameters(placeholderValues);
}
catch (Exception ex)
{
// Error when applying parameters to the request
errors.Add(
new ValidationError(
ValidationErrorCode.RewriteRequestFailure,
"GenerateMethodRequestAsync",
ex.Message));
return new ValidationResult<HttpRequest>(null, errors);
}
if (scenario.StatusCodesToRetry != null)
{
request.RetryOnStatusCode =
(from status in scenario.StatusCodesToRetry select (System.Net.HttpStatusCode)status).ToList();
}
}
if (string.IsNullOrEmpty(request.Accept))
{
if (!string.IsNullOrEmpty(ValidationConfig.ODataMetadataLevel))
{
request.Accept = MimeTypeJson + "; " + ValidationConfig.ODataMetadataLevel;
}
else
{
request.Accept = MimeTypeJson;
}
}
return new ValidationResult<HttpRequest>(request, errors);
}
internal static IEnumerable<ParameterDefinition> MissingRequestParameters(this MethodDefinition method, bool queryStringOnly = false)
{
HttpParser parser = new HttpParser();
var request = parser.ParseHttpRequest(method.Request);
string urlString = request.Url;
string path, queryString;
urlString.SplitUrlComponents(out path, out queryString);
List<ParameterDefinition> missingParameters = new List<ParameterDefinition>();
if (!queryStringOnly)
{
missingParameters.AddRange(from id in FindVariablesInString(path)
where !method.Parameters.HasMatchingParameter(id, ParameterLocation.Path)
select new ParameterDefinition { Name = id, Location = ParameterLocation.Path, Required = true, Type = ParameterDataType.String });
}
if (!string.IsNullOrEmpty(queryString))
{
missingParameters.AddRange(from id in FindVariablesInQueryString(queryString)
where !method.Parameters.HasMatchingParameter(id, ParameterLocation.QueryString)
select new ParameterDefinition { Name = id, Location = ParameterLocation.QueryString, Required = false, Type = ParameterDataType.String });
}
return missingParameters;
}
private static HttpRequest ParseHttpRequest(string rawHttpRequest)
{
HttpParser parser = new HttpParser();
HttpRequest request = parser.ParseHttpRequest(rawHttpRequest);
return request;
}
/// <summary>
/// Based on data in the codeBlock, see if we can infer what kind of block this is
/// </summary>
/// <param name="codeBlock"></param>
/// <returns></returns>
private static CodeBlockType InferBlockType(Block codeBlock, string resourceTypeName = null)
{
if (codeBlock.CodeLanguage == "http")
{
// See if this is an HTTP request or HTTP response
Http.HttpParser parser = new Http.HttpParser();
try
{
parser.ParseHttpRequest(codeBlock.Content);
return CodeBlockType.Request;
}
catch { }
try
{
parser.ParseHttpResponse(codeBlock.Content);
return CodeBlockType.Response;
}
catch { }
}
else if (codeBlock.CodeLanguage == "json" && !string.IsNullOrEmpty(resourceTypeName))
{
return CodeBlockType.Resource;
}
return CodeBlockType.Unknown;
}
