private static (OpenApiDocument, OpenApiDiagnostic) ReadSpecification(Stream stream)
{
var reader = new OpenApiStreamReader();
var apiDocument = reader.Read(stream, out OpenApiDiagnostic diags);
return(apiDocument, diags);
}
private async Task PublishServiceApiAsync(HttpContext context, string serviceId)
{
var reader = new OpenApiStreamReader();
var document = reader.Read(context.Request.Body, out var diagnostic);
if (diagnostic.Errors.Count > 0)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
context.Response.ContentType = "text/plain";
await context.Response.WriteAsync("Error reading OpenApi document. " + string.Join(Environment.NewLine, diagnostic.Errors.Select(e => e.Message)));
}
if (ValidateModel(document))
{
await _serviceRepository.StoreApiAsync(new Models.ServiceApiDescription {
ApiDocument = document, ServiceId = serviceId
});
context.Response.StatusCode = (int)HttpStatusCode.OK;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
context.Response.ContentType = "text/plain";
await context.Response.WriteAsync("Invalid OpenApi document.");
}
}
private static OpenApiDocument GetOpenApiDocument(string url)
{
HttpClient httpClient = CreateHttpClient();
var response = httpClient.GetAsync(url)
.GetAwaiter().GetResult();
if (!response.IsSuccessStatusCode)
{
throw new Exception("Failed to retrieve OpenApi document");
}
var stream = response.Content.ReadAsStreamAsync().GetAwaiter().GetResult();;
var newrules = ValidationRuleSet.GetDefaultRuleSet().Rules
.Where(r => r.GetType() != typeof(ValidationRule <OpenApiSchema>)).ToList();
var reader = new OpenApiStreamReader(new OpenApiReaderSettings()
{
RuleSet = new ValidationRuleSet(newrules)
});
var openApiDoc = reader.Read(stream, out var diagnostic);
if (diagnostic.Errors.Count > 0)
{
throw new Exception("OpenApi document has errors : " + String.Join("\n", diagnostic.Errors));
}
return(openApiDoc);
}
public async Task JwtAuthenticationOption_GetSwaggerDocs_ContainsJwtSecurityScheme()
{
// Arrange
string key = $"secret-{Guid.NewGuid()}";
string issuer = $"issuer-{Guid.NewGuid()}";
string audience = $"audience-{Guid.NewGuid()}";
string jwtToken = CreateToken(key, issuer, audience);
var jwtHeader = AuthenticationHeaderValue.Parse("Bearer " + jwtToken);
var options = new WebApiProjectOptions().WithJwtAuthentication(key, issuer, audience);
using (var project = await WebApiProject.StartNewAsync(options, _outputWriter))
{
// Act
using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync())
{
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var reader = new OpenApiStreamReader();
using (Stream json = await response.Content.ReadAsStreamAsync())
{
OpenApiDocument document = reader.Read(json, out OpenApiDiagnostic diagnostic);
Assert.NotNull(document.Components);
(string schemeName, OpenApiSecurityScheme componentScheme) = Assert.Single(document.Components.SecuritySchemes);
Assert.Equal(SecuritySchemeType.Http, componentScheme.Type);
OpenApiSecurityRequirement requirement = Assert.Single(document.SecurityRequirements);
Assert.NotNull(requirement);
(OpenApiSecurityScheme requirementScheme, IList <string> scopes) = Assert.Single(requirement);
Assert.Equal("jwt", requirementScheme.Reference.Id);
}
}
}
}
public async Task OAuthAuthorizeOperationFilter_ShouldNotIncludeSecurityDefinitionResponses_OnNonAuthorizedOperations()
{
// Arrange
using (var client = _testServer.CreateClient())
// Act
using (HttpResponseMessage response = await client.GetAsync("swagger/v1/swagger.json"))
{
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var reader = new OpenApiStreamReader();
using (var responseStream = await response.Content.ReadAsStreamAsync())
{
OpenApiDocument swagger = reader.Read(responseStream, out OpenApiDiagnostic diagnostic);
_outputWriter.WriteLine(diagnostic.Errors.Count == 0 ? String.Empty : String.Join(", ", diagnostic.Errors.Select(e => e.Message + ": " + e.Pointer)));
Assert.True(
swagger.Paths.TryGetValue("/oauth/none", out OpenApiPathItem oauthPath),
"Cannot find OAuth none authorized path in Open API spec file");
Assert.True(
oauthPath.Operations.TryGetValue(OperationType.Get, out OpenApiOperation oauthOperation),
"Cannot find OAuth GET operation in Open API spec file");
OpenApiResponses oauthResponses = oauthOperation.Responses;
Assert.DoesNotContain(oauthResponses, r => r.Key == "401");
Assert.DoesNotContain(oauthResponses, r => r.Key == "403");
}
}
}
public async Task SharedAccessKeyAuthenticationOption_GetsSwaggerDocs_ContainsSharedAccessKeySecurityScheme()
{
// Arrange
const string headerName = "x-shared-access-key";
const string secretKey = "MySecretKey";
string secretValue = Guid.NewGuid().ToString("N");
var authenticatedArguments =
new WebApiProjectOptions()
.WithSharedAccessAuthentication(headerName, secretKey, secretValue);
using (var project = await WebApiProject.StartNewAsync(_configuration, authenticatedArguments, _outputWriter))
// Act
using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync())
{
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var reader = new OpenApiStreamReader();
using (Stream json = await response.Content.ReadAsStreamAsync())
{
OpenApiDocument document = reader.Read(json, out OpenApiDiagnostic diagnostic);
Assert.NotNull(document.Components);
(string schemeName, OpenApiSecurityScheme componentScheme) = Assert.Single(document.Components.SecuritySchemes);
Assert.Equal("shared-access-key", schemeName);
Assert.Equal(ParameterLocation.Header, componentScheme.In);
Assert.Equal(headerName, componentScheme.Name);
OpenApiSecurityRequirement requirement = Assert.Single(document.SecurityRequirements);
Assert.NotNull(requirement);
(OpenApiSecurityScheme requirementScheme, IList <string> scopes) = Assert.Single(requirement);
Assert.Equal(headerName, requirementScheme.Name);
}
}
}
public GraphTests(ITestOutputHelper output)
{
_output = output;
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
_httpClient = new HttpClient(new HttpClientHandler()
{ AutomaticDecompression = DecompressionMethods.GZip
});
_httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new System.Net.Http.Headers.StringWithQualityHeaderValue("gzip"));
_httpClient.DefaultRequestHeaders.UserAgent.Add(new System.Net.Http.Headers.ProductInfoHeaderValue("OpenApi.Net.Tests", "1.0"));
var response = _httpClient.GetAsync(graphOpenApiUrl)
.GetAwaiter().GetResult();
if (!response.IsSuccessStatusCode)
{
_output.WriteLine($"Couldn't load graph openapi");
return;
}
var stream = response.Content.ReadAsStreamAsync().GetAwaiter().GetResult(); ;
var reader = new OpenApiStreamReader();
_graphOpenApi = reader.Read(stream, out var diagnostic);
if (diagnostic.Errors.Count > 0)
{
_output.WriteLine($"Errors parsing");
_output.WriteLine(String.Join("\n", diagnostic.Errors));
// Assert.True(false); // Uncomment to identify descriptions with errors.
}
}
public async Task EnsureThatICouldParse(string url)
{
var response = await _httpClient.GetAsync(url);
if (!response.IsSuccessStatusCode)
{
_output.WriteLine($"Couldn't load {url}");
return;
}
await response.Content.LoadIntoBufferAsync();
var stream = await response.Content.ReadAsStreamAsync();
var stopwatch = new Stopwatch();
stopwatch.Start();
var reader = new OpenApiStreamReader();
var openApiDocument = reader.Read(stream, out var diagnostic);
if (diagnostic.Errors.Count > 0)
{
_output.WriteLine($"Errors parsing {url}");
_output.WriteLine(String.Join("\n", diagnostic.Errors));
// Assert.True(false); // Uncomment to identify descriptions with errors.
}
Assert.NotNull(openApiDocument);
stopwatch.Stop();
_output.WriteLine($"Parsing {url} took {stopwatch.ElapsedMilliseconds} ms.");
}
private async Task <OpenApiDocument> ReadDocumentAsync()
{
var reader = new OpenApiStreamReader();
await using var stream = File.OpenRead(_options.InputFile);
return(reader.Read(stream, out _));
}
private static OpenApiDocument FromStream(Stream stream)
{
using (stream)
{
var sr = new OpenApiStreamReader(_settings);
return(sr.Read(stream, out var diagnostic));
}
}
private static OpenApiDocument GetDocument(string path)
{
var reader = new OpenApiStreamReader();
using (var streamReader = new StreamReader(path))
{
return(reader.Read(streamReader.BaseStream, out _));
}
}
public static OpenApiDocument Read(this OpenApiStreamReader reader, Stream input)
{
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
return(reader.Read(input, out OpenApiDiagnostic _));
}
public static OpenApiDocument ReadDocument(string filePath)
{
using (var fs = File.OpenRead(filePath))
{
var sr = new OpenApiStreamReader(_readerSettings);
OpenApiDocument document = sr.Read(fs, out var diagnostic);
SetSchemaTitles(document);
return(document);
}
}
public void StreamShouldNotCloseIfLeaveStreamOpenSettingEqualsTrue()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "petStore.yaml")))
{
var reader = new OpenApiStreamReader(new OpenApiReaderSettings {
LeaveStreamOpen = true
});
reader.Read(stream, out _);
Assert.True(stream.CanRead);
}
}
public async Task OpenApi_document_is_valid()
{
using var response = await this.Client.GetAsync($"/openapi.json");
var reader = new OpenApiStreamReader();
using var stream = await response.Content.ReadAsStreamAsync();
reader.Read(stream, out var diagnostic);
diagnostic.Errors.Should().BeEmpty();
}
public ValidationResult Validate(string schema)
{
var reader = new OpenApiStreamReader();
var ms = new MemoryStream(Encoding.Default.GetBytes(schema));
reader.Read(ms, out var diagnostic);
if (diagnostic.Errors.Count == 0)
{
return(ValidationResult.Success);
}
return(new ValidationResult(string.Join(Environment.NewLine, diagnostic.Errors.Select(x => x.Message))));
}
private static OpenApiDocument Clone(OpenApiDocument subsetOpenApiDocument)
{
var stream = new MemoryStream();
var writer = new OpenApiYamlWriter(new StreamWriter(stream));
subsetOpenApiDocument.SerializeAsV3(writer);
writer.Flush();
stream.Position = 0;
var reader = new OpenApiStreamReader();
return(reader.Read(stream, out OpenApiDiagnostic diag));
}
private async Task <OpenApiDocument> ReadSwaggerOpenAPiDocumentAsync(HttpResponseMessage response)
{
var reader = new OpenApiStreamReader();
using (var responseStream = await response.Content.ReadAsStreamAsync())
{
OpenApiDocument swagger = reader.Read(responseStream, out OpenApiDiagnostic diagnostic);
_logger.LogTrace(diagnostic.Errors.Count == 0
? String.Empty
: String.Join(", ", diagnostic.Errors.Select(e => e.Message + ": " + e.Pointer)));
return(swagger);
}
}
public async Task OpenApi_endpoint_works(string extension)
{
using (var response = await client.GetAsync($"/openapi{extension}"))
{
var reader = new OpenApiStreamReader();
using (var stream = await response.Content.ReadAsStreamAsync())
{
reader.Read(stream, out var diagnostic);
Assert.IsFalse(diagnostic.Errors.Any(), string.Join(",", diagnostic.Errors));
}
}
}
public static OpenApiDocument ReadDocument(Stream docStream, out OpenApiDiagnostic diagnostic)
{
var reader = new OpenApiStreamReader(
new OpenApiReaderSettings
{
ReferenceResolution = ReferenceResolutionSetting.ResolveLocalReferences,
ExtensionParsers =
{
["x-ms-enum"] = EnumOpenApiExtension.Parse,
},
});
return(reader.Read(docStream, out diagnostic));
}
public async Task OpenApi_document_is_valid()
{
using (var response = await client.GetAsync($"/openapi.json"))
{
var reader = new OpenApiStreamReader();
using (var stream = await response.Content.ReadAsStreamAsync())
{
reader.Read(stream, out var diagnostic);
Assert.IsFalse(diagnostic.Errors.Any(), string.Join(",", diagnostic.Errors));
}
}
}
public static OpenApiDocument GenerateApiDocument(
string spec)
{
var memoryStream = new MemoryStream();
using var writer = new StreamWriter(memoryStream);
writer.Write(spec);
writer.Flush();
memoryStream.Position = 0;
var openApiStreamReader = new OpenApiStreamReader();
return(openApiStreamReader.Read(memoryStream, out _));
}
public void ShouldAllowComponentsThatJustContainAReference()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "ComponentRootReference.json")))
{
OpenApiStreamReader reader = new OpenApiStreamReader();
OpenApiDocument doc = reader.Read(stream, out OpenApiDiagnostic diags);
OpenApiSchema schema1 = doc.Components.Schemas["AllPets"];
Assert.False(schema1.UnresolvedReference);
OpenApiSchema schema2 = (OpenApiSchema)doc.ResolveReference(schema1.Reference);
if (schema2.UnresolvedReference && schema1.Reference.Id == schema2.Reference.Id)
{
// detected a cycle - this code gets triggered
Assert.True(false, "A cycle should not be detected");
}
}
}
protected (OpenApiDocument, OpenApiSpecVersion) ReadDoc()
{
var reader = new OpenApiStreamReader(new OpenApiReaderSettings().AddTypedRest());
using var stream = InputPath == "-"
? Console.OpenStandardInput()
: File.OpenRead(InputPath);
var doc = reader.Read(stream, out var diagnostic);
foreach (var error in diagnostic.Errors)
{
Console.Error.WriteLine("Warning: " + error.Message);
}
return(doc, diagnostic.SpecificationVersion);
}
public IEnumerable <MappingModel> FromFile(string path, WireMockOpenApiParserSettings settings, out OpenApiDiagnostic diagnostic)
{
OpenApiDocument document;
if (Path.GetExtension(path).EndsWith("raml", StringComparison.OrdinalIgnoreCase))
{
diagnostic = new OpenApiDiagnostic();
document = new RamlConverter().ConvertToOpenApiDocument(path);
}
else
{
var reader = new OpenApiStreamReader();
document = reader.Read(File.OpenRead(path), out diagnostic);
}
return(FromDocument(document, settings));
}
private void ReadJson(string[] args)
{
string inputPath = args[0];
if (!Path.IsPathRooted(inputPath))
{
Console.WriteLine("The file path you entered does not have a root");
return;
}
OpenApiStreamReader reader = new OpenApiStreamReader();
var diagnostic = new OpenApiDiagnostic();
try
{
string path = Path.GetFullPath(inputPath);
Stream stream = File.OpenRead(path);
OpenApiDocument newDocument = reader.Read(stream, out diagnostic);
}
catch (FileNotFoundException e)
{
Console.WriteLine("Check to make sure you entered a correct file path because the file was not found.");
Console.Error.WriteLine(e.Message);
return;
}
catch (Exception e)
{
Console.WriteLine("Check the file path you entered for errors.");
Console.Error.WriteLine(e.Message);
return;
}
if (diagnostic.Errors.Count == 0)
{
Console.WriteLine("Read File Successfully");
}
else
{
foreach (OpenApiError error in diagnostic.Errors)
{
Console.WriteLine($"There was an error reading in the file at {error.Pointer}");
Console.Error.WriteLine(error.Message);
}
}
}
public static void Main()
{
SetWorkingDirectoryToProjectRoot();
Handlebars.Configuration.TextEncoder = new PassthroughEncoder();
OpenApiDocument document;
Console.WriteLine("Loading OpenApi YAML");
using (var stream = File.OpenRead("openapi.yml"))
{
var reader = new OpenApiStreamReader();
document = reader.Read(stream, out _);
}
var templatesPath = Path.Combine("src", "Scryfall.OpenApi.Codegen");
var outputPath = Path.Combine("src", "Scryfall.Api");
new CodeRenderer(document, templatesPath, outputPath).Render();
}
internal static async Task <OpenApiUrlTreeNode> GetTreeNode(string url)
{
Stream stream;
if (url.StartsWith("http", StringComparison.OrdinalIgnoreCase))
{
using var httpClient = new HttpClient();
stream = await httpClient.GetStreamAsync(url);
}
else
{
stream = File.OpenRead(url);
}
var reader = new OpenApiStreamReader();
var doc = reader.Read(stream, out var diags);
await stream.DisposeAsync();
return(OpenApiUrlTreeNode.Create(doc, "default"));
}
public static async Task <OpenApiDocument> HandleOpenApiDocumentResponseAsync(HttpResponseMessage response)
{
// What should the failure modes of this method be?
if (response.IsSuccessStatusCode)
{
var openApiStream = await response.Content.ReadAsStreamAsync();
var reader = new OpenApiStreamReader();
var doc = reader.Read(openApiStream, out var diag);
// how do we handle diag errors
// catch exceptions
return(doc);
}
else
{
throw new Exception("Request failed");
}
}
private static List <OpenApiDocumentContainer> GetAllApiDocuments(DirectoryInfo specificationPath)
{
if (specificationPath == null)
{
throw new ArgumentNullException(nameof(specificationPath));
}
var result = new List <OpenApiDocumentContainer>();
var docFiles = Directory.GetFiles(specificationPath.FullName, "*.yaml", SearchOption.AllDirectories);
if (docFiles.Length == 0)
{
docFiles = Directory.GetFiles(specificationPath.FullName, "*.json", SearchOption.AllDirectories);
}
foreach (var docFile in docFiles)
{
var text = File.ReadAllText(docFile);
try
{
var openApiStreamReader = new OpenApiStreamReader();
var document = openApiStreamReader.Read(File.OpenRead(docFile), out var diagnostic);
result.Add(
new OpenApiDocumentContainer(
new FileInfo(docFile),
text,
document,
diagnostic));
}
catch (Exception ex)
{
result.Add(
new OpenApiDocumentContainer(
new FileInfo(docFile),
text,
ex));
}
}
return(result);
}
