public void TestClientModelWithPayloadFlattening()
{
using (NewContext)
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-payload-flatten.json"),
PayloadFlatteningThreshold = 3
};
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(4, clientModel.Methods[0].Parameters.Count);
Assert.Equal("String subscriptionId", clientModel.Methods[0].Parameters[0].ToString());
Assert.Equal("String resourceGroupName", clientModel.Methods[0].Parameters[1].ToString());
Assert.Equal("String apiVersion", clientModel.Methods[0].Parameters[2].ToString());
Assert.Equal("MaxProduct maxProduct", clientModel.Methods[0].Parameters[3].ToString());
Assert.Equal(6, clientModel.Methods[1].Parameters.Count);
Assert.Equal("String subscriptionId", clientModel.Methods[1].Parameters[0].ToString());
Assert.Equal("String resourceGroupName", clientModel.Methods[1].Parameters[1].ToString());
Assert.Equal("String apiVersion", clientModel.Methods[1].Parameters[2].ToString());
Assert.Equal("String baseProductId", clientModel.Methods[1].Parameters[3].ToString());
Assert.Equal(true, clientModel.Methods[1].Parameters[3].IsRequired);
Assert.Equal("String baseProductDescription", clientModel.Methods[1].Parameters[4].ToString());
Assert.Equal(false, clientModel.Methods[1].Parameters[4].IsRequired);
Assert.Equal("MaxProduct maxProductReference", clientModel.Methods[1].Parameters[5].ToString());
Assert.Equal(false, clientModel.Methods[1].Parameters[5].IsRequired);
Assert.Equal(1, clientModel.Methods[1].InputParameterTransformation.Count);
Assert.Equal(3, clientModel.Methods[1].InputParameterTransformation[0].ParameterMappings.Count);
}
}
public override CodeModelPy TransformCodeModel(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
// Put the initial namespace value, not transformed by the Core
// Note that the "Else" is not supposed to be used, since Autorest
// provides a default value now for Namespace, so Namespace is never empty.
codeModel.Namespace = Settings.Instance.Namespace.Else(codeModel.Name.ToPythonCase().ToLower());
// api_version is no longer a parameter of the constructor
codeModel.Remove(codeModel.Properties.FirstOrDefault(p => p.Name == "api_version"));
// If one of the constructor parameter is called base_url, rename it to base_url_parameter
Property baseUrlPRop = codeModel.Properties.FirstOrDefault(each => each.Name == "base_url");
if (baseUrlPRop != null)
{
baseUrlPRop.Name = "base_url_parameter";
}
TransformGroupApiVersionToLocal(codeModel);
SwaggerExtensions.NormalizeClientModel(codeModel);
PopulateAdditionalProperties(codeModel);
PopulateDiscriminator(codeModel);
Flattening(codeModel);
GenerateConstantProperties(codeModel);
return(codeModel);
}
public void TestParameterLocationExtension()
{
using (NewContext)
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-parameter-location.json"),
PayloadFlatteningThreshold = 3
};
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(2, clientModel.Properties.Count);
Assert.Equal(clientModel.Properties[0].Name, "SubscriptionId");
Assert.Equal(clientModel.Properties[1].Name, "ApiVersion");
Assert.False(
clientModel.Methods[0].Parameters.First(p => p.Name == "resourceGroupName").IsClientProperty);
Assert.True(clientModel.Methods[0].Parameters.First(p => p.Name == "subscriptionId").IsClientProperty);
Assert.True(clientModel.Methods[0].Parameters.First(p => p.Name == "apiVersion").IsClientProperty);
Assert.False(
clientModel.Methods[1].Parameters.First(p => p.Name == "resourceGroupName").IsClientProperty);
Assert.True(clientModel.Methods[1].Parameters.First(p => p.Name == "subscriptionId").IsClientProperty);
Assert.True(clientModel.Methods[1].Parameters.First(p => p.Name == "apiVersion").IsClientProperty);
}
}
public override CodeModelTS TransformCodeModel(CodeModel cm)
{
var codeModel = cm as CodeModelTS;
// we're guaranteed to be in our language-specific context here.
SwaggerExtensions.NormalizeClientModel(codeModel);
TransformHeaderCollectionParameterTypes(codeModel);
PopulateAdditionalProperties(codeModel);
NormalizeOdataFilterParameter(codeModel);
PerformParameterMapping(codeModel);
CreateModelTypeForOptionalClientProperties(codeModel);
CreateModelTypesForOptionalMethodParameters(codeModel);
AddEnumTypesToCodeModel(codeModel);
EnsureParameterMethodSet(codeModel);
CreateUniqueParameterMapperNames(codeModel);
DisambiguateHeaderNames(codeModel);
AddReadOnlyDocumentation(codeModel);
ProcessAdditionalProperties(codeModel);
if (codeModel.Settings.ModelDateTimeAsString)
{
ConvertDateTimeToString(codeModel);
}
return(codeModel);
}
public override CodeModelTf TransformCodeModel(CodeModel codeModel)
{
var model = base.TransformCodeModel(codeModel);
SwaggerExtensions.NormalizeClientModel(model);
CreateTransformers().ForEach(tr => tr.Transform(model));
return(model);
}
/// <summary>
/// Normalizes client model by updating names and types to be language specific.
/// </summary>
/// <param name="serviceClient"></param>
public override void NormalizeClientModel(ServiceClient serviceClient)
{
SwaggerExtensions.NormalizeClientModel(serviceClient, Settings);
PopulateAdditionalProperties(serviceClient);
CodeNamer.NormalizeClientModel(serviceClient);
CodeNamer.ResolveNameCollisions(serviceClient, Settings.Namespace,
Settings.Namespace + "::Models");
}
public void TestClientModelWithPayloadFlatteningViaXMSClientFlatten()
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-x-ms-client-flatten.json")
};
var modeler = new SwaggerModeler(setting);
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel, setting);
Assert.NotNull(clientModel);
Assert.Equal(8, clientModel.ModelTypes.Count);
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "SimpleProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProductProperties")); // Since it's referenced in the response
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "RecursiveProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "Error"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ProductWithInheritance"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseFlattenedProduct"));
var simpleProduct = clientModel.ModelTypes.First(m => m.Name == "SimpleProduct");
Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_display_name" &&
p.Name == "max_product_display_name"));
Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_capacity" &&
p.Name == "max_product_capacity"));
Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_image.@odata\\\\.value" &&
p.Name == "@odata.value"));
var conflictedProduct = clientModel.ModelTypes.First(m => m.Name == "ConflictedProduct");
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "max_product_display_name" &&
p.Name == "max_product_display_name"));
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "details.max_product_display_name" &&
p.Name == "ConflictedProductProperties_max_product_display_name"));
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "simpleDetails.max_product_display_name" &&
p.Name == "SimpleProductProperties_max_product_display_name"));
Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "details.base_product_description" &&
p.Name == "ConflictedProduct_base_product_description"));
var recursiveProduct = clientModel.ModelTypes.First(m => m.Name == "RecursiveProduct");
Assert.True(recursiveProduct.Properties.Any(p => p.SerializedName == "properties.name" &&
p.Name == "name"));
Assert.True(recursiveProduct.Properties.Any(p => p.SerializedName == "properties.parent" &&
p.Name == "parent"));
var error = clientModel.ModelTypes.First(m => m.Name == "Error");
Assert.Equal(3, error.Properties.Count);
Assert.True(error.Properties.Any(p => p.SerializedName == "code" && p.Name == "code"));
Assert.True(error.Properties.Any(p => p.SerializedName == "message" && p.Name == "message"));
Assert.True(error.Properties.Any(p => p.SerializedName == "parentError" && p.Name == "parentError"));
Assert.True(error.Properties.First(p => p.SerializedName == "parentError" && p.Name == "parentError").Type == error);
}
public override CodeModelRb TransformCodeModel(CodeModel cm)
{
var codeModel = cm as CodeModelRb;
SwaggerExtensions.NormalizeClientModel(codeModel);
PopulateAdditionalProperties(codeModel);
Flattening(codeModel);
return(codeModel);
}
public override CodeModelPy TransformCodeModel(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
TransformGroupApiVersionToLocal(codeModel);
SwaggerExtensions.NormalizeClientModel(codeModel);
PopulateAdditionalProperties(codeModel);
Flattening(codeModel);
GenerateConstantProperties(codeModel);
return(codeModel);
}
public override CodeModelJv TransformCodeModel(CodeModel cs)
{
var codeModel = cs as CodeModelJv;
// we're guaranteed to be in our language-specific context here.
// todo: these should be turned into individual transformers
SwaggerExtensions.NormalizeClientModel(codeModel);
return(codeModel);
}
public override CodeModelTS TransformCodeModel(CodeModel cm)
{
var codeModel = cm as CodeModelTS;
// we're guaranteed to be in our language-specific context here.
SwaggerExtensions.NormalizeClientModel(codeModel);
PopulateAdditionalProperties(codeModel);
NormalizeOdataFilterParameter(codeModel);
PerformParameterMapping(codeModel);
CreateModelTypeForOptionalClientProperties(codeModel);
CreateModelTypesForOptionalMethodParameters(codeModel);
AddEnumTypesToCodeModel(codeModel);
return(codeModel);
}
public override CodeModelPy TransformCodeModel(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
// Put the initial namespace value, not transformed by the Core
// Note that the "Else" is not supposed to be used, since Autorest
// provides a default value now for Namespace, so Namespace is never empty.
codeModel.Namespace = Settings.Instance.Namespace.Else(codeModel.Name.ToPythonCase().ToLower());
TransformGroupApiVersionToLocal(codeModel);
SwaggerExtensions.NormalizeClientModel(codeModel);
PopulateAdditionalProperties(codeModel);
Flattening(codeModel);
GenerateConstantProperties(codeModel);
return(codeModel);
}
public override CodeModelCs TransformCodeModel(CodeModel cs)
{
var codeModel = cs as CodeModelCs;
// we're guaranteed to be in our language-specific context here.
// add the Credentials
PopulateAdditionalProperties(codeModel);
// todo: these should be turned into individual transformers
SwaggerExtensions.NormalizeClientModel(codeModel);
// Do parameter transformations
TransformParameters(codeModel);
return(codeModel);
}
public void TestClientModelClientName()
{
using (NewContext)
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-x-ms-client-name.json")
};
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(2, clientModel.Methods.Count);
Assert.Equal(2, clientModel.Methods[0].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal(0, clientModel.Methods[1].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].Name);
Assert.Equal("version", clientModel.Methods[0].Parameters[1].Name);
Assert.Equal("subscriptionId", clientModel.Methods[0].Parameters[0].Name.FixedValue);
Assert.Equal("apiVersion", clientModel.Methods[0].Parameters[1].Name.FixedValue);
Assert.Equal(2, clientModel.Properties.Count);
Assert.Equal("Subscription", clientModel.Properties[0].Name);
Assert.Equal("_version", clientModel.Properties[1].Name);
Assert.Equal("subscriptionId", clientModel.Properties[0].Name.FixedValue);
Assert.Equal("apiVersion", clientModel.Properties[1].Name.FixedValue);
Assert.Equal(1, clientModel.ModelTypes.Count);
var type = clientModel.ModelTypes.First();
Assert.Equal("ErrorCode", type.Properties[0].Name);
Assert.Equal("ErrorMessage", type.Properties[1].Name);
Assert.Equal("ParentError", type.Properties[2].Name);
Assert.Equal("code", type.Properties[0].Name.FixedValue);
Assert.Equal("message", type.Properties[1].Name.FixedValue);
Assert.Equal("parentError", type.Properties[2].Name.FixedValue);
}
}
public void TestClientNameRubyNormalization()
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine("Swagger", "swagger-x-ms-client-name.json")
};
var modeler = new SwaggerModeler(setting);
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel, setting);
var namer = new RubyCodeNamer();
namer.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(2, clientModel.Methods.Count);
Assert.Equal(2, clientModel.Methods[0].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].GetClientName());
Assert.Equal("version", clientModel.Methods[0].Parameters[1].GetClientName());
Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].Name);
Assert.Equal("version", clientModel.Methods[0].Parameters[1].Name);
Assert.Equal(2, clientModel.Properties.Count);
Assert.Equal(0, clientModel.Methods[1].Parameters.Where(p => !p.IsClientProperty).Count());
Assert.Equal("subscription", clientModel.Properties[0].GetClientName());
Assert.Equal("_version", clientModel.Properties[1].GetClientName());
Assert.Equal("subscription", clientModel.Properties[0].Name);
Assert.Equal("_version", clientModel.Properties[1].Name);
var type = clientModel.ModelTypes.First();
Assert.Equal("error_code", type.Properties[0].Name);
Assert.Equal("error_message", type.Properties[1].Name);
Assert.Equal("parent_error", type.Properties[2].Name);
}
public override CodeModelJs TransformCodeModel(CodeModel cm)
{
var codeModel = cm as CodeModelJs;
// we're guaranteed to be in our language-specific context here.
SwaggerExtensions.NormalizeClientModel(codeModel);
PopulateAdditionalProperties(codeModel);
NormalizeOdataFilterParameter(codeModel);
foreach (var method in codeModel.Methods)
{
foreach (var parameterTransformation in method.InputParameterTransformation)
{
parameterTransformation.OutputParameter.Name =
method.GetUniqueName(
CodeNamer.Instance.GetParameterName(parameterTransformation.OutputParameter.GetClientName()));
foreach (var parameterMapping in parameterTransformation.ParameterMappings)
{
if (parameterMapping.InputParameterProperty != null)
{
parameterMapping.InputParameterProperty =
CodeNamer.Instance.GetPropertyName(parameterMapping.InputParameterProperty);
}
if (parameterMapping.OutputParameterProperty != null)
{
parameterMapping.OutputParameterProperty =
CodeNamer.Instance.GetPropertyName(parameterMapping.OutputParameterProperty);
}
}
}
}
return(codeModel);
}
public void TestClientModelWithPayloadFlatteningViaXMSClientFlatten()
{
using (NewContext)
{
var setting = new Settings
{
Namespace = "Test",
Input = Path.Combine(Core.Utilities.Extensions.CodeBaseDirectory, "Resource", "swagger-x-ms-client-flatten.json")
};
var modeler = new SwaggerModeler();
var clientModel = modeler.Build();
SwaggerExtensions.NormalizeClientModel(clientModel);
Assert.NotNull(clientModel);
Assert.Equal(8, clientModel.ModelTypes.Count);
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "SimpleProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProductProperties"));
// Since it's referenced in the response
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "RecursiveProduct"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "Error"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ProductWithInheritance"));
Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseFlattenedProduct"));
var simpleProduct = clientModel.ModelTypes.First(m => m.Name == "SimpleProduct");
Assert.True(simpleProduct.Properties.Any(p => (p.SerializedName == "details.max_product_display_name") &&
(p.Name == "MaxProductDisplayName")));
Assert.True(simpleProduct.Properties.Any(p => (p.SerializedName == "details.max_product_capacity") &&
(p.Name == "MaxProductCapacity")));
Assert.Equal("@odata.value",
simpleProduct.Properties.FirstOrDefault(
p => p.SerializedName == "details.max_product_image.@odata\\\\.value").Name.FixedValue);
var conflictedProduct = clientModel.ModelTypes.First(m => m.Name == "ConflictedProduct");
Assert.True(conflictedProduct.Properties.Any(p => (p.SerializedName == "max_product_display_name") &&
(p.Name.FixedValue == "max_product_display_name")));
Assert.Equal("MaxProductDisplayName2",
conflictedProduct.Properties.FirstOrDefault(
p => p.SerializedName == "details.max_product_display_name").Name);
Assert.Equal("MaxProductDisplayName1",
conflictedProduct.Properties.First(p => p.SerializedName == "simpleDetails.max_product_display_name")
.Name);
Assert.Equal("ConflictedProductBaseProductDescription",
conflictedProduct.Properties.First(p => p.SerializedName == "details.base_product_description").Name);
var recursiveProduct = clientModel.ModelTypes.First(m => m.Name == "RecursiveProduct");
Assert.Equal("Name", recursiveProduct.Properties.First(p => p.SerializedName == "properties.name").Name);
Assert.Equal("Parent",
recursiveProduct.Properties.First(p => p.SerializedName == "properties.parent").Name);
var error = clientModel.ModelTypes.First(m => m.Name == "Error");
Assert.Equal(3, error.Properties.Count);
Assert.Equal("Code", error.Properties.First(p => p.SerializedName == "code").Name);
Assert.Equal("Message", error.Properties.First(p => p.SerializedName == "message").Name);
Assert.Equal("ParentError", error.Properties.First(p => p.SerializedName == "parentError").Name);
}
}