private void CollectHeaderReferences(OpenApiHeader header)
{
if (header == null)
{
return;
}
if (header.UnresolvedReference)
{
if (!_unresolvedReferences.Contains(header.Reference))
{
_unresolvedReferences.Add(header.Reference);
}
return;
}
CollectSchemaReferences(header.Schema);
foreach (var content in header.Content)
{
CollectMediaTypeReferences(content.Value);
}
foreach (var example in header.Examples)
{
if (example.Value.UnresolvedReference && !_unresolvedReferences.Contains(example.Value.Reference))
{
_unresolvedReferences.Add(example.Value.Reference);
}
}
}
public void ValidateExampleShouldNotHaveDataTypeMismatchForSimpleSchema()
{
// Arrange
IEnumerable <OpenApiError> errors;
var header = new OpenApiHeader()
{
Required = true,
Example = new OpenApiInteger(55),
Schema = new OpenApiSchema()
{
Type = "string",
}
};
// Act
var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
var walker = new OpenApiWalker(validator);
walker.Walk(header);
errors = validator.Errors;
bool result = !errors.Any();
// Assert
result.Should().BeFalse();
errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
{
RuleHelpers.DataTypeMismatchedErrorMessage
});
errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
{
"#/example",
});
}
private static OpenApiSchema GetOrCreateSchema(OpenApiHeader p)
{
if (p.Schema == null)
{
p.Schema = new OpenApiSchema();
}
return(p.Schema);
}
/// <summary>
/// Visits <see cref="OpenApiHeader"/> and child objects
/// </summary>
/// <param name="header"></param>
internal void Walk(OpenApiHeader header)
{
_visitor.Visit(header);
Walk(header.Content);
Walk(header.Example);
Walk(header.Examples);
Walk(header.Schema);
Walk(header as IOpenApiExtensible);
}
/// <summary>
/// Visits <see cref="OpenApiHeader"/> and child objects
/// </summary>
internal void Walk(OpenApiHeader header)
{
if (header == null)
{
return;
}
_visitor.Visit(header);
Walk(OpenApiConstants.Content, () => Walk(header.Content));
Walk(OpenApiConstants.Example, () => Walk(header.Example));
Walk(OpenApiConstants.Examples, () => Walk(header.Examples));
Walk(OpenApiConstants.Schema, () => Walk(header.Schema));
Walk(header as IOpenApiExtensible);
}
public override void Visit(OpenApiHeader header)
{
if (header.UnresolvedReference)
{
throw new ArgumentException("Single pass reference resolution expects this element to already be resolved");
}
var schema = ResolveElement(header.Schema);
if (schema != null)
{
header.Schema = schema as OpenApiSchema;
}
ResolveDict(header.Examples);
}
/// <summary>
/// Visits <see cref="OpenApiHeader"/> and child objects
/// </summary>
internal void Walk(OpenApiHeader header, bool isComponent = false)
{
if (header == null || ProcessAsReference(header, isComponent))
{
return;
}
_visitor.Visit(header);
Walk(OpenApiConstants.Content, () => Walk(header.Content));
Walk(OpenApiConstants.Example, () => Walk(header.Example));
Walk(OpenApiConstants.Examples, () => Walk(header.Examples));
Walk(OpenApiConstants.Schema, () => Walk(header.Schema));
Walk(header as IOpenApiExtensible);
}
private static IOpenApiReferenceable ResolveReferenceOnHeaderElement(
OpenApiHeader headerElement,
string propertyName,
string mapKey,
JsonPointer pointer)
{
switch (propertyName)
{
case OpenApiConstants.Schema:
return(headerElement.Schema);
case OpenApiConstants.Examples when mapKey != null:
return(headerElement.Examples[mapKey]);
default:
throw new OpenApiException(string.Format(SRResource.InvalidReferenceId, pointer));
}
}
public static OpenApiHeader LoadHeader(ParseNode node)
{
var mapNode = node.CheckMapNode("header");
var header = new OpenApiHeader();
foreach (var property in mapNode)
{
property.ParseField(header, _headerFixedFields, _headerPatternFields);
}
var schema = node.Context.GetFromTempStorage <OpenApiSchema>("schema");
if (schema != null)
{
header.Schema = schema;
node.Context.SetTempStorage("schema", null);
}
return(header);
}
public static OpenApiHeader LoadHeader(ParseNode node)
{
var mapNode = node.CheckMapNode("header");
var pointer = mapNode.GetReferencePointer();
if (pointer != null)
{
return(mapNode.GetReferencedObject <OpenApiHeader>(ReferenceType.Header, pointer));
}
var header = new OpenApiHeader();
foreach (var property in mapNode)
{
property.ParseField(header, _headerFixedFields, _headerPatternFields);
}
return(header);
}
public void Traverse(OpenApiHeader header)
{
if (header == null)
{
return;
}
Visitor.Visit(header);
Traverse(header.Schema);
if (header.Examples != null)
{
foreach (var example in header.Examples)
{
Traverse(example.Value);
}
}
if (header.Content != null)
{
foreach (var mediaType in header.Content)
{
Traverse(mediaType.Value);
}
}
}
private static void LoadStyle(OpenApiHeader header, string style)
{
switch (style)
{
case "csv":
header.Style = ParameterStyle.Simple;
return;
case "ssv":
header.Style = ParameterStyle.SpaceDelimited;
return;
case "pipes":
header.Style = ParameterStyle.PipeDelimited;
return;
case "tsv":
throw new NotSupportedException();
default:
throw new OpenApiReaderException("Unrecognized header style: " + style);
}
}
public void ValidateExamplesShouldNotHaveDataTypeMismatchForSimpleSchema()
{
// Arrange
IEnumerable <OpenApiError> errors;
var header = new OpenApiHeader()
{
Required = true,
Schema = new OpenApiSchema()
{
Type = "object",
AdditionalProperties = new OpenApiSchema()
{
Type = "integer",
}
},
Examples =
{
["example0"] = new OpenApiExample()
{
Value = new OpenApiString("1"),
},
["example1"] = new OpenApiExample()
{
Value = new OpenApiObject()
{
["x"] = new OpenApiInteger(2),
["y"] = new OpenApiString("20"),
["z"] = new OpenApiString("200")
}
},
["example2"] = new OpenApiExample()
{
Value =
new OpenApiArray()
{
new OpenApiInteger(3)
}
},
["example3"] = new OpenApiExample()
{
Value = new OpenApiObject()
{
["x"] = new OpenApiInteger(4),
["y"] = new OpenApiInteger(40),
}
},
}
};
// Act
var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
var walker = new OpenApiWalker(validator);
walker.Walk(header);
errors = validator.Errors;
bool result = !errors.Any();
// Assert
result.Should().BeFalse();
errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
{
RuleHelpers.DataTypeMismatchedErrorMessage,
RuleHelpers.DataTypeMismatchedErrorMessage,
RuleHelpers.DataTypeMismatchedErrorMessage,
});
errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
{
// #enum/0 is not an error since the spec allows
// representing an object using a string.
"#/examples/example1/value/y",
"#/examples/example1/value/z",
"#/examples/example2/value"
});
}
private void AddHeader(IList <PropertyParsingNode> nodes, OpenApiComponents components, OpenApiHeader header)
{
if (header == null)
{
return;
}
if (header.UnresolvedReference)
{
AddHeader(nodes, components, header.Reference);
return;
}
AddSchema(nodes, components, header.Schema);
foreach (var example in header.Examples)
{
if (example.Value.UnresolvedReference)
{
AddExample(nodes, components, example.Value.Reference);
}
}
foreach (var content in header.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 override void Visit(OpenApiHeader tag)
{
EncodeCall();
base.Visit(tag);
}
/// <summary> /// Execute validation rules against an <see cref="OpenApiHeader"/> /// </summary> /// <param name="item">The object to be validated</param> public override void Visit(OpenApiHeader item) => Validate(item);
public void LocateReferences()
{
var baseSchema = new OpenApiSchema()
{
Reference = new OpenApiReference()
{
Id = "base",
Type = ReferenceType.Schema
},
UnresolvedReference = false
};
var derivedSchema = new OpenApiSchema
{
AnyOf = new List <OpenApiSchema>()
{
baseSchema
},
Reference = new OpenApiReference()
{
Id = "derived",
Type = ReferenceType.Schema
},
UnresolvedReference = false
};
var testHeader = new OpenApiHeader()
{
Schema = derivedSchema,
Reference = new OpenApiReference()
{
Id = "test-header",
Type = ReferenceType.Header
},
UnresolvedReference = false
};
var doc = new OpenApiDocument
{
Paths = new OpenApiPaths()
{
["/"] = new OpenApiPathItem()
{
Operations = new Dictionary <OperationType, OpenApiOperation>()
{
[OperationType.Get] = new OpenApiOperation()
{
Responses = new OpenApiResponses()
{
["200"] = new OpenApiResponse()
{
Content = new Dictionary <string, OpenApiMediaType>()
{
["application/json"] = new OpenApiMediaType()
{
Schema = derivedSchema
}
},
Headers = new Dictionary <string, OpenApiHeader>()
{
["test-header"] = testHeader
}
}
}
}
}
}
},
Components = new OpenApiComponents()
{
Schemas = new Dictionary <string, OpenApiSchema>()
{
["derived"] = derivedSchema,
["base"] = baseSchema,
},
Headers = new Dictionary <string, OpenApiHeader>()
{
["test-header"] = testHeader
}
}
};
var locator = new LocatorVisitor();
var walker = new OpenApiWalker(locator);
walker.Walk(doc);
locator.Locations.Where(l => l.StartsWith("referenceAt:")).ShouldBeEquivalentTo(new List <string> {
"referenceAt: #/paths/~1/get/responses/200/content/application~1json/schema",
"referenceAt: #/paths/~1/get/responses/200/headers/test-header",
"referenceAt: #/components/schemas/derived/anyOf/0",
"referenceAt: #/components/headers/test-header/schema"
});
}
public virtual void Visit(OpenApiHeader header)
{
}
/// <summary>
/// Visits <see cref="OpenApiHeader"/>
/// </summary>
public virtual void Visit(OpenApiHeader tag)
{
}
public ChangedHeaderBO(OpenApiHeader oldHeader, OpenApiHeader newHeader, DiffContextBO context)
{
OldHeader = oldHeader;
NewHeader = newHeader;
_context = context;
}
