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 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 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"); }
/// <summary> /// Changes paginated method signatures to return Page type. /// </summary> /// <param name="serviceClient"></param> /// <param name="pageClasses"></param> public virtual void NormalizePaginatedMethods(ServiceClient serviceClient, IDictionary <KeyValuePair <string, string>, string> pageClasses) { if (serviceClient == null) { throw new ArgumentNullException("serviceClient"); } var convertedTypes = new Dictionary <IType, CompositeType>(); foreach (var method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension))) { string nextLinkString; string pageClassName = GetPagingSetting(method.Extensions, pageClasses, out nextLinkString); if (string.IsNullOrEmpty(pageClassName)) { continue; } var pageTypeFormat = "{0}<{1}>"; var ipageTypeFormat = "Microsoft.Rest.Azure.IPage<{0}>"; if (string.IsNullOrWhiteSpace(nextLinkString)) { ipageTypeFormat = "System.Collections.Generic.IEnumerable<{0}>"; } foreach (var responseStatus in method.Responses .Where(r => r.Value.Body is CompositeType).Select(s => s.Key).ToArray()) { var compositType = (CompositeType)method.Responses[responseStatus].Body; var sequenceType = compositType.Properties.Select(p => p.Type).FirstOrDefault(t => t is SequenceType) as SequenceType; // if the type is a wrapper over page-able response if (sequenceType != null) { var pagableTypeName = string.Format(CultureInfo.InvariantCulture, pageTypeFormat, pageClassName, sequenceType.ElementType.Name); var ipagableTypeName = string.Format(CultureInfo.InvariantCulture, ipageTypeFormat, sequenceType.ElementType.Name); CompositeType pagedResult = new CompositeType { Name = pagableTypeName }; pagedResult.Extensions[AzureExtensions.ExternalExtension] = true; pagedResult.Extensions[AzureExtensions.PageableExtension] = ipagableTypeName; convertedTypes[method.Responses[responseStatus].Body] = pagedResult; method.Responses[responseStatus] = new Response(pagedResult, method.Responses[responseStatus].Headers); } } if (convertedTypes.ContainsKey(method.ReturnType.Body)) { method.ReturnType = new Response(convertedTypes[method.ReturnType.Body], method.ReturnType.Headers); } } SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name))); }
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 void GetPath_Should_ReturnFullDeleteMethod() { var controllerType = typeof(StubController); var actual = SwaggerExtensions.GetPath("prefix", controllerType, controllerType.GetMethod(nameof(StubController.Delete))); const string expected = "/prefix/Stub/Delete(System.Guid id)"; Assert.Equal(expected, actual); }
public void GetPath_Should_ReturnClearMethod() { var controllerType = typeof(StubController); var actual = SwaggerExtensions.GetPath("prefix", controllerType, controllerType.GetMethod(nameof(StubController.Clear))); const string expected = "/prefix/Stub/Clear()"; Assert.Equal(expected, actual); }
public override CodeModelRb TransformCodeModel(CodeModel cm) { var codeModel = cm as CodeModelRb; SwaggerExtensions.NormalizeClientModel(codeModel); PopulateAdditionalProperties(codeModel); Flattening(codeModel); return(codeModel); }
public AnnotatedResponse(SwaggerResponseAttribute attr, ISwaggerModelCatalog modelCatalog) { Description = attr.Message; StatusCode = (int)attr.Code; if (attr.Model != null) { Schema = SwaggerExtensions.GetSchema(modelCatalog, attr.Model); } }
/// <summary> /// Changes paginated method signatures to return Page type. /// </summary> /// <param name="serviceClient"></param> /// <param name="pageClasses"></param> public void NormalizePaginatedMethods(CodeModel serviceClient, IDictionary <KeyValuePair <string, string>, string> pageClasses) { if (serviceClient == null) { throw new ArgumentNullException("serviceClient"); } var convertedTypes = new Dictionary <IModelType, IModelType>(); foreach (MethodJva method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension))) { string nextLinkString; string pageClassName = GetPagingSetting(method.Extensions, pageClasses, out nextLinkString); if (string.IsNullOrEmpty(pageClassName)) { continue; } if (string.IsNullOrEmpty(nextLinkString)) { method.Extensions[AzureExtensions.PageableExtension] = null; } foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeTypeJva).Select(s => s.Key).ToArray()) { var compositType = (CompositeTypeJva)method.Responses[responseStatus].Body; var sequenceType = compositType.Properties.Select(p => p.ModelType).FirstOrDefault(t => t is SequenceTypeJva) as SequenceTypeJva; // if the type is a wrapper over page-able response if (sequenceType != null) { IModelType pagedResult; pagedResult = new SequenceTypeJva { ElementType = sequenceType.ElementType, PageImplType = pageClassName }; convertedTypes[method.Responses[responseStatus].Body] = pagedResult; var resp = New <Response>(pagedResult, method.Responses[responseStatus].Headers) as ResponseJva; resp.Parent = method; method.Responses[responseStatus] = resp; } } if (convertedTypes.ContainsKey(method.ReturnType.Body)) { var resp = New <Response>(convertedTypes[method.ReturnType.Body], method.ReturnType.Headers) as ResponseJva; resp.Parent = method; method.ReturnType = resp; } } SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeTypeJva>().Select(t => t.Name.ToString()))); }
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 CodeModelPy TransformCodeModel(CodeModel cm) { var codeModel = cm as CodeModelPy; TransformGroupApiVersionToLocal(codeModel); SwaggerExtensions.NormalizeClientModel(codeModel); PopulateAdditionalProperties(codeModel); Flattening(codeModel); GenerateConstantProperties(codeModel); return(codeModel); }
public override CodeModelGo TransformCodeModel(CodeModel cm) { var cmg = cm as CodeModelGo; SwaggerExtensions.ProcessGlobalParameters(cmg); // Add the current package name as a reserved keyword CodeNamerGo.Instance.ReserveNamespace(cm.Namespace); FixStutteringTypeNames(cmg); TransformEnumTypes(cmg); TransformMethods(cmg); TransformModelTypes(cmg); return(cmg); }
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 CodeModelSwift TransformCodeModel(CodeModel cm) { var cmg = cm as CodeModelSwift; SwaggerExtensions.ProcessGlobalParameters(cmg); // Add the current package name as a reserved keyword TransformEnumTypes(cmg); TransformModelTypes(cmg); TransformMethods(cmg); AppendTypeSpecifier(cmg); AzureExtensions.ProcessParameterizedHost(cmg); return(cmg); }
/// <summary> /// Changes paginated method signatures to return Page type. /// </summary> /// <param name="codeModel"></param> private void NormalizePaginatedMethods(CodeModelPya codeModel) { if (codeModel == null) { throw new ArgumentNullException("codeModel"); } var convertedTypes = new Dictionary <IModelType, Response>(); foreach (MethodPya method in codeModel.Methods.Where(m => m is MethodPya && m.Extensions.ContainsKey(AzureExtensions.PageableExtension))) { foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeType).Select(s => s.Key)) { var compositType = (CompositeType)method.Responses[responseStatus].Body; var sequenceType = compositType.Properties.Select(p => p.ModelType).FirstOrDefault(t => t is SequenceType) as SequenceType; // if the type is a wrapper over page-able response if (sequenceType != null) { var valueType = sequenceType.ElementType; string valueTypeName = valueType.Name; if (!codeModel.PageClasses.ContainsKey(valueTypeName)) { codeModel.PageClasses.Add(valueTypeName, new Dictionary <int, string>()); } var pagableTypeName = GetPagingSetting(codeModel, compositType, method.Extensions, valueType, codeModel.PageClasses[valueTypeName], method.SerializedName); var pagedResult = New <CompositeType>(pagableTypeName); // make sure the parent reference is set. pagedResult.CodeModel = codeModel; method.PagedResponseContentClass = valueType; // Save the content type model convertedTypes[compositType] = new Response(pagedResult, null); method.Responses[responseStatus] = convertedTypes[compositType]; break; } } if (convertedTypes.ContainsKey(method.ReturnType.Body)) { method.ReturnType = convertedTypes[method.ReturnType.Body]; } } SwaggerExtensions.RemoveUnreferencedTypes(codeModel, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name.Value))); }
public override CodeModelGo TransformCodeModel(CodeModel cm) { var cmg = cm as CodeModelGo; SwaggerExtensions.ProcessGlobalParameters(cmg); TransformEnumTypes(cmg); TransformModelTypes(cmg); TransformMethods(cmg); SwaggerExtensions.ProcessParameterizedHost(cmg); FixStutteringTypeNames(cmg); AssureUniqueNames(cmg); TransformPropertyTypes(cmg); return(cmg); }
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); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { // Don't add pagable/longrunning method since we already handle ourself. Settings.AddCredentials = true; AzureExtensions.ProcessClientRequestIdExtension(serviceClient); AzureExtensions.UpdateHeadMethods(serviceClient); AzureExtensions.ParseODataExtension(serviceClient); SwaggerExtensions.FlattenModels(serviceClient); ParameterGroupExtensionHelper.AddParameterGroups(serviceClient); AzureExtensions.AddAzureProperties(serviceClient); AzureExtensions.SetDefaultResponses(serviceClient); CorrectFilterParameters(serviceClient); base.NormalizeClientModel(serviceClient); NormalizeApiVersion(serviceClient); NormalizePaginatedMethods(serviceClient); }
/// <summary> /// Changes paginated method signatures to return Page type. /// </summary> /// <param name="serviceClient"></param> private void NormalizePaginatedMethods(ServiceClient serviceClient) { if (serviceClient == null) { throw new ArgumentNullException("serviceClient"); } var convertedTypes = new Dictionary <IType, Response>(); foreach (var method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension))) { foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeType).Select(s => s.Key)) { var compositType = (CompositeType)method.Responses[responseStatus].Body; var sequenceType = compositType.Properties.Select(p => p.Type).FirstOrDefault(t => t is SequenceType) as SequenceType; // if the type is a wrapper over page-able response if (sequenceType != null) { string valueType = sequenceType.ElementType.Name; if (!pageClasses.ContainsKey(valueType)) { pageClasses.Add(valueType, new Dictionary <int, string>()); } string pagableTypeName = GetPagingSetting(compositType, method.Extensions, valueType, pageClasses[valueType], method.SerializedName); CompositeType pagedResult = new CompositeType { Name = pagableTypeName }; convertedTypes[compositType] = new Response(pagedResult, null); method.Responses[responseStatus] = convertedTypes[compositType]; break; } } if (convertedTypes.ContainsKey(method.ReturnType.Body)) { method.ReturnType = convertedTypes[method.ReturnType.Body]; } } SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name))); }
public override CodeModelGo TransformCodeModel(CodeModel cm) { var cmg = cm as CodeModelGo; SwaggerExtensions.ProcessGlobalParameters(cmg); TransformEnumTypes(cmg); TransformModelTypes(cmg); // FixUpPolymorphicTypes can generate new enum types so to avoid // name collisions call it after transforming enums and models FixUpPolymorphicTypes(cmg); TransformMethods(cmg); SwaggerExtensions.ProcessParameterizedHost(cmg); FixStutteringTypeNames(cmg); AssureUniqueNames(cmg); TransformPropertyTypes(cmg); return(cmg); }
public override CodeModelGo TransformCodeModel(CodeModel cm) { var cmg = cm as CodeModelGo; // DON'T EVER CHANGE THE ORDERING OF THESE METHODS, CHANGING THE ORDER OF THESE METHODS MIGHT LEAD TO UNEXPECTED RESULTS SwaggerExtensions.ProcessGlobalParameters(cmg); TransformEnumTypes(cmg); TransformModelTypes(cmg); // FixUpPolymorphicTypes can generate new enum types so to avoid // name collisions call it after transforming enums and models FixUpPolymorphicTypes(cmg); TransformMethods(cmg); SwaggerExtensions.ProcessParameterizedHost(cmg); FixStutteringTypeNames(cmg); AssureUniqueNames(cmg); TransformPropertyTypes(cmg); return(cmg); }
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 CodeModelGo TransformCodeModel(CodeModel cm) { var cmg = cm as CodeModelGo; // DON'T EVER CHANGE THE ORDERING OF THESE METHODS, CHANGING THE ORDER OF THESE METHODS MIGHT LEAD TO UNEXPECTED RESULTS SwaggerExtensions.ProcessGlobalParameters(cmg); TransformEnumTypes(cmg); TransformModelTypes(cmg); // FixUpPolymorphicTypes can generate new enum types so to avoid // name collisions call it after transforming enums and models FixUpPolymorphicTypes(cmg); TransformMethods(cmg); SwaggerExtensions.ProcessParameterizedHost(cmg); FixStutteringTypeNames(cmg); // Get the setting of enum prefix var enumPrefix = Settings.Instance.Host.GetValue <bool>("enum-prefix").Result; TransfromEnumValues(cmg, enumPrefix); TransformPropertyTypes(cmg); return(cmg); }
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); }