public void TestInputMapping()
{
var input = Path.Combine(Core.Utilities.Extensions.CodeBaseDirectory(typeof(MappingExtensionsTests)), "Resource", "swagger-payload-flatten.json");
var modeler = new SwaggerModeler(new Settings {
PayloadFlatteningThreshold = 3
});
var clientModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
var plugin = new PluginCs();
using (plugin.Activate())
{
clientModel = plugin.Serializer.Load(clientModel);
clientModel = plugin.Transformer.TransformCodeModel(clientModel);
CodeGeneratorCs generator = new CodeGeneratorCs();
generator.Generate(clientModel).GetAwaiter().GetResult();
string body = Settings.Instance.FileSystemOutput.ReadAllText(Path.Combine("Payload.cs"));
Assert.True(body.ContainsMultiline(@"
MinProduct minProduct = new MinProduct();
if (baseProductId != null || baseProductDescription != null || maxProductReference != null)
{
minProduct.BaseProductId = baseProductId;
minProduct.BaseProductDescription = baseProductDescription;
minProduct.MaxProductReference = maxProductReference;
}"));
}
}
public void TestcodeModelWithResponseHeaders()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-response-headers.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
var methods = codeModel.Methods.ToList();
Assert.Equal(2, methods.Count);
Assert.Equal(2, methods[0].Responses.Count);
Assert.Equal("ListHeaders", methods[0].Responses[HttpStatusCode.OK].Headers.Name);
Assert.Equal(3, ((CompositeType)methods[0].Responses[HttpStatusCode.OK].Headers).Properties.Count);
Assert.Equal("ListHeaders", methods[0].Responses[HttpStatusCode.Created].Headers.Name);
Assert.Equal(3, ((CompositeType)methods[0].Responses[HttpStatusCode.Created].Headers).Properties.Count);
Assert.Equal("ListHeaders", methods[0].ReturnType.Headers.Name);
Assert.Equal(3, ((CompositeType)methods[0].ReturnType.Headers).Properties.Count);
Assert.Equal(1, methods[1].Responses.Count);
Assert.Equal("CreateHeaders", methods[1].Responses[HttpStatusCode.OK].Headers.Name);
Assert.Equal(3, ((CompositeType)methods[1].Responses[HttpStatusCode.OK].Headers).Properties.Count);
Assert.Equal("CreateHeaders", methods[1].ReturnType.Headers.Name);
Assert.Equal(3, ((CompositeType)methods[1].ReturnType.Headers).Properties.Count);
Assert.True(codeModel.HeaderTypes.Any(c => c.Name == "ListHeaders"));
Assert.True(codeModel.HeaderTypes.Any(c => c.Name == "CreateHeaders"));
}
public void TestcodeModelFromSimpleSwagger()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-simple-spec.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
var description =
"The Products endpoint returns information about the Uber products offered at a given location. The response includes the display name and other details about each product, and lists the products in the proper display order.";
var summary = "Product Types";
Assert.NotNull(codeModel);
Assert.Equal(2, codeModel.Properties.Count);
Assert.True(
codeModel.Properties.Any(p => p.Name.EqualsIgnoreCase("subscriptionId")));
Assert.True(
codeModel.Properties.Any(p => p.Name.EqualsIgnoreCase("apiVersion")));
Assert.Equal("2014-04-01-preview", codeModel.ApiVersion);
Assert.Equal("https://management.azure.com", codeModel.BaseUrl);
Assert.Equal("Some cool documentation.", codeModel.Documentation);
//var allMethods = codeModel.Operations.SelectMany(each => each.Methods);
var methods = codeModel.Methods.ToList();
Assert.Equal(2, methods.Count);
Assert.Equal("List", methods[0].Name);
Assert.NotEmpty(methods[0].Description);
Assert.Equal(description, methods[0].Description);
Assert.NotEmpty(methods[0].Summary);
Assert.Equal(summary, methods[0].Summary);
Assert.Equal(HttpMethod.Get, methods[0].HttpMethod);
Assert.Equal(3, methods[0].Parameters.Count);
Assert.Equal("subscriptionId", methods[0].Parameters[0].Name);
Assert.NotNull(methods[0].Parameters[0].ClientProperty);
Assert.Equal("resourceGroupName", methods[0].Parameters[1].Name);
Assert.Equal("resourceGroupName", methods[0].Parameters[1].SerializedName);
Assert.Equal("Resource Group ID.", methods[0].Parameters[1].Documentation);
Assert.Equal(true, methods[0].Parameters[0].IsRequired);
Assert.Equal(ParameterLocation.Path, methods[0].Parameters[0].Location);
Assert.Equal("String", methods[0].Parameters[0].ModelType.Name);
Assert.Equal("Reset", methods[1].Name);
Assert.Equal("Product", codeModel.ModelTypes.First(m => m.Name == "Product").Name);
Assert.Equal("Product", codeModel.ModelTypes.First(m => m.Name == "Product").SerializedName);
Assert.Equal("The product title.", codeModel.ModelTypes.First(m => m.Name == "Product").Summary);
Assert.Equal("The product documentation.",
codeModel.ModelTypes.First(m => m.Name == "Product").Documentation);
Assert.Equal("A product id.",
codeModel.ModelTypes.First(m => m.Name == "Product").Properties[0].Summary);
Assert.Equal("ProductId", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[0].Name);
Assert.Equal("product_id",
codeModel.ModelTypes.First(m => m.Name == "Product").Properties[0].SerializedName);
Assert.Null(methods[1].ReturnType.Body);
Assert.Null(methods[1].Responses[HttpStatusCode.NoContent].Body);
Assert.Equal(3, methods[1].Parameters.Count);
Assert.Equal("subscriptionId", methods[1].Parameters[0].Name);
Assert.Null(methods[1].Parameters[0].ClientProperty);
Assert.Equal("resourceGroupName", methods[1].Parameters[1].Name);
Assert.Equal("apiVersion", methods[1].Parameters[2].Name);
Assert.Equal("Capacity", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[3].Name);
Assert.Equal("100", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[3].DefaultValue);
}
public void TestcodeModelWithStreamAndByteArray()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-streaming.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
var methods = codeModel.Methods.ToList();
Assert.Equal("GetWithStreamFormData", methods[0].Name);
Assert.Equal("Stream", methods[0].Parameters[0].ModelType.Name);
Assert.Equal("Stream", CreateCSharpResponseType(methods[0].ReturnType));
Assert.Equal("Stream", CreateCSharpResponseType(methods[0].Responses[HttpStatusCode.OK]));
Assert.Equal("PostWithByteArrayFormData", methods[1].Name);
Assert.Equal("ByteArray", methods[1].Parameters[0].ModelType.Name);
Assert.Equal("ByteArray", CreateCSharpResponseType(methods[1].ReturnType));
Assert.Equal("ByteArray", CreateCSharpResponseType(methods[1].Responses[HttpStatusCode.OK]));
Assert.Equal("GetWithStream", methods[2].Name);
Assert.Equal("Stream", CreateCSharpResponseType(methods[2].ReturnType));
Assert.Equal("Stream", CreateCSharpResponseType(methods[2].Responses[HttpStatusCode.OK]));
Assert.Equal("PostWithByteArray", methods[3].Name);
Assert.Equal("ByteArray", CreateCSharpResponseType(methods[3].ReturnType));
Assert.Equal("ByteArray", CreateCSharpResponseType(methods[3].Responses[HttpStatusCode.OK]));
}
private IEnumerable <ValidationMessage> ValidateOpenAPISpec(string input, ServiceDefinitionMetadata metadata)
{
var validator = new RecursiveObjectValidator(PropertyNameResolver.JsonName);
var serviceDefinition = SwaggerParser.Parse(input, File.ReadAllText(input));
return(validator.GetValidationExceptions(new Uri(input, UriKind.RelativeOrAbsolute), serviceDefinition, metadata).OfType <ValidationMessage>());
}
public void TestYamlParsing()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-simple-spec.yaml");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
}
public void ParseSecurityDefinitionType()
{
var swaggerContent = File.ReadAllText(@"Resource\SerializationTests\SerializationTests.json");
var definition = SwaggerParser.Parse(swaggerContent);
Assert.Equal(SecuritySchemeType.OAuth2, definition.SecurityDefinitions["petstore_auth"].SecuritySchemeType);
Assert.Equal(SecuritySchemeType.ApiKey, definition.SecurityDefinitions["api_key"].SecuritySchemeType);
}
public void TestCompositeConstants()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-composite-constants.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.Equal(false, codeModel.ModelTypes.First(m => m.Name == "NetworkInterfaceIPConfigurationPropertiesFormat").ContainsConstantProperties);
Assert.Equal(false, codeModel.ModelTypes.First(m => m.Name == "IPConfigurationPropertiesFormat").ContainsConstantProperties);
}
public void GlobalResponsesReference()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-global-responses.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.Equal(1, codeModel.Methods[0].Responses.Count);
Assert.NotNull(codeModel.Methods[0].Responses[HttpStatusCode.OK]);
}
public void TestCustomPaths()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-x-ms-paths.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal(3, codeModel.Methods.Count());
Assert.True(codeModel.Methods.All(m => m.Url == "/values/foo"));
}
public void DefaultReturnsCorrectType()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-multiple-response-schemas.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
var retType = codeModel.Methods.First(m => m.Name == "PatchDefaultResponse");
Assert.Equal("Pet", CreateCSharpResponseType(retType.ReturnType));
}
public void TestcodeModelWithMethodGroups()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-optional-params.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal(0, codeModel.Methods.Count(m => m.Group == null));
Assert.Equal(2, codeModel.Methods.Count(m => m.Group == "Widgets"));
Assert.Equal("List", codeModel.Methods[0].Name);
}
public void GenerateCodeModel()
{
var input = Path.Combine(CodeBaseDirectory, "..", "..", "..", "Resource", "Swagger", "deprecated.yaml");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
var output = Path.Combine(CodeBaseDirectory, "..", "..", "..", "Expected", "deprecated", "deprecated.json");
Directory.CreateDirectory(Path.GetDirectoryName(output));
File.WriteAllText(output, JsonConvert.SerializeObject(codeModel, Formatting.Indented));
}
public void AllowVendorExtensionInPath()
{
var input = Path.Combine("Resource", "Swagger", "vendor-extension-in-path.json");
var modeler = new SwaggerModeler();
var clientModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
// should return a valid model.
Assert.NotNull(clientModel);
// there should be one method in this generated api.
Assert.Equal(1, modeler.CodeModel.Methods.Count);
}
public void TestRealPathRegular()
{
var input = Path.Combine("Resource", "Swagger", "swagger-xml.yaml");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
foreach (var property in codeModel.ModelTypes.SelectMany(m => m.Properties))
{
Assert.Equal(property.Name, string.Join(".", property.RealPath));
Assert.Equal(property.XmlName, string.Join(".", property.RealXmlPath));
}
}
public void TestcodeModelWithRecursiveTypes()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-recursive-type.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal("Product", codeModel.ModelTypes.First(m => m.Name == "Product").Name);
Assert.Equal("ProductId", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[0].Name);
Assert.Equal("String",
codeModel.ModelTypes.First(m => m.Name == "Product").Properties[0].ModelType.Name);
}
private IEnumerable <ValidationMessage> ValidateSwagger(string input, ServiceDefinitionMetadata metadata)
{
// Most rules are to be applied for ARM documents
// Also, most rules need to be run over the composite document (i.e. AFTER merge state)
// hence the defaults
using (NewContext)
{
var validator = new RecursiveObjectValidator(PropertyNameResolver.JsonName);
var serviceDefinition = SwaggerParser.Parse(input, File.ReadAllText(input));
return(validator.GetValidationExceptions(new Uri(input, UriKind.RelativeOrAbsolute), serviceDefinition, metadata).OfType <ValidationMessage>());
}
}
public void TestcodeModelWithNoContent()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-no-content.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.Equal("DeleteBlob", codeModel.Methods[4].Name);
Assert.True(codeModel.Methods[4].ReturnType.Body.IsPrimaryType(KnownPrimaryType.Object));
Assert.True(
codeModel.Methods[4].Responses[HttpStatusCode.OK].Body.IsPrimaryType(KnownPrimaryType.Object));
Assert.Null(codeModel.Methods[4].Responses[HttpStatusCode.BadRequest].Body);
}
public void TestConstants()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-validation.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
var methods = codeModel.Methods.ToList();
Assert.Equal("myintconst", methods[0].Parameters[4].Name);
Assert.Equal(true, methods[0].Parameters[4].ModelType.IsPrimaryType(KnownPrimaryType.Int));
Assert.Equal(true, methods[0].Parameters[4].IsConstant);
Assert.Equal("0", methods[0].Parameters[4].DefaultValue);
Assert.Equal("mystrconst", methods[0].Parameters[5].Name);
Assert.Equal(true, methods[0].Parameters[5].ModelType.IsPrimaryType(KnownPrimaryType.String));
Assert.Equal(true, methods[0].Parameters[5].IsConstant);
Assert.Equal("constant", methods[0].Parameters[5].DefaultValue);
Assert.Equal("Myintconst", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[5].Name);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[5].ModelType.IsPrimaryType(KnownPrimaryType.Int));
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[5].IsConstant);
Assert.Equal("0", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[5].DefaultValue);
Assert.Equal("Mystrconst", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[6].Name);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[6].ModelType.IsPrimaryType(KnownPrimaryType.String));
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[6].IsConstant);
Assert.Equal("constant", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[6].DefaultValue);
Assert.Equal("RefStrEnumRequiredConstant", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[7].Name);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[7].ModelType.IsPrimaryType(KnownPrimaryType.String));
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[7].IsConstant);
Assert.Equal("ReferenceEnum1", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[7].DefaultValue);
Assert.Equal("RefIntEnumRequiredConstant", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[8].Name);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[8].ModelType.IsPrimaryType(KnownPrimaryType.Int));
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[8].IsConstant);
Assert.Equal("0", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[8].DefaultValue);
Assert.Equal("RefStrEnum", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].Name);
Assert.Equal("enum", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].ModelType.Name);
Assert.Equal(false, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].IsConstant);
Assert.True(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].DefaultValue.IsNullOrEmpty());
Assert.Equal("RefIntEnum", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].Name);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].ModelType.IsPrimaryType(KnownPrimaryType.Int));
Assert.Equal(false, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].IsConstant);
Assert.True(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].DefaultValue.IsNullOrEmpty());
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").ContainsConstantProperties);
Assert.Equal(false, codeModel.ModelTypes.First(m => m.Name == "Error").ContainsConstantProperties);
}
public void TestNameOverrideRules()
{
var input = Path.Combine("Resource", "Swagger", "swagger-xml.yaml");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
foreach (var modelType in codeModel.ModelTypes)
{
Assert.Equal(modelType.Documentation, modelType.XmlName);
foreach (var property in codeModel.Properties)
{
Assert.Equal(property.Documentation, property.XmlName);
}
}
}
public void TestcodeModelWithInheritance()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-allOf.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal("Pet", codeModel.ModelTypes.First(m => m.Name == "Pet").Name);
Assert.Equal("Cat", codeModel.ModelTypes.First(m => m.Name == "Cat").Name);
Assert.Equal("Pet", codeModel.ModelTypes.First(m => m.Name == "Cat").BaseModelType.Name);
Assert.Equal("Breed", codeModel.ModelTypes.First(m => m.Name == "Cat").Properties[0].Name);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Cat").Properties[0].IsRequired);
Assert.Equal("Color", codeModel.ModelTypes.First(m => m.Name == "Cat").Properties[1].Name);
Assert.Equal("Siamese", codeModel.ModelTypes.First(m => m.Name == "Siamese").Name);
Assert.Equal("Cat", codeModel.ModelTypes.First(m => m.Name == "Siamese").BaseModelType.Name);
}
public void TestcodeModelWithXmsDiscriminatorValue()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-x-ms-discriminator-value.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal("Pet", codeModel.ModelTypes.First(m => m.Name == "Pet").Name);
Assert.Equal("Microsoft.Models.MSPet", codeModel.ModelTypes.First(m => m.Name == "Pet").Extensions["x-ms-discriminator-value"]);
Assert.Equal("type", codeModel.ModelTypes.First(m => m.Name == "Pet").PolymorphicDiscriminator);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Pet").IsPolymorphic);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Pet").BaseIsPolymorphic);
Assert.Equal("Cat", codeModel.ModelTypes.First(m => m.Name == "Cat").Name);
Assert.Equal("Microsoft.Models.MSCat", codeModel.ModelTypes.First(m => m.Name == "Cat").Extensions["x-ms-discriminator-value"]);
Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Cat").BaseIsPolymorphic);
Assert.Equal("Pet", codeModel.ModelTypes.First(m => m.Name == "Cat").BaseModelType.Name);
}
public void TestcodeModelPolymorhism()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-polymorphism.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal("Pet", codeModel.ModelTypes.First(m => m.Name == "Pet").Name);
Assert.Equal("dtype", codeModel.ModelTypes.First(m => m.Name == "Pet").PolymorphicDiscriminator);
Assert.Equal(2, codeModel.ModelTypes.First(m => m.Name == "Pet").Properties.Count);
Assert.Equal("Id", codeModel.ModelTypes.First(m => m.Name == "Pet").Properties[0].Name);
Assert.Equal("Description", codeModel.ModelTypes.First(m => m.Name == "Pet").Properties[1].Name);
Assert.Equal("Cat", codeModel.ModelTypes.First(m => m.Name == "Cat").Name);
Assert.Equal("Pet", codeModel.ModelTypes.First(m => m.Name == "Cat").BaseModelType.Name);
Assert.Equal(1, codeModel.ModelTypes.First(m => m.Name == "Cat").Properties.Count);
Assert.Equal("Lizard", codeModel.ModelTypes.First(m => m.Name == "Lizard").Name);
Assert.Equal("lzd", codeModel.ModelTypes.First(m => m.Name == "Lizard").SerializedName);
}
internal static MemoryFileSystem GenerateCodeInto(this string testName, MemoryFileSystem inputFileSystem, Settings settings, IAnyPlugin plugin = null)
{
plugin = plugin ?? new PluginCs();
Settings.Instance.FileSystemInput = inputFileSystem;
// copy the whole input directory into the memoryfilesystem.
inputFileSystem.CopyFolder("Resource", testName, "");
// find the appropriately named .yaml or .json file for the swagger.
foreach (var ext in new[] { ".yaml", ".json", ".md" })
{
var name = testName + ext;
if (inputFileSystem.FileExists(name))
{
settings.Input = name;
}
}
if (string.IsNullOrWhiteSpace(settings.Input))
{
throw new Exception($"Can't find swagger file ${testName} [.yaml] [.json] [.md]");
}
var modeler = new SwaggerModeler(Settings.Instance);
var swagger = SwaggerParser.Parse(inputFileSystem.ReadAllText(Settings.Instance.Input));
var codeModel = modeler.Build(swagger);
using (plugin.Activate())
{
// load model into language-specific code model
codeModel = plugin.Serializer.Load(codeModel);
// apply language-specific tranformation (more than just language-specific types)
// used to be called "NormalizeClientModel" .
codeModel = plugin.Transformer.TransformCodeModel(codeModel);
// Generate code from CodeModel.
plugin.CodeGenerator.Generate(codeModel).GetAwaiter().GetResult();
return(settings.FileSystemOutput);
}
}
public void ConvertsPageResultsToPageTypeTest()
{
using (NewContext)
{
var input = Path.Combine(Core.Utilities.Extensions.CodeBaseDirectory(typeof(CSharpAzureCodeNamingFrameworkTests)), "Resource", "azure-paging.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
var plugin = new AutoRest.CSharp.Azure.PluginCsa();
using (plugin.Activate()) {
codeModel = plugin.Serializer.Load(codeModel);
codeModel = plugin.Transformer.TransformCodeModel(codeModel);
var methods = codeModel.Methods.ToList();
Assert.Equal(7, methods.Count);
Assert.Equal(1, methods.Count(m => m.Name == "GetSinglePage"));
Assert.Equal(0, methods.Count(m => m.Name == "GetSinglePageNext"));
Assert.Equal(1, methods.Count(m => m.Name == "PutSinglePage"));
Assert.Equal(1, methods.Count(m => m.Name == "PutSinglePageSpecialNext"));
Assert.Equal("Page<Product>", methods[0].ReturnType.Body.Name);
Assert.Equal("object", methods[1].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", methods[1].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("string",
methods[1].Responses.ElementAt(1).Value.Body.Name.ToLowerInvariant());
Assert.Equal("object", methods[2].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", methods[2].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("Page1<Product>", methods[2].Responses.ElementAt(1).Value.Body.Name);
Assert.Equal("object", methods[3].ReturnType.Body.Name.ToLowerInvariant());
Assert.Equal("Page1<Product>", methods[3].Responses.ElementAt(0).Value.Body.Name);
Assert.Equal("Page1<ProductChild>", methods[3].Responses.ElementAt(1).Value.Body.Name);
Assert.Equal(5, codeModel.ModelTypes.Count);
Assert.False(
codeModel.ModelTypes.Any(t => t.Name.EqualsIgnoreCase("ProducResult")));
Assert.False(
codeModel.ModelTypes.Any(t => t.Name.EqualsIgnoreCase("ProducResult2")));
Assert.False(
codeModel.ModelTypes.Any(t => t.Name.EqualsIgnoreCase("ProducResult3")));
}
}
}
public void TestcodeModelWithDifferentReturnsTypesBasedOnStatusCode()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-multiple-response-schemas.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal("GetSameResponse", codeModel.Methods[0].Name);
Assert.Equal("IList<Pet>", CreateCSharpResponseType(codeModel.Methods[0].ReturnType));
Assert.Equal("IList<Pet>", CreateCSharpResponseType(codeModel.Methods[0].Responses[HttpStatusCode.OK]));
Assert.Equal("IList<Pet>", CreateCSharpResponseType(codeModel.Methods[0].Responses[HttpStatusCode.Accepted]));
Assert.Equal("PostInheretedTypes", codeModel.Methods[1].Name);
Assert.Equal("Pet", CreateCSharpResponseType(codeModel.Methods[1].ReturnType));
Assert.Equal("Dog", CreateCSharpResponseType(codeModel.Methods[1].Responses[HttpStatusCode.OK]));
Assert.Equal("Cat", CreateCSharpResponseType(codeModel.Methods[1].Responses[HttpStatusCode.Accepted]));
Assert.Equal("PatchDifferentStreamTypesNoContent", codeModel.Methods[6].Name);
Assert.Equal("VirtualMachineGetRemoteDesktopFileResponse", CreateCSharpResponseType(codeModel.Methods[6].ReturnType));
Assert.Equal("VirtualMachineGetRemoteDesktopFileResponse", CreateCSharpResponseType(codeModel.Methods[6].Responses[HttpStatusCode.OK]));
Assert.Null(codeModel.Methods[6].Responses[HttpStatusCode.NoContent].Body);
}
public void TestRealPathIrregular()
{
var input = Path.Combine("Resource", "Swagger", "swagger-xml-paths.yaml");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
foreach (var property in codeModel.ModelTypes.SelectMany(m => m.Properties))
{
var expectedRealPath = property.Documentation.StartsWith("CUSTOM_")
? property.Documentation.Substring("CUSTOM_".Length)
: null;
var expectedRealXmlPath = property.Summary;
if (expectedRealPath != null)
{
Assert.Equal(expectedRealPath, string.Join(".", property.RealPath));
}
if (expectedRealXmlPath != null)
{
Assert.Equal(expectedRealXmlPath, string.Join(".", property.RealXmlPath));
}
}
}
public void TestcodeModelWithManyAllOfRelationships()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-ref-allOf-inheritance.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
// the model has a few base type relationships which should be observed:
// RedisResource is a Resource
var resourceModel = codeModel.ModelTypes.Single(x => x.Name == "Resource");
var redisResourceModel = codeModel.ModelTypes.Single(x => x.Name == "RedisResource");
Assert.Equal(resourceModel, redisResourceModel.BaseModelType);
// RedisResourceWithAccessKey is a RedisResource
var redisResponseWithAccessKeyModel =
codeModel.ModelTypes.Single(x => x.Name == "RedisResourceWithAccessKey");
Assert.Equal(redisResourceModel, redisResponseWithAccessKeyModel.BaseModelType);
// RedisCreateOrUpdateParameters is a Resource
var redisCreateUpdateParametersModel =
codeModel.ModelTypes.Single(x => x.Name == "RedisCreateOrUpdateParameters");
Assert.Equal(resourceModel, redisCreateUpdateParametersModel.BaseModelType);
// RedisReadableProperties is a RedisProperties
var redisPropertiesModel = codeModel.ModelTypes.Single(x => x.Name == "RedisProperties");
var redisReadablePropertieModel = codeModel.ModelTypes.Single(x => x.Name == "RedisReadableProperties");
Assert.Equal(redisPropertiesModel, redisReadablePropertieModel.BaseModelType);
// RedisReadablePropertiesWithAccessKey is a RedisReadableProperties
var redisReadablePropertiesWithAccessKeysModel =
codeModel.ModelTypes.Single(x => x.Name == "RedisReadablePropertiesWithAccessKey");
Assert.Equal(redisReadablePropertieModel, redisReadablePropertiesWithAccessKeysModel.BaseModelType);
}
public void TestAdditionalProperties()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-additional-properties.yaml");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
Assert.NotNull(codeModel);
Assert.Equal(5, codeModel.ModelTypes.Count);
// did we find the type?
var wtd = codeModel.ModelTypes.FirstOrDefault(each => each.Name == "WithTypedDictionary");
Assert.NotNull(wtd);
// did we find the member called 'additionalProperties'
var prop = wtd.Properties.FirstOrDefault(each => each.Name == "AdditionalProperties");
Assert.NotNull(prop);
// is it a DictionaryType?
var dictionaryProperty = prop.ModelType as DictionaryType;
Assert.NotNull(dictionaryProperty);
// is a string,string dictionary?
Assert.Equal("Dictionary<string,Feature>", dictionaryProperty.Name);
Assert.Equal("Feature", dictionaryProperty.ValueType.Name);
// is it marked as an 'additionalProperties' bucket?
Assert.True(dictionaryProperty.SupportsAdditionalProperties);
// did we find the type?
var wud = codeModel.ModelTypes.FirstOrDefault(each => each.Name == "WithUntypedDictionary");
Assert.NotNull(wud);
// did we find the member called 'additionalProperties'
prop = wud.Properties.FirstOrDefault(each => each.Name == "AdditionalProperties");
Assert.NotNull(prop);
// is it a DictionaryType?
dictionaryProperty = prop.ModelType as DictionaryType;
Assert.NotNull(dictionaryProperty);
// is a string,string dictionary?
Assert.Equal("Dictionary<string,Object>", dictionaryProperty.Name);
Assert.Equal("Object", dictionaryProperty.ValueType.Name);
// is it marked as an 'additionalProperties' bucket?
Assert.True(dictionaryProperty.SupportsAdditionalProperties);
var wsd = codeModel.ModelTypes.FirstOrDefault(each => each.Name == "WithStringDictionary");
Assert.NotNull(wsd);
// did we find the member called 'additionalProperties'
prop = wsd.Properties.FirstOrDefault(each => each.Name == "AdditionalProperties");
Assert.NotNull(prop);
// is it a DictionaryType?
dictionaryProperty = prop.ModelType as DictionaryType;
Assert.NotNull(dictionaryProperty);
// is a string,string dictionary?
Assert.Equal("Dictionary<string,String>", dictionaryProperty.Name);
Assert.Equal("String", dictionaryProperty.ValueType.Name);
// is it marked as an 'additionalProperties' bucket?
Assert.True(dictionaryProperty.SupportsAdditionalProperties);
}
public void TestClientWithValidation()
{
var input = Path.Combine(CodeBaseDirectory, "Resource", "Swagger", "swagger-validation.json");
var modeler = new SwaggerModeler();
var codeModel = modeler.Build(SwaggerParser.Parse(File.ReadAllText(input)));
var methods = codeModel.Methods.ToList();
Assert.Equal("resourceGroupName", methods[0].Parameters[1].Name);
Assert.Equal(true, methods[0].Parameters[1].IsRequired);
Assert.Equal(3, methods[0].Parameters[1].Constraints.Count);
Assert.Equal("10", methods[0].Parameters[1].Constraints[Constraint.MaxLength]);
Assert.Equal("3", methods[0].Parameters[1].Constraints[Constraint.MinLength]);
Assert.Equal("[a-zA-Z0-9]+", methods[0].Parameters[1].Constraints[Constraint.Pattern]);
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.MultipleOf));
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.ExclusiveMaximum));
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.ExclusiveMinimum));
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.InclusiveMinimum));
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.InclusiveMaximum));
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.MinItems));
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.MaxItems));
Assert.False(methods[0].Parameters[1].Constraints.ContainsKey(Constraint.UniqueItems));
Assert.Equal("id", methods[0].Parameters[2].Name);
Assert.Equal(3, methods[0].Parameters[2].Constraints.Count);
Assert.Equal("10", methods[0].Parameters[2].Constraints[Constraint.MultipleOf]);
Assert.Equal("100", methods[0].Parameters[2].Constraints[Constraint.InclusiveMinimum]);
Assert.Equal("1000", methods[0].Parameters[2].Constraints[Constraint.InclusiveMaximum]);
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.ExclusiveMaximum));
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.ExclusiveMinimum));
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.MaxLength));
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.MinLength));
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.Pattern));
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.MinItems));
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.MaxItems));
Assert.False(methods[0].Parameters[2].Constraints.ContainsKey(Constraint.UniqueItems));
Assert.Equal("apiVersion", methods[0].Parameters[3].Name);
Assert.NotNull(methods[0].Parameters[3].ClientProperty);
Assert.Equal(1, methods[0].Parameters[3].Constraints.Count);
Assert.Equal("\\d{2}-\\d{2}-\\d{4}", methods[0].Parameters[3].Constraints[Constraint.Pattern]);
Assert.Equal("Product", codeModel.ModelTypes.First(m => m.Name == "Product").Name);
Assert.Equal("DisplayNames", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Name);
Assert.Equal(3, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.Count);
Assert.Equal("6", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints[Constraint.MaxItems]);
Assert.Equal("0", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints[Constraint.MinItems]);
Assert.Equal("true", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints[Constraint.UniqueItems]);
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.ExclusiveMaximum));
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.ExclusiveMinimum));
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.InclusiveMaximum));
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.InclusiveMinimum));
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.MultipleOf));
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.MinLength));
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.MaxLength));
Assert.False(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[2].Constraints.ContainsKey(Constraint.Pattern));
Assert.Equal("Capacity", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[3].Name);
Assert.Equal(2, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[3].Constraints.Count);
Assert.Equal("100", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[3].Constraints[Constraint.ExclusiveMaximum]);
Assert.Equal("0", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[3].Constraints[Constraint.ExclusiveMinimum]);
}
