public void ValidateKeyMustMatchRegularExpressionInComponents()
{
// Arrange
const string key = "%@abc";
OpenApiComponents components = new OpenApiComponents()
{
Responses = new Dictionary <string, OpenApiResponse>
{
{ key, new OpenApiResponse {
Description = "any"
} }
}
};
var errors = components.Validate();
// Act
bool result = !errors.Any();
// Assert
Assert.False(result);
Assert.NotNull(errors);
OpenApiError error = Assert.Single(errors);
Assert.Equal(String.Format(SRResource.Validation_ComponentsKeyMustMatchRegularExpr, key, "responses", OpenApiComponentsRules.KeyRegex.ToString()),
error.Message);
}
public void IsSharedContract(bool expected, OpenApiSchema openApiSchema, OpenApiComponents openApiComponents)
{
// Act
var actual = openApiSchema.IsSharedContract(openApiComponents);
// Assert
Assert.Equal(expected, actual);
}
public static OpenApiComponents AddSecurity(this OpenApiComponents components, IEnumerable <string> roles, AuthOptions.CqApiAuthOptions options)
{
components.SecuritySchemes.Add("auth", new OpenApiSecurityScheme
{
Scheme = "bearer",
Type = SecuritySchemeType.Http,
});
return(components);
}
public static OpenApiComponents LoadComponents(ParseNode node)
{
var mapNode = node.CheckMapNode("components");
var components = new OpenApiComponents();
ParseMap(mapNode, components, _componentsFixedFields, _componentsPatternFields);
return(components);
}
/// <summary>
/// Escapes the # character from the description of the 'microsoft.graph.networkInterface' schema.
/// </summary>
/// <remarks>
/// This particular schema has a '#' character within the description of one of
/// its schema definitions that breaks the PowerShell client code gen.
/// Below is a temporary fix awaiting a permanent solution from AutoRest
/// </remarks>
/// <param name="components">The <see cref="OpenApiComponents"/> object with the target schema.</param>
private static void EscapePoundCharacter(OpenApiComponents components)
{
if (components.Schemas.TryGetValue("microsoft.graph.networkInterface", out OpenApiSchema parentSchema))
{
if (parentSchema.Properties.TryGetValue("description", out OpenApiSchema descriptionSchema))
{
// PowerShell uses ` to escape special characters
descriptionSchema.Description = descriptionSchema.Description.Replace("<#>", "<#/>");
}
}
}
public override void Visit(OpenApiComponents components)
{
ResolveMap(components.Parameters);
ResolveMap(components.RequestBodies);
ResolveMap(components.Responses);
ResolveMap(components.Links);
ResolveMap(components.Callbacks);
ResolveMap(components.Examples);
ResolveMap(components.Schemas);
ResolveMap(components.SecuritySchemes);
}
private static Dictionary <string, OpenApiSchema> GetSchema(OpenApiComponents components,
Dictionary <string, string> mapping)
{
var result = new Dictionary <string, OpenApiSchema>();
foreach (var map in mapping)
{
result.Add(map.Key, refPointer.ResolveRef(components, new OpenApiSchema(), map.Value));
}
return(result);
}
public static OpenApiComponents CreateComponents(ParsingNode node)
{
var components = new OpenApiComponents();
var definitions = node.storage.Retrieve <IDictionary <string, OpenApiSchema> >("root.definitions");
if (definitions != null)
{
components.Schemas = new Dictionary <string, OpenApiSchema>();
foreach (var schema in definitions)
{
components.Schemas.Add(schema);
}
}
var parameters = node.storage.Retrieve <IDictionary <string, OpenApiParameter> >("root.parameters");
if (parameters != null)
{
components.Parameters = new Dictionary <string, OpenApiParameter>();
components.RequestBodies = new Dictionary <string, OpenApiRequestBody>();
foreach (var parameter in parameters)
{
if (parameter.Value.In == OpenApiParameterLocation.Body || parameter.Value.In == OpenApiParameterLocation.FormData)
{
components.RequestBodies.Add(parameter.Key, BodyParameterToRequestBody(node, parameter.Value));
}
else
{
components.Parameters.Add(parameter);
}
}
}
var responses = node.storage.Retrieve <IDictionary <string, OpenApiResponse> >("root.responses");
if (responses != null)
{
components.Responses = new OpenApiResponses();
foreach (var response in responses)
{
components.Responses.Add(response);
}
}
var securityDefinitions = node.storage.Retrieve <IDictionary <string, OpenApiSecurityScheme> >("root.securityDefinitions");
if (securityDefinitions != null)
{
components.SecuritySchemes = new Dictionary <string, OpenApiSecurityScheme>();
foreach (var scheme in securityDefinitions)
{
components.SecuritySchemes.Add(scheme);
}
}
return(components);
}
static public IOpenApiAny GetExample(Type parameter, TypeMaps maps, OpenApiComponents components)
{
if (components.Schemas.ContainsKey(parameter.Name))
{
return(components.Schemas[parameter.Name].Example);
}
if (maps.ContainsMap(parameter))
{
return(maps.GetMap(parameter).OpenApiExample);
}
else if (parameter == typeof(string))
{
int randomNum = new Random().Next() % 3;
var words = new string[] { "foo", "bar", "baz" };
return(new OpenApiString(words[randomNum]));
}
else if (IsNumericType(parameter))
{
int randomNum = new Random().Next() % 400;
return(new OpenApiInteger(randomNum));
}
else if (parameter == typeof(bool))
{
int randomNum = new Random().Next() % 1;
return(new OpenApiBoolean(randomNum == 0));
}
else if (parameter.GetInterfaces().Contains(typeof(IEnumerable)))
{
var exampleArr = new OpenApiArray();
int randomNum = new Random().Next() % 3;
for (int _ = 0; _ < randomNum + 1; _++)
{
var innerType = parameter.GetElementType() ?? parameter.GenericTypeArguments[0];
exampleArr.Add(GetExample(innerType, maps, components));
}
return(exampleArr);
}
else
{
if (parameter.GetProperties().Length == 0)
{
return(new OpenApiNull());
}
var example = new OpenApiObject();
foreach (var prop in parameter.GetProperties())
{
example.Add(prop.Name, GetExample(prop.PropertyType, maps, components));
}
return(example);
}
}
private void AddLink(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiReference unresolved)
{
var linkNodes = nodes.Where(c => c.Name == "links").First().Value as ObjectParsingNode;
var linkRef = linkNodes.childNodes.Where(c => c.Name == unresolved.Id).First();
if (components.Links.ContainsKey(linkRef.Name))
{
return;
}
var resolvedLink = linkRef.Value.ParseIntoElement <OpenApiLink, OpenApiLinkParsingStrategy>();
components.Links.Add(linkRef.Name, resolvedLink);
}
private void AddExample(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiReference unresolved)
{
var exampleNodes = nodes.Where(c => c.Name == "examples").First().Value as ObjectParsingNode;
var exampleRef = exampleNodes.childNodes.Where(c => c.Name == unresolved.Id).First();
if (components.Examples.ContainsKey(exampleRef.Name))
{
return;
}
var resolvedExample = exampleRef.Value.ParseIntoElement <OpenApiExample, OpenApiExampleParsingStrategy>();
components.Examples.Add(exampleRef.Name, resolvedExample);
}
private void AddSecurityScheme(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiReference unresolved)
{
var securitySchemeNodes = nodes.Where(c => c.Name == "securitySchemes").First().Value as ObjectParsingNode;
var securitySchemaRef = securitySchemeNodes.childNodes.Where(c => c.Name == unresolved.Id).First();
if (components.SecuritySchemes.ContainsKey(securitySchemaRef.Name))
{
return;
}
var resolvedSecurityScheme = securitySchemaRef.Value.ParseIntoElement <OpenApiSecurityScheme, OpenApiSecuritySchemeParsingStrategy>();
components.SecuritySchemes.Add(securitySchemaRef.Name, resolvedSecurityScheme);
}
/// <summary>
/// Generate CodeDom of the client API for ApiDescriptions.
/// </summary>
/// <param name="descriptions">Web Api descriptions exposed by Configuration.Services.GetApiExplorer().ApiDescriptions</param>
public void CreateCodeDom(OpenApiPaths paths, OpenApiComponents components)
{
if (paths == null && components == null)
{
return;
}
clientNamespace = new CodeNamespace(settings.ClientNamespace);
CodeCompileUnit.Namespaces.Add(clientNamespace); //namespace added to Dom
ComponentsToTsTypes componentsToTsTypes = new ComponentsToTsTypes(settings, CodeCompileUnit, clientNamespace);
componentsToTsTypes.CreateCodeDom(components);
if (paths == null)
{
return;
}
AddBasicReferences();
string[] containerClassNames = GetContainerClassNames(paths);
CodeTypeDeclaration[] newClassesCreated = containerClassNames.Select(d => CreateControllerClientClass(clientNamespace, d)).ToArray();
foreach (KeyValuePair <string, OpenApiPathItem> p in paths)
{
string relativePath = p.Key;
foreach (KeyValuePair <OperationType, OpenApiOperation> op in p.Value.Operations)
{
ClientApiTsFunctionGenAbstract apiFunctionGen = apiFunctionGenFactory();
CodeMemberMethod apiFunction = apiFunctionGen.CreateApiFunction(settings, relativePath, op.Key, op.Value, componentsToTsTypes);
if (apiFunction == null)
{
System.Diagnostics.Trace.TraceWarning($"Not to generate TS for {p.Key} {op.Key}.");
continue;
}
string containerClassName = nameComposer.GetContainerName(op.Value, p.Key);
CodeTypeDeclaration existingClass = LookupExistingClass(containerClassName);
existingClass.Members.Add(apiFunction);
}
}
foreach (CodeTypeDeclaration c in newClassesCreated)
{
AddHelperFunctionsInClass(c);
}
}
private void AddRequestBody(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiReference unresolved)
{
var requestBodyNodes = nodes.Where(c => c.Name == "requestBodies").First().Value as ObjectParsingNode;
var requestBodyRef = requestBodyNodes.childNodes.Where(c => c.Name == unresolved.Id).First();
if (components.RequestBodies.ContainsKey(requestBodyRef.Name))
{
return;
}
var resolvedRequestBody = requestBodyRef.Value.ParseIntoElement <OpenApiRequestBody, OpenApiRequestBodyParsingStrategy>();
components.RequestBodies.Add(requestBodyRef.Name, resolvedRequestBody);
AddRequestBody(nodes, components, resolvedRequestBody); // add resolvedRequestBody.Content, etc
}
private void AddHeader(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiReference unresolved)
{
var headerNodes = nodes.Where(c => c.Name == "headers").First().Value as ObjectParsingNode;
var headerRef = headerNodes.childNodes.Where(c => c.Name == unresolved.Id).First();
if (components.Headers.ContainsKey(headerRef.Name))
{
return;
}
var resolvedHeader = headerRef.Value.ParseIntoElement <OpenApiHeader, OpenApiHeaderParsingStrategy>();
components.Headers.Add(headerRef.Name, resolvedHeader);
AddHeader(nodes, components, resolvedHeader); // add resolvedHeader.schema, resolvedHeader.Examples, etc
}
private void AddCallback(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiReference unresolved)
{
var callbackNodes = nodes.Where(c => c.Name == "callbacks").First().Value as ObjectParsingNode;
var callbackRef = callbackNodes.childNodes.Where(c => c.Name == unresolved.Id).First();
if (components.Callbacks.ContainsKey(callbackRef.Name))
{
return;
}
var resolvedCallback = callbackRef.Value.ParseIntoElement <OpenApiCallback, OpenApiCallbackParsingStrategy>();
components.Callbacks.Add(callbackRef.Name, resolvedCallback);
AddCallback(nodes, components, resolvedCallback);
}
private void AddSchema(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiReference unresolved)
{
var schemaNodes = nodes.Where(c => c.Name == "schemas").First().Value as ObjectParsingNode;
var schemaRef = schemaNodes.childNodes.Where(c => c.Name == unresolved.Id).First();
if (components.Schemas.ContainsKey(schemaRef.Name))
{
return;
}
var resolvedSchema = schemaRef.Value.ParseIntoElement <OpenApiSchema, OpenApiSchemaParsingStrategy>();
components.Schemas.Add(schemaRef.Name, resolvedSchema);
AddSchema(nodes, components, resolvedSchema); // add all subschemas
}
private OpenApiComponents MapComponents(IDictionary <object, object> types)
{
var components = new OpenApiComponents
{
Schemas = new Dictionary <string, OpenApiSchema>()
};
if (types != null)
{
foreach (var key in types.Keys.OfType <string>())
{
switch (types[key])
{
case IDictionary <object, object> values:
if (values.Get("type") == "object")
{
var required = values.GetAsCollection("required");
var properties = values.GetAsDictionary("properties");
components.Schemas.Add(key, MapSchema(properties, required));
}
if (values.ContainsKey("enum"))
{
var enumAsCollection = values.GetAsCollection("enum").OfType <string>();
var enumValues = enumAsCollection
.SelectMany(e => e.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries))
.Select(x => new OpenApiString(x.Trim()));
var schema = new OpenApiSchema
{
Type = "string",
Enum = enumValues.OfType <IOpenApiAny>().ToList()
};
components.Schemas.Add(key, schema);
}
break;
case string jsonOrYaml:
var items = _deserializer.Deserialize <IDictionary <object, object> >(jsonOrYaml);
var requiredX = items.GetAsCollection("required");
var propertiesX = items.GetAsDictionary("properties");
components.Schemas.Add(key, MapSchema(propertiesX, requiredX));
break;
}
}
}
return(components.Schemas.Count > 0 ? components: null);
}
private static KeyValuePair <string, OpenApiSchema> ResolveComposedSchema(OpenApiComponents components, OpenApiSchema schema)
{
var allOfSchemaList = schema.AllOf.ToList();
if (!allOfSchemaList.Any())
{
return(new KeyValuePair <string, OpenApiSchema>(string.Empty, null));
}
// Get combined schema name
var refName = "allOfCombined-";
allOfSchemaList
.ForEach(x => refName += x.Reference?.ReferenceV3);
// If the same refName was already created before
if (components.Schemas.TryGetValue(refName, out var composedSchema))
{
return(new KeyValuePair <string, OpenApiSchema>(refName, composedSchema));
}
//// Add combined schema name with empty schema
//components.Schemas.Add(refName, new OpenApiSchema());
// Construct combined schema
var allOfCombinedSchema = new OpenApiSchema();
allOfCombinedSchema = AddSchema(allOfCombinedSchema, schema);
foreach (var t in allOfSchemaList)
{
var allOfSchema = t;
allOfSchema =
RefPointer.ResolveRef(components, allOfSchema, allOfSchema.Reference?.ReferenceV3);
var result = ResolveComposedSchema(components, allOfSchema);
if (result.Value != null)
{
allOfSchema = result.Value;
}
allOfCombinedSchema = AddSchema(allOfCombinedSchema, allOfSchema);
}
// Set correct combined schema
components.Schemas[refName] = allOfCombinedSchema;
return(new KeyValuePair <string, OpenApiSchema>(refName, allOfCombinedSchema));
}
public void CreateCodeDom(OpenApiComponents components)
{
if (components == null)
{
return;
}
ComponentsSchemas = components.Schemas; //.OrderBy(d => d.Value.Reference != null).OrderBy(k => k.Value.Properties.Count > 0).OrderBy(g => g.Value.AllOf.Count > 0).OrderBy(d => d.Value.Type != "array"); //so simple complex types will be handled first to be referenced by more complex ones.
var classNamespaceNames = NameFunc.FindNamespacesInClassNames(ComponentsSchemas.Keys);
if (classNamespaceNames.Length > 0)
{
var groupedComponentsSchemas = ComponentsSchemas
.GroupBy(d => NameFunc.GetNamespaceOfClassName(d.Key))
.OrderBy(k => k.Key);
var namespacesOfTypes = groupedComponentsSchemas.Select(d => d.Key).ToArray();
foreach (var groupedTypes in groupedComponentsSchemas)
{
var classNamespaceText = groupedTypes.Key;
var classNamespace = new CodeNamespace(classNamespaceText);
codeCompileUnit.Namespaces.Add(classNamespace);
ClassNamespaces.Add(classNamespace);
foreach (var kv in groupedTypes.OrderBy(t => t.Key))
{
var existingType = ComponentsHelper.FindTypeDeclarationInNamespace(NameFunc.RefineTypeName(kv.Key, classNamespaceText), classNamespace);
if (existingType == null)
{
AddTypeToCodeDom(kv);
}
}
}
}
else
{
foreach (KeyValuePair <string, OpenApiSchema> item in ComponentsSchemas)
{
var existingType = FindTypeDeclarationInNamespaces(NameFunc.RefineTypeName(item.Key, null), null);
if (existingType == null)
{
AddTypeToCodeDom(item);
}
}
}
}
public void OpenApiComponentsComparerShouldSucceed(
string testCaseName,
OpenApiComponents source,
OpenApiComponents target,
List <OpenApiDifference> expectedDifferences)
{
_output.WriteLine(testCaseName);
var comparisonContext = new ComparisonContext(new OpenApiComparerFactory(), _sourceDocument,
_targetDocument);
var comparer = new OpenApiComponentsComparer();
comparer.Compare(source, target, comparisonContext);
var differences = comparisonContext.OpenApiDifferences.ToList();
differences.Count().ShouldBeEquivalentTo(expectedDifferences.Count);
differences.ShouldBeEquivalentTo(expectedDifferences);
}
public void ValidateSchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator()
{
IEnumerable <OpenApiError> errors;
var components = new OpenApiComponents
{
Schemas =
{
{
"schema1",
new OpenApiSchema
{
Type = "object",
Discriminator = new OpenApiDiscriminator{
PropertyName = "property1"
},
Reference = new OpenApiReference{
Id = "schema1"
}
}
}
}
};
// Act
var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
var walker = new OpenApiWalker(validator);
walker.Walk(components);
errors = validator.Errors;
bool result = !errors.Any();
// Assert
result.Should().BeFalse();
errors.Should().BeEquivalentTo(new List <OpenApiValidatorError>
{
new OpenApiValidatorError(nameof(OpenApiSchemaRules.ValidateSchemaDiscriminator), "#/schemas/schema1/discriminator",
string.Format(SRResource.Validation_SchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator,
"schema1", "property1"))
});
}
public static string GeneritorSwaggerHtml(string templatePath, OpenApiDocument model)
{
//foreach (var item in model.Paths)
//{
// var obj = item.Value.Operations.FirstOrDefault();
// if (obj.Key.ToString() == "Post")
// {
// var response = obj.Value.Responses.FirstOrDefault();
// if (response.Value.Content != null && response.Value.Content.Count > 0)
// {
// foreach (var t in response.Value.Content)
// {
// var reference = t.Value.Schema.Reference;
// if (reference != null)
// {
// var schema = GetOpenApiSchemaInfo(reference.Id);
// if (schema != null)
// {
// foreach (var param in schema.Properties)
// {
// }
// }
// }
// }
// }
// }
//}
components = model.Components;
var template = System.IO.File.ReadAllText(templatePath);
var result = Engine.Razor.RunCompile(template, "SwaggerDocs", typeof(OpenApiDocument), model);
//var result = Engine.Razor.RunCompile(new LoadedTemplateSource(template, templatePath), typeof(SwaggerDocument), null, model);
return(result);
}
private static ImmutableDictionary <SecuritySchemeType, ParameterLocation> GetListOfSecuritySchemes(
OpenApiComponents components, OpenApiSecurityRequirement securityRequirement)
{
var tmpResult = new Dictionary <SecuritySchemeType, ParameterLocation>();
foreach (var openApiSecurityScheme in securityRequirement.Keys.ToList())
{
if (components.SecuritySchemes.TryGetValue(openApiSecurityScheme.Reference?.ReferenceV3,
out var result))
{
if (!tmpResult.ContainsKey(result.Type))
{
tmpResult.Add(result.Type, result.In);
}
}
else
{
throw new ArgumentException("Impossible to find security scheme: " + openApiSecurityScheme.Scheme);
}
}
return(tmpResult.ToImmutableDictionary());
}
private void AddRequestBody(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiRequestBody requestBody)
{
if (requestBody == null)
{
return;
}
if (requestBody.UnresolvedReference)
{
AddRequestBody(nodes, components, requestBody.Reference);
return;
}
foreach (var content in requestBody.Content)
{
AddSchema(nodes, components, content.Value.Schema);
foreach (var example in content.Value.Examples)
{
if (example.Value.UnresolvedReference)
{
AddExample(nodes, components, example.Value.Reference);
}
}
}
}
public void CheckProjectSchema()
{
var components = new OpenApiComponents();
new ComponentBuilder(components)
.LoadTypeToSchema <ProjectDto>();
components.Schemas.Should().HaveKey("ProjectDto");
var projectDto = components.Schemas["ProjectDto"];
projectDto.Type.Should().Be("object");
projectDto.Properties.Should().HaveKey("id");
projectDto.Properties.Should().HaveKey("name");
var id = projectDto.Properties["id"];
id.Type.Should().Be("string");
var name = projectDto.Properties["name"];
name.Type.Should().Be("string");
}
public T ResolveRef(OpenApiComponents components, T t, string reference)
{
if (reference != null)
{
var refName = GetRefName(reference);
var maps = GetMap(components);
maps.TryGetValue(refName, out var result);
if (result == null)
{
var caseInsensitiveDictionary = new Dictionary <string, T>(maps, StringComparer.OrdinalIgnoreCase);
if (caseInsensitiveDictionary.TryGetValue(refName, out var insensitiveValue))
{
throw new Exception(
$"Reference case sensitive error. {refName} is not equal to {caseInsensitiveDictionary.First(x => x.Value.Equals(insensitiveValue)).Key}");
}
throw new AggregateException($"ref '{reference}' doesn't exist.");
}
return(result);
}
return(t);
}
public override void ResolveReferences(OpenApiComponents components)
{
base.ResolveReferences(components);
Element?.ResolveReferences(components);
}
/// <summary> /// Resolves the <see cref="OpenApiSchema.Reference"/> in the <paramref name="link"/>, if present, using <paramref name="components"/>. /// </summary> public static OpenApiLink Resolve([NotNull] this OpenApiLink link, [NotNull] OpenApiComponents components) => link.Resolve(components.Links);
/// <summary> /// Resolves the <see cref="OpenApiSchema.Reference"/> in the <paramref name="schema"/>, if present, using <paramref name="components"/>. /// </summary> public static OpenApiSchema Resolve([NotNull] this OpenApiSchema schema, [NotNull] OpenApiComponents components) => schema.Resolve(components.Schemas);
