public void ParseBasicXmlShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicXml.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var xml = OpenApiV3Deserializer.LoadXml(node);
// Assert
xml.ShouldBeEquivalentTo(
new OpenApiXml
{
Name = "name1",
Namespace = new Uri("http://example.com/schema/namespaceSample"),
Prefix = "samplePrefix",
Wrapped = true
});
}
}
public void ParseQueryParameterWithObjectTypeShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "queryParameterWithObjectType.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV3Deserializer.LoadParameter(node);
// Assert
parameter.ShouldBeEquivalentTo(
new OpenApiParameter
{
In = ParameterLocation.Query,
Name = "freeForm",
Schema = new OpenApiSchema
{
Type = "object",
AdditionalProperties = new OpenApiSchema
{
Type = "integer"
}
},
Style = ParameterStyle.Form
});
}
public void ParseHttpSecuritySchemeShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "httpSecurityScheme.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.Should().BeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.Http,
Scheme = "basic"
});
}
}
public void ParseMediaTypeWithExamplesShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "mediaTypeWithExamples.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var mediaType = OpenApiV3Deserializer.LoadMediaType(node);
// Assert
mediaType.ShouldBeEquivalentTo(
new OpenApiMediaType
{
Examples =
{
["example1"] = new OpenApiExample()
{
Value = new OpenApiFloat(5),
},
["example2"] = new OpenApiExample()
{
Value = new OpenApiFloat((float)7.5),
}
},
Schema = new OpenApiSchema
{
Type = "number",
Format = "float"
}
});
}
public void ParseQueryParameterShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "queryParameter.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV3Deserializer.LoadParameter(node);
// Assert
parameter.ShouldBeEquivalentTo(
new OpenApiParameter
{
In = ParameterLocation.Query,
Name = "id",
Description = "ID of the object to fetch",
Required = false,
Schema = new OpenApiSchema
{
Type = "array",
Items = new OpenApiSchema
{
Type = "string"
}
},
Style = ParameterStyle.Form,
Explode = true
});
}
public void ParseHeaderParameterShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "headerParameter.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV3Deserializer.LoadParameter(node);
// Assert
parameter.ShouldBeEquivalentTo(
new OpenApiParameter
{
In = ParameterLocation.Header,
Name = "token",
Description = "token to be passed as a header",
Required = true,
Style = ParameterStyle.Simple,
Schema = new OpenApiSchema
{
Type = "array",
Items = new OpenApiSchema
{
Type = "integer",
Format = "int64",
}
}
});
}
public void ParsePathParameterShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "pathParameter.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV3Deserializer.LoadParameter(node);
// Assert
parameter.ShouldBeEquivalentTo(
new OpenApiParameter
{
In = ParameterLocation.Path,
Name = "username",
Description = "username to fetch",
Required = true,
Schema = new OpenApiSchema
{
Type = "string"
}
});
}
public void ParseBearerSecuritySchemeShouldSucceed()
{
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "bearerSecurityScheme.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.Http,
Scheme = "bearer",
BearerFormat = "JWT"
});
}
}
public void ParseApiKeySecuritySchemeShouldSucceed()
{
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "apiKeySecurityScheme.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.ApiKey,
Name = "api_key",
In = ParameterLocation.Header
});
}
}
public void ParseDictionarySchemaShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "dictionarySchema.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var schema = OpenApiV3Deserializer.LoadSchema(node);
// Assert
diagnostic.ShouldBeEquivalentTo(new OpenApiDiagnostic());
schema.ShouldBeEquivalentTo(
new OpenApiSchema
{
Type = "object",
AdditionalProperties = new OpenApiSchema
{
Type = "string"
}
});
}
}
public void ParseBasicDiscriminatorShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicDiscriminator.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var discriminator = OpenApiV3Deserializer.LoadDiscriminator(node);
// Assert
discriminator.Should().BeEquivalentTo(
new OpenApiDiscriminator
{
PropertyName = "pet_type",
Mapping =
{
["puppy"] = "#/components/schemas/Dog",
["kitten"] = "Cat"
}
});
}
}
public void ParseMinimalInfoShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "minimalInfo.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var openApiInfo = OpenApiV3Deserializer.LoadInfo(node);
// Assert
openApiInfo.Should().BeEquivalentTo(
new OpenApiInfo
{
Title = "Minimal Info",
Version = "1.0.1"
});
}
}
public void ParsePrimitiveSchemaShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "primitiveSchema.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var schema = OpenApiV3Deserializer.LoadSchema(node);
// Assert
diagnostic.Should().BeEquivalentTo(new OpenApiDiagnostic());
schema.Should().BeEquivalentTo(
new OpenApiSchema
{
Type = "string",
Format = "email"
});
}
}
public void ParseOpenIdConnectSecuritySchemeShouldSucceed()
{
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "openIdConnectSecurityScheme.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.OpenIdConnect,
Description = "Sample Description",
OpenIdConnectUrl = new Uri("http://www.example.com")
});
}
}
public void ParseParameterWithExampleShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "parameterWithExample.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV3Deserializer.LoadParameter(node);
// Assert
parameter.ShouldBeEquivalentTo(
new OpenApiParameter
{
In = null,
Name = "username",
Description = "username to fetch",
Required = true,
Example = new OpenApiFloat(5),
Schema = new OpenApiSchema
{
Type = "number",
Format = "float"
}
});
}
public void ParseAdvancedInfoShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "advancedInfo.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var openApiInfo = OpenApiV3Deserializer.LoadInfo(node);
// Assert
openApiInfo.Should().BeEquivalentTo(
new OpenApiInfo
{
Title = "Advanced Info",
Description = "Sample Description",
Version = "1.0.0",
TermsOfService = new Uri("http://example.org/termsOfService"),
Contact = new OpenApiContact
{
Email = "*****@*****.**",
Extensions =
{
["x-twitter"] = new OpenApiString("@exampleTwitterHandler")
},
Name = "John Doe",
Url = new Uri("http://www.example.com/url1")
},
License = new OpenApiLicense
{
Extensions = { ["x-disclaimer"] = new OpenApiString("Sample Extension String Disclaimer") },
Name = "licenseName",
Url = new Uri("http://www.example.com/url2")
},
Extensions =
{
["x-something"] = new OpenApiString("Sample Extension String Something"),
["x-contact"] = new OpenApiObject
{
["name"] = new OpenApiString("John Doe"),
["url"] = new OpenApiString("http://www.example.com/url3"),
["email"] = new OpenApiString("*****@*****.**")
},
["x-list"] = new OpenApiArray
{
new OpenApiString("1"),
new OpenApiString("2")
}
}
});
}
}
public void ParseOperationWithParameterWithNoLocationShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "operationWithParameterWithNoLocation.json")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var operation = OpenApiV3Deserializer.LoadOperation(node);
// Assert
operation.ShouldBeEquivalentTo(new OpenApiOperation()
{
Tags =
{
new OpenApiTag
{
UnresolvedReference = true,
Reference = new OpenApiReference()
{
Id = "user",
Type = ReferenceType.Tag
}
}
},
Summary = "Logs user into the system",
Description = "",
OperationId = "loginUser",
Parameters =
{
new OpenApiParameter
{
Name = "username",
Description = "The user name for login",
Required = true,
Schema = new OpenApiSchema
{
Type = "string"
}
},
new OpenApiParameter
{
Name = "password",
Description = "The password for login in clear text",
In = ParameterLocation.Query,
Required = true,
Schema = new OpenApiSchema
{
Type = "string"
}
}
}
});
}
public void ParseAdvancedExampleShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "advancedExample.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
var example = OpenApiV3Deserializer.LoadExample(node);
diagnostic.Errors.Should().BeEmpty();
example.ShouldBeEquivalentTo(
new OpenApiExample
{
Value = new OpenApiObject
{
["versions"] = new OpenApiArray
{
new OpenApiObject
{
["status"] = new OpenApiString("Status1"),
["id"] = new OpenApiString("v1"),
["links"] = new OpenApiArray
{
new OpenApiObject
{
["href"] = new OpenApiString("http://example.com/1"),
["rel"] = new OpenApiString("sampleRel1")
}
}
},
new OpenApiObject
{
["status"] = new OpenApiString("Status2"),
["id"] = new OpenApiString("v2"),
["links"] = new OpenApiArray
{
new OpenApiObject
{
["href"] = new OpenApiString("http://example.com/2"),
["rel"] = new OpenApiString("sampleRel2")
}
}
}
}
}
});
}
}
public void ParseBasicCallbackShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicCallback.yaml")))
{
// Arrange
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var callback = OpenApiV3Deserializer.LoadCallback(node);
// Assert
diagnostic.ShouldBeEquivalentTo(new OpenApiDiagnostic());
callback.ShouldBeEquivalentTo(
new OpenApiCallback
{
PathItems =
{
[RuntimeExpression.Build("$request.body#/url")]
= new OpenApiPathItem
{
Operations =
{
[OperationType.Post] =
new OpenApiOperation
{
RequestBody = new OpenApiRequestBody
{
Content =
{
["application/json"] = null
}
},
Responses = new OpenApiResponses
{
["200"] = new OpenApiResponse
{
Description = "Success"
}
}
}
}
}
}
});
}
}
public void ParseSimpleSchemaShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "simpleSchema.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var schema = OpenApiV3Deserializer.LoadSchema(node);
// Assert
diagnostic.ShouldBeEquivalentTo(new OpenApiDiagnostic());
schema.ShouldBeEquivalentTo(
new OpenApiSchema
{
Type = "object",
Required =
{
"name"
},
Properties =
{
["name"] = new OpenApiSchema
{
Type = "string"
},
["address"] = new OpenApiSchema
{
Type = "string"
},
["age"] = new OpenApiSchema
{
Type = "integer",
Format = "int32",
Minimum = 0
}
},
AdditionalPropertiesAllowed = false
});
}
}
public void ParseBasicSchemaWithExampleShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicSchemaWithExample.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var schema = OpenApiV3Deserializer.LoadSchema(node);
// Assert
diagnostic.ShouldBeEquivalentTo(new OpenApiDiagnostic());
schema.ShouldBeEquivalentTo(
new OpenApiSchema
{
Type = "object",
Properties =
{
["id"] = new OpenApiSchema
{
Type = "integer",
Format = "int64"
},
["name"] = new OpenApiSchema
{
Type = "string"
}
},
Required =
{
"name"
},
Example = new OpenApiObject
{
["name"] = new OpenApiString("Puma"),
["id"] = new OpenApiInteger(1)
}
});
}
}
public void ParseQueryParameterWithObjectTypeAndContentShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "queryParameterWithObjectTypeAndContent.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV3Deserializer.LoadParameter(node);
// Assert
parameter.ShouldBeEquivalentTo(
new OpenApiParameter
{
In = ParameterLocation.Query,
Name = "coordinates",
Content =
{
["application/json"] = new OpenApiMediaType
{
Schema = new OpenApiSchema
{
Type = "object",
Required =
{
"lat",
"long"
},
Properties =
{
["lat"] = new OpenApiSchema
{
Type = "number"
},
["long"] = new OpenApiSchema
{
Type = "number"
}
}
}
}
}
});
}
public void ParseBasicInfoShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicInfo.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var openApiInfo = OpenApiV3Deserializer.LoadInfo(node);
// Assert
openApiInfo.Should().BeEquivalentTo(
new OpenApiInfo
{
Title = "Basic Info",
Description = "Sample Description",
Version = "1.0.1",
TermsOfService = new Uri("http://swagger.io/terms/"),
Contact = new OpenApiContact
{
Email = "*****@*****.**",
Name = "API Support",
Url = new Uri("http://www.swagger.io/support")
},
License = new OpenApiLicense
{
Name = "Apache 2.0",
Url = new Uri("http://www.apache.org/licenses/LICENSE-2.0.html")
}
});
}
}
/// <summary>
/// Reads the stream input and parses it into an Open API document.
/// </summary>
public OpenApiDocument Read(Stream input, out OpenApiDiagnostic diagnostic)
{
RootNode rootNode;
var context = new ParsingContext();
diagnostic = new OpenApiDiagnostic();
try
{
using (var streamReader = new StreamReader(input))
{
var yamlStream = new YamlStream();
yamlStream.Load(streamReader);
var yamlDocument = yamlStream.Documents.First();
rootNode = new RootNode(context, diagnostic, yamlDocument);
}
}
catch (SyntaxErrorException ex)
{
diagnostic.Errors.Add(new OpenApiError(string.Empty, ex.Message));
return(new OpenApiDocument());
}
var inputVersion = GetVersion(rootNode);
switch (inputVersion)
{
case "2.0":
context.ReferenceService = new OpenApiV2ReferenceService(rootNode);
return(OpenApiV2Deserializer.LoadOpenApi(rootNode));
default:
context.ReferenceService = new OpenApiV3ReferenceService(rootNode);
return(OpenApiV3Deserializer.LoadOpenApi(rootNode));
}
}
public void ParseAdvancedEncodingShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "advancedEncoding.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var encoding = OpenApiV3Deserializer.LoadEncoding(node);
// Assert
encoding.Should().BeEquivalentTo(
new OpenApiEncoding
{
ContentType = "image/png, image/jpeg",
Headers =
{
["X-Rate-Limit-Limit"] =
new OpenApiHeader
{
Description = "The number of allowed requests in the current period",
Schema = new OpenApiSchema
{
Type = "integer"
}
}
}
});
}
}
public void ParseBasicEncodingShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicEncoding.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)yamlNode);
// Act
var encoding = OpenApiV3Deserializer.LoadEncoding(node);
// Assert
encoding.Should().BeEquivalentTo(
new OpenApiEncoding
{
ContentType = "application/xml; charset=utf-8"
});
}
}
public void ParseOAuth2SecuritySchemeShouldSucceed()
{
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "oAuth2SecurityScheme.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var securityScheme = OpenApiV3Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.OAuth2,
Flows = new OpenApiOAuthFlows
{
Implicit = new OpenApiOAuthFlow
{
AuthorizationUrl = new Uri("https://example.com/api/oauth/dialog"),
Scopes =
{
["write:pets"] = "modify pets in your account",
["read:pets"] = "read your pets"
}
}
}
});
}
}
/// <summary>
/// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="OpenApiReference"/> object
/// </summary>
public bool TryLoadReference(OpenApiReference reference, out IOpenApiReferenceable referencedObject)
{
referencedObject = null;
if (reference == null)
{
return(false);
}
if (reference.IsExternal)
{
// TODO: need to read the external document and load the referenced object.
throw new NotImplementedException(SRResource.LoadReferencedObjectFromExternalNotImplmented);
}
if (!reference.Type.HasValue)
{
throw new ArgumentException("Local reference must have type specified.");
}
// Special case for Tag
if (reference.Type == ReferenceType.Tag)
{
foreach (var tag in _tags)
{
if (tag.Name == reference.Id)
{
referencedObject = tag;
return(true);
}
}
referencedObject = new OpenApiTag {
Name = reference.Id
};
return(false);
}
var componentJsonPointer =
new JsonPointer("#/components/" + reference.Type.GetDisplayName() + "/" + reference.Id);
var node = _rootNode.Find(componentJsonPointer);
switch (reference.Type)
{
case ReferenceType.Schema:
referencedObject = OpenApiV3Deserializer.LoadSchema(node);
break;
case ReferenceType.Response:
referencedObject = OpenApiV3Deserializer.LoadResponse(node);
break;
case ReferenceType.Parameter:
referencedObject = OpenApiV3Deserializer.LoadParameter(node);
break;
case ReferenceType.Example:
referencedObject = OpenApiV3Deserializer.LoadExample(node);
break;
case ReferenceType.RequestBody:
referencedObject = OpenApiV3Deserializer.LoadRequestBody(node);
break;
case ReferenceType.Header:
referencedObject = OpenApiV3Deserializer.LoadHeader(node);
break;
case ReferenceType.SecurityScheme:
referencedObject = OpenApiV3Deserializer.LoadSecurityScheme(node);
break;
case ReferenceType.Link:
referencedObject = OpenApiV3Deserializer.LoadLink(node);
break;
case ReferenceType.Callback:
referencedObject = OpenApiV3Deserializer.LoadCallback(node);
break;
default:
throw new OpenApiException(
string.Format(
SRResource.ReferenceV3HasInvalidValue,
reference.Type,
componentJsonPointer));
}
return(true);
}
