public RootNode(
ParsingContext context,
OpenApiDiagnostic diagnostic,
YamlDocument yamlDocument) : base(context, diagnostic)
{
_yamlDocument = yamlDocument;
}
public void LoadResponseReference()
{
// Arrange
OpenApiDocument document;
var diagnostic = new OpenApiDiagnostic();
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "multipleReferences.v2.yaml")))
{
document = new OpenApiStreamReader().Read(stream, out diagnostic);
}
var reference = new OpenApiReference
{
Type = ReferenceType.Response,
Id = "NotFound"
};
// Act
var referencedObject = document.ResolveReference(reference);
// Assert
referencedObject.ShouldBeEquivalentTo(
new OpenApiResponse
{
Description = "Entity not found.",
Reference = new OpenApiReference
{
Type = ReferenceType.Response,
Id = "NotFound"
}
}
);
}
public void ParsePrimitiveStringSchemaFragmentShouldSucceed()
{
var input = @"
{ ""type"": ""integer"",
""format"": ""int64"",
""default"": 88
}
";
var reader = new OpenApiStringReader();
var diagnostic = new OpenApiDiagnostic();
// Act
var schema = reader.ReadFragment <OpenApiSchema>(input, OpenApiSpecVersion.OpenApi3_0, out diagnostic);
// Assert
diagnostic.ShouldBeEquivalentTo(new OpenApiDiagnostic());
schema.ShouldBeEquivalentTo(
new OpenApiSchema
{
Type = "integer",
Format = "int64",
Default = new OpenApiInteger(88)
});
}
public void EndpointsJsonIsValid()
{
OpenApiDocument document = Resources.OpenApiDefinition;
OpenApiDiagnostic diagnostic = Resources.ApiDiagnostic;
Assert.IsFalse(diagnostic.Errors.Any(), string.Join(",", diagnostic.Errors));
}
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 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 LoadSecuritySchemeReference()
{
// Arrange
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "multipleReferences.v2.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlDocument = yamlStream.Documents.First();
context.RootNode = new RootNode(context, diagnostic, yamlDocument);
}
context.VersionService = new OpenApiV2VersionService();
var reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "api_key_sample"
};
// Act
context.VersionService.TryLoadReference(context, reference, out var referencedObject);
// Assert
referencedObject.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.ApiKey,
Name = "api_key",
In = ParameterLocation.Header
}
);
}
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 ParseCustomExtension()
{
var description = @"
openapi: 3.0.0
info:
title: A doc with an extension
version: 1.0.0
x-foo:
bar: hey
baz: hi!
paths: {}
";
var settings = new OpenApiReaderSettings()
{
ExtensionParsers = { { "x-foo", (a, v) => {
var fooNode = (OpenApiObject)a;
return(new FooExtension()
{
Bar = (fooNode["bar"] as OpenApiString)?.Value,
Baz = (fooNode["baz"] as OpenApiString)?.Value
});
} } }
};
var reader = new OpenApiStringReader(settings);
var diag = new OpenApiDiagnostic();
var doc = reader.Read(description, out diag);
var fooExtension = doc.Info.Extensions["x-foo"] as FooExtension;
fooExtension.Should().NotBeNull();
fooExtension.Bar.Should().Be("hey");
fooExtension.Baz.Should().Be("hi!");
}
public void ParseOAuth2ImplicitSecuritySchemeShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "oauth2ImplicitSecurityScheme.yaml")))
{
var document = LoadYamlDocument(stream);
var diagnostic = new OpenApiDiagnostic();
var context = new ParsingContext(diagnostic);
var node = new MapNode(context, (YamlMappingNode)document.RootNode);
// Act
var securityScheme = OpenApiV2Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.Should().BeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.OAuth2,
Flows = new OpenApiOAuthFlows
{
Implicit = new OpenApiOAuthFlow
{
AuthorizationUrl = new Uri("http://swagger.io/api/oauth/dialog"),
Scopes =
{
["write:pets"] = "modify pets in your account",
["read:pets"] = "read your pets"
}
}
}
});
}
}
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 PropertyNode(ParsingContext context, OpenApiDiagnostic diagnostic, string name, YamlNode node) : base(
context,
diagnostic)
{
Name = name;
Value = Create(context, diagnostic, node);
}
public void ParseExampleStringFragmentShouldSucceed()
{
var input = @"
{
""foo"": ""bar"",
""baz"": [ 1,2]
}";
var reader = new OpenApiStringReader();
var diagnostic = new OpenApiDiagnostic();
// Act
var openApiAny = reader.ReadFragment <IOpenApiAny>(input, OpenApiSpecVersion.OpenApi3_0, out diagnostic);
// Assert
diagnostic.ShouldBeEquivalentTo(new OpenApiDiagnostic());
openApiAny.ShouldBeEquivalentTo(
new OpenApiObject
{
["foo"] = new OpenApiString("bar"),
["baz"] = new OpenApiArray()
{
new OpenApiInteger(1),
new OpenApiInteger(2)
}
});
}
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 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 ParseListAsAnyShouldSucceed()
{
var input = @"
- fooBar
- 10
- 2.34
- 2017-01-01
";
var yamlStream = new YamlStream();
yamlStream.Load(new StringReader(input));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new ListNode(context, diagnostic, (YamlSequenceNode)yamlNode);
var any = node.CreateAny();
diagnostic.Errors.Should().BeEmpty();
any.ShouldBeEquivalentTo(
new OpenApiArray
{
new OpenApiString("fooBar"),
new OpenApiInteger(10),
new OpenApiDouble(2.34),
new OpenApiDateTime(DateTimeOffset.Parse("2017-01-01"))
});
}
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 LoadResponseReference()
{
// Arrange
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
RootNode rootNode;
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "multipleReferences.v2.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlDocument = yamlStream.Documents.First();
rootNode = new RootNode(context, diagnostic, yamlDocument);
}
context.ReferenceService = new OpenApiV2ReferenceService(rootNode);
var reference = new OpenApiReference
{
Type = ReferenceType.Response,
Id = "NotFound"
};
// Act
context.ReferenceService.TryLoadReference(reference, out var referencedObject);
// Assert
referencedObject.ShouldBeEquivalentTo(
new OpenApiResponse
{
Description = "Entity not found."
}
);
}
public void ParseMapAsAnyShouldSucceed()
{
var input = @"
aString: fooBar
aInteger: 10
aDouble: 2.34
aDateTime: 2017-01-01
";
var yamlStream = new YamlStream();
yamlStream.Load(new StringReader(input));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
var anyMap = node.CreateAny();
diagnostic.Errors.Should().BeEmpty();
anyMap.ShouldBeEquivalentTo(
new OpenApiObject
{
["aString"] = new OpenApiString("fooBar"),
["aInteger"] = new OpenApiInteger(10),
["aDouble"] = new OpenApiDouble(2.34),
["aDateTime"] = new OpenApiDateTime(DateTimeOffset.Parse("2017-01-01"))
});
}
public OpenApiDocumentContainer(FileInfo docFile, string docText, OpenApiDocument openApiDocument, OpenApiDiagnostic openApiDiagnostic)
{
DocFile = docFile;
DocText = docText;
Document = openApiDocument;
Diagnostic = openApiDiagnostic;
}
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 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 = OpenApiV2Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.ApiKey,
Name = "api_key",
In = ParameterLocation.Header
});
}
}
public void LoadSecuritySchemeReference()
{
// Arrange
OpenApiDocument document;
var diagnostic = new OpenApiDiagnostic();
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "multipleReferences.v2.yaml")))
{
document = new OpenApiStreamReader().Read(stream, out diagnostic);
}
var reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "api_key_sample"
};
// Act
var referencedObject = document.ResolveReference(reference);
// Assert
referencedObject.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.ApiKey,
Name = "api_key",
In = ParameterLocation.Header,
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "api_key_sample"
}
}
);
}
/// <summary>
/// Gets an Open API YAML file stored as an embedded resource, and returns parsing diagnostics.
/// </summary>
/// <param name="assembly">The assembly in which the resource is stored.</param>
/// <param name="resourceName">The name of the embedded resource.</param>
/// <param name="diagnostics">Diagnostics will be returned through this parameter.</param>
/// <returns>The parsed document.</returns>
public static OpenApiDocument ReadOpenApiServiceFromEmbeddedDefinitionWithDiagnostics(
Assembly assembly,
string resourceName,
out OpenApiDiagnostic diagnostics)
{
using Stream stream = assembly.GetManifestResourceStream(resourceName);
return(new OpenApiStreamReader().Read(stream, out diagnostics));
}
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 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")
}
}
}
}
}
});
}
}
/// <summary>
/// Blazor WebAssembly won't be ready for a while, so this method assumes we're using Blazor Server.
/// So a .json file is read.
/// For Blazer WA this should make an http call.
/// </summary>
/// <returns></returns>
public Task <OpenApiDocument> GetDocument()
{
OpenApiDiagnostic apiDiagnostic = null;
// Note: OpenApi.NET doesn't appear to have an async reader or I would have used it.
OpenApiDocument document =
new OpenApiStreamReader().Read(new FileStream(Path, FileMode.Open), out apiDiagnostic);
return(Task.FromResult(document));
}
public ValueNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlNode node) : base(
context,
diagnostic)
{
if (!(node is YamlScalarNode scalarNode))
{
throw new OpenApiReaderException("Expected a value.", node);
}
_node = scalarNode;
}
public ConvertToOpenApiReferenceV2Tests()
{
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var yamlDocument = new YamlDocument("{}");
var rootNode = new RootNode(context, diagnostic, yamlDocument);
_referenceService = new OpenApiV2ReferenceService(rootNode);
}
public void LoadSchemaReference()
{
// Arrange
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
RootNode rootNode;
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "multipleReferences.v2.yaml")))
{
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlDocument = yamlStream.Documents.First();
rootNode = new RootNode(context, diagnostic, yamlDocument);
}
context.ReferenceService = new OpenApiV2ReferenceService(rootNode);
var reference = new OpenApiReference
{
Type = ReferenceType.Schema,
Id = "SampleObject"
};
// Act
context.ReferenceService.TryLoadReference(reference, out var referencedObject);
// Assert
referencedObject.ShouldBeEquivalentTo(
new OpenApiSchema
{
Required =
{
"id",
"name"
},
Properties =
{
["id"] = new OpenApiSchema
{
Type = "integer",
Format = "int64"
},
["name"] = new OpenApiSchema
{
Type = "string"
},
["tag"] = new OpenApiSchema
{
Type = "string"
}
}
}
);
}
