public void ParseHeaderParameterShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "headerParameter.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV2Deserializer.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 ParseOperationWithResponseExamplesShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "operationWithResponseExamples.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var operation = OpenApiV2Deserializer.LoadOperation(node);
// Assert
operation.Should().BeEquivalentTo(
new OpenApiOperation()
{
Responses = new OpenApiResponses()
{
{ "200", new OpenApiResponse()
{
Description = "An array of float response",
Content =
{
["application/json"] = new OpenApiMediaType()
{
Schema = new OpenApiSchema()
{
Type = "array",
Items = new OpenApiSchema()
{
Type = "number",
Format = "float"
}
},
Example = new OpenApiArray()
{
new OpenApiFloat(5),
new OpenApiFloat(6),
new OpenApiFloat(7),
}
},
["application/xml"] = new OpenApiMediaType()
{
Schema = new OpenApiSchema()
{
Type = "array",
Items = new OpenApiSchema()
{
Type = "number",
Format = "float"
}
}
}
}
} }
}
}
);
}
public void ParseHeaderWithEnumShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "headerWithEnum.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var header = OpenApiV2Deserializer.LoadHeader(node);
// Assert
header.ShouldBeEquivalentTo(
new OpenApiHeader
{
Schema = new OpenApiSchema()
{
Type = "number",
Format = "float",
Enum =
{
new OpenApiFloat(7),
new OpenApiFloat(8),
new OpenApiFloat(9)
}
}
});
}
public void ParsePathParameterShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "pathParameter.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV2Deserializer.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 ParseQueryParameterShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "queryParameter.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV2Deserializer.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 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 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 ParseOperationWithBodyShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "operationWithBody.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var operation = OpenApiV2Deserializer.LoadOperation(node);
// Assert
operation.ShouldBeEquivalentTo(_operationWithBody);
}
public void ParseBasicPathItemWithFormDataShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicPathItemWithFormData.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var operation = OpenApiV2Deserializer.LoadPathItem(node);
// Assert
operation.ShouldBeEquivalentTo(_basicPathItemWithFormData);
}
public void ParseResponseWithExamplesShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "responseWithExamples.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
node.Context.SetTempStorage(TempStorageKeys.OperationProduces, new List <string>()
{
"application/json"
});
// Act
var response = OpenApiV2Deserializer.LoadResponse(node);
// Assert
response.ShouldBeEquivalentTo(
new OpenApiResponse()
{
Description = "An array of float response",
Content =
{
["application/json"] = new OpenApiMediaType()
{
Schema = new OpenApiSchema()
{
Type = "array",
Items = new OpenApiSchema()
{
Type = "number",
Format = "float"
}
},
Example = new OpenApiArray()
{
new OpenApiFloat(5),
new OpenApiFloat(6),
new OpenApiFloat(7),
}
}
}
});
}
public void ParseOperationWithBodyTwiceShouldYieldSameObject()
{
// Arrange
MapNode node;
using (var stream = new MemoryStream(
Encoding.Default.GetBytes(_operationWithBody.SerializeAsYaml(OpenApiSpecVersion.OpenApi2_0))))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var operation = OpenApiV2Deserializer.LoadOperation(node);
// Assert
operation.ShouldBeEquivalentTo(_operationWithBody);
}
public void ParseBodyParameterShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "bodyParameter.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV2Deserializer.LoadParameter(node);
// Assert
// Body parameter is currently not translated via LoadParameter.
// This design may be revisited and this unit test may likely change.
parameter.ShouldBeEquivalentTo(null);
}
public void ParseSchemaWithExampleShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "schemaWithExample.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var schema = OpenApiV2Deserializer.LoadSchema(node);
// Assert
schema.Should().BeEquivalentTo(
new OpenApiSchema
{
Type = "number",
Format = "float",
Example = new OpenApiFloat(5)
});
}
/// <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 ParseParameterWithNoSchemaShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "parameterWithNoSchema.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV2Deserializer.LoadParameter(node);
// Assert
parameter.Should().BeEquivalentTo(
new OpenApiParameter
{
In = null,
Name = "username",
Description = "username to fetch",
Required = false
});
}
public void ParseHttpSecuritySchemeShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicSecurityScheme.yaml")))
{
var document = OpenApiStreamReader.LoadYamlDocument(stream);
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)document.RootNode);
// Act
var securityScheme = OpenApiV2Deserializer.LoadSecurityScheme(node);
// Assert
securityScheme.ShouldBeEquivalentTo(
new OpenApiSecurityScheme
{
Type = SecuritySchemeType.Http,
Scheme = "basic"
});
}
}
public void ParseApiKeySecuritySchemeShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "apiKeySecurityScheme.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.ApiKey,
Name = "api_key",
In = ParameterLocation.Header
});
}
}
public void ParseOAuth2AccessCodeSecuritySchemeShouldSucceed()
{
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "oAuth2AccessCodeSecurityScheme.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.OAuth2,
Flows = new OpenApiOAuthFlows
{
AuthorizationCode = new OpenApiOAuthFlow
{
AuthorizationUrl = new Uri("http://swagger.io/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 jsonPointer =
new JsonPointer("#/" + GetReferenceTypeV2Name(reference.Type.Value) + "/" + reference.Id);
var node = _rootNode.Find(jsonPointer);
switch (reference.Type)
{
case ReferenceType.Schema:
referencedObject = OpenApiV2Deserializer.LoadSchema(node);
break;
case ReferenceType.Response:
referencedObject = OpenApiV2Deserializer.LoadResponse(node);
break;
case ReferenceType.Parameter:
referencedObject = OpenApiV2Deserializer.LoadParameter(node);
break;
case ReferenceType.SecurityScheme:
referencedObject = OpenApiV2Deserializer.LoadSecurityScheme(node);
break;
default:
throw new OpenApiException(
string.Format(
SRResource.ReferenceV2HasInvalidValue,
reference.Type,
jsonPointer));
}
return(true);
}
public void ParseHeaderParameterWithIncorrectDataTypeShouldSucceed()
{
// Arrange
MapNode node;
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "headerParameterWithIncorrectDataType.yaml")))
{
node = TestHelper.CreateYamlMapNode(stream);
}
// Act
var parameter = OpenApiV2Deserializer.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 = "string",
Format = "date-time",
Enum = new List <IOpenApiAny>
{
new OpenApiString("1"),
new OpenApiString("2"),
new OpenApiString("3"),
new OpenApiString("4"),
}
},
Default = new OpenApiArray()
{
new OpenApiString("1"),
new OpenApiString("2")
},
Enum = new List <IOpenApiAny>
{
new OpenApiArray()
{
new OpenApiString("1"), new OpenApiString("2")
},
new OpenApiArray()
{
new OpenApiString("2"), new OpenApiString("3")
},
new OpenApiArray()
{
new OpenApiString("3"), new OpenApiString("4")
}
}
}
});
}
