public void ReplacesModelsByInnerInterfaces() { var model = root.AddClass(new CodeClass { Name = "somemodel", Kind = CodeClassKind.Model, }).First(); var requestBuilder = root.AddClass(new CodeClass { Name = "somerequestbuilder", Kind = CodeClassKind.RequestBuilder, }).First(); var responseModel = requestBuilder.AddInnerClass(new CodeClass { Name = "someresponsemodel", Kind = CodeClassKind.Model, }).First(); var executorMethod = requestBuilder.AddMethod(new CodeMethod { Name = "Execute", Kind = CodeMethodKind.RequestExecutor, ReturnType = new CodeType { Name = responseModel.Name, TypeDefinition = responseModel, }, }).First(); var executorParameter = new CodeParameter { Name = "requestBody", Kind = CodeParameterKind.RequestBody, Type = new CodeType { Name = model.Name, TypeDefinition = model, }, }; executorMethod.AddParameter(executorParameter); Assert.Empty(root.GetChildElements(true).OfType <CodeInterface>()); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.Single(root.GetChildElements(true).OfType <CodeInterface>()); var responseInter = requestBuilder.GetChildElements(true).OfType <CodeInterface>().LastOrDefault(); Assert.NotNull(responseInter); }
public void AddsDefaultImports() { var model = root.AddClass(new CodeClass(root) { Name = "model", ClassKind = CodeClassKind.Model }).First(); var requestBuilder = root.AddClass(new CodeClass(root) { Name = "rb", ClassKind = CodeClassKind.RequestBuilder, }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Ruby }, root); Assert.NotEmpty(model.StartBlock.Usings); Assert.NotEmpty(requestBuilder.StartBlock.Usings); }
public void ConvertsUnionTypesToWrapper() { var model = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); var union = new CodeUnionType { Name = "union", }; union.AddType(new () { Name = "type1", }, new() { Name = "type2" }); var property = model.AddProperty(new CodeProperty { Name = "deserialize", Kind = CodePropertyKind.Custom, Type = union.Clone() as CodeTypeBase, }).First(); var method = model.AddMethod(new CodeMethod { Name = "method", ReturnType = union.Clone() as CodeTypeBase }).First(); var parameter = new CodeParameter { Name = "param1", Type = union.Clone() as CodeTypeBase }; var indexer = new CodeIndexer { Name = "idx", ReturnType = union.Clone() as CodeTypeBase, }; model.SetIndexer(indexer); method.AddParameter(parameter); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.CSharp }, root); //using CSharp so the indexer doesn't get removed Assert.True(property.Type is CodeType); Assert.True(parameter.Type is CodeType); Assert.True(method.ReturnType is CodeType); Assert.True(indexer.ReturnType is CodeType); }
public void DisambiguatePropertiesWithClassNames() { var model = root.AddClass(new CodeClass { Name = "Model", Kind = CodeClassKind.Model }).First(); var propToAdd = model.AddProperty(new CodeProperty { Name = "model", Type = new CodeType { Name = "string" } }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.CSharp }, root); Assert.Equal("model_prop", propToAdd.Name); Assert.Equal("model", propToAdd.SerializationName); }
public void TrimsCircularDiscriminatorReferences() { var modelsNS = root.AddNamespace("models"); var baseModel = modelsNS.AddClass(new CodeClass { Kind = CodeClassKind.Model, Name = "BaseModel", }).First(); baseModel.AddProperty(new CodeProperty { Name = "Discriminator", Type = new CodeType { Name = "string" }, }); var subNamespace = modelsNS.AddNamespace($"{modelsNS.Name}.sub"); var derivedModel = subNamespace.AddClass(new CodeClass { Kind = CodeClassKind.Model, Name = "DerivedModel", }).First(); derivedModel.StartBlock.Inherits = new CodeType { Name = baseModel.Name, TypeDefinition = baseModel, }; var factoryMethod = baseModel.AddMethod(new CodeMethod { Kind = CodeMethodKind.Factory, Name = "factory", ReturnType = new CodeType { Name = baseModel.Name, TypeDefinition = baseModel, }, }).First(); factoryMethod.DiscriminatorPropertyName = "Discriminator"; factoryMethod.AddDiscriminatorMapping("DerivedModel", new CodeType { Name = derivedModel.Name, TypeDefinition = derivedModel }); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.Empty(factoryMethod.DiscriminatorMappings); Assert.Empty(baseModel.Usings.Where(x => x.Name.Equals("models.sub", StringComparison.OrdinalIgnoreCase))); }
public void ReplacesDurationByNativeType() { var model = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); var method = model.AddMethod(new CodeMethod { Name = "method", ReturnType = new CodeType { Name = "TimeSpan" }, }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.TypeScript }, root); Assert.NotEmpty(model.StartBlock.Usings); Assert.Equal("Duration", method.ReturnType.Name); }
public void AliasesDuplicateUsingSymbols() { var model = graphNS.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); var modelsNS = graphNS.AddNamespace($"{graphNS.Name}.models"); var source1 = modelsNS.AddClass(new CodeClass { Name = "source", Kind = CodeClassKind.Model }).First(); var submodelsNS = modelsNS.AddNamespace($"{modelsNS.Name}.submodels"); var source2 = submodelsNS.AddClass(new CodeClass { Name = "source", Kind = CodeClassKind.Model }).First(); var using1 = new CodeUsing { Name = modelsNS.Name, Declaration = new CodeType { Name = source1.Name, TypeDefinition = source1, IsExternal = false, } }; var using2 = new CodeUsing { Name = submodelsNS.Name, Declaration = new CodeType { Name = source2.Name, TypeDefinition = source2, IsExternal = false, } }; model.AddUsing(using1); model.AddUsing(using2); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.TypeScript }, root); Assert.NotEmpty(using1.Alias); Assert.NotEmpty(using2.Alias); Assert.NotEqual(using1.Alias, using2.Alias); }
public void ReplacesDurationByNativeType() { var model = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); var method = model.AddMethod(new CodeMethod { Name = "method", ReturnType = new CodeType { Name = "TimeSpan" }, }).First(); root.AddNamespace("ApiSdk/models"); // so the interface copy refiner goes through ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.NotEmpty(model.StartBlock.Usings); Assert.Equal("ISODuration", method.ReturnType.Name); }
public void DoesNotEscapePublicPropertiesReservedKeywordsForQueryParameters() { var model = root.AddClass(new CodeClass { Name = "SomeClass", Kind = CodeClassKind.QueryParameters }).First(); var property = model.AddProperty(new CodeProperty { Name = "select", Type = new CodeType { Name = "string" }, Access = AccessModifier.Public, }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.Equal("select", property.Name); Assert.False(property.IsNameEscaped); }
public void ReplacesRequestBuilderPropertiesByMethods() { var model = root.AddClass(new CodeClass { Name = "someModel", Kind = CodeClassKind.RequestBuilder }).First(); var rb = model.AddProperty(new CodeProperty { Name = "someProperty", Kind = CodePropertyKind.RequestBuilder, }).First(); rb.Type = new CodeType { Name = "someType", }; ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.Empty(model.Properties); Assert.Single(model.Methods.Where(x => x.IsOfKind(CodeMethodKind.RequestBuilderBackwardCompatibility))); }
public void FixInheritedEntityType() { var model = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); var entity = graphNS.AddClass(new CodeClass { Name = "entity", Kind = CodeClassKind.Model }).First(); var declaration = model.StartBlock as ClassDeclaration; declaration.Inherits = new (){ Name = "entity" }; ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Ruby, ClientNamespaceName = graphNS.Name }, root); Assert.Equal("Graph::Entity", declaration.Inherits.Name); }
public void EscapesReservedKeywordsInInternalDeclaration() { var model = root.AddClass(new CodeClass { Name = "break", Kind = CodeClassKind.Model }).First(); var nUsing = new CodeUsing { Name = "some.ns", }; nUsing.Declaration = new CodeType { Name = "break", IsExternal = false, }; model.AddUsing(nUsing); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root); Assert.NotEqual("break", nUsing.Declaration.Name); Assert.Contains("escaped", nUsing.Declaration.Name); }
public void ReplacesBinaryWithNativeType() { var model = root.AddClass(new CodeClass() { Name = "model", Kind = CodeClassKind.Model }).First(); var method = model.AddMethod(new CodeMethod() { Name = "method" }).First(); method.ReturnType = new CodeType() { Name = "binary" }; ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.PHP }, root); Assert.Equal("StreamInterface", method.ReturnType.Name); }
public void AddsDefaultImports() { var model = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); var requestBuilder = root.AddClass(new CodeClass { Name = "rb", Kind = CodeClassKind.RequestBuilder, }).First(); requestBuilder.AddMethod(new CodeMethod { Name = "get", Kind = CodeMethodKind.RequestExecutor, }); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Ruby, ClientNamespaceName = graphNS.Name }, root); Assert.NotEmpty(model.StartBlock.Usings); Assert.NotEmpty(requestBuilder.StartBlock.Usings); }
public void CorrectsCoreTypes() { var model = root.AddClass(new CodeClass { Name = "rb", Kind = CodeClassKind.RequestBuilder }).First(); var property = model.AddProperty(new CodeProperty { Name = "name", Type = new CodeType { Name = "string", IsExternal = true }, Kind = CodePropertyKind.PathParameters, DefaultValue = "wrongDefaultValue" }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Ruby, ClientNamespaceName = graphNS.Name }, root); Assert.Equal("Hash.new", property.DefaultValue); }
public void EscapesPublicPropertiesReservedKeywordsForModels() { var model = root.AddClass(new CodeClass { Name = "SomeClass", Kind = CodeClassKind.Model }).First(); var property = model.AddProperty(new CodeProperty { Name = "select", Type = new CodeType { Name = "string" }, Access = AccessModifier.Public, }).First(); root.AddNamespace("ApiSdk/models"); // so the interface copy refiner goes through ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.Equal("select_escaped", property.Name); Assert.True(property.IsNameEscaped); }
public void AddsQueryParameterMapperMethod() { var model = graphNS.AddClass(new CodeClass { Name = "somemodel", Kind = CodeClassKind.QueryParameters, }).First(); model.AddProperty(new CodeProperty { Name = "Select", SerializationName = "%24select", Type = new CodeType { Name = "string" }, }); Assert.Empty(model.Methods); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.TypeScript }, graphNS); Assert.Single(model.Methods.Where(x => x.IsOfKind(CodeMethodKind.QueryParametersMapper))); }
public void ReplacesBinaryByNativeType() { var model = root.AddClass(new CodeClass(root) { Name = "model", ClassKind = CodeClassKind.Model }).First(); var method = model.AddMethod(new CodeMethod(model) { Name = "method" }).First(); method.ReturnType = new CodeType(method) { Name = "binary" }; ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root); Assert.NotEmpty(model.StartBlock.Usings); Assert.NotEqual("binary", method.ReturnType.Name); }
public void AddsListImport() { var model = root.AddClass(new CodeClass(root) { Name = "model", ClassKind = CodeClassKind.Model }).First(); model.AddProperty(new CodeProperty(model) { Name = "prop1", Type = new CodeType(model) { Name = "string", CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Complex, IsExternal = true, } }); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root); Assert.NotEmpty((model.StartBlock as CodeClass.Declaration).Usings.Where(x => "List".Equals(x.Name))); }
public void AddsEnumSetImport() { var model = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); model.AddProperty(new CodeProperty { Name = "prop1", Type = new CodeType { Name = "SomeEnum", TypeDefinition = new CodeEnum { Name = "SomeEnum", Flags = true, Parent = root, } } }); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root); Assert.NotEmpty((model.StartBlock as ClassDeclaration).Usings.Where(x => "EnumSet".Equals(x.Name))); }
public void PrefixReservedWordPropertyNamesWith() { var model = root.AddClass(new CodeClass() { Name = "userRequestBuilder", Kind = CodeClassKind.RequestBuilder }).First(); var property = model.AddProperty(new CodeProperty() { Name = "continue", Kind = CodePropertyKind.RequestBuilder, Type = new CodeType() { Name = "string" } }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.PHP }, root); Assert.Equal("EscapedContinue", property.Name); }
public void AddsInnerClasses() { var model = root.AddClass(new CodeClass(root) { Name = "model", ClassKind = CodeClassKind.Model }).First(); var method = model.AddMethod(new CodeMethod(model) { Name = "method1", ReturnType = new CodeType(model) { Name = "string", IsExternal = true } }).First(); var parameter = new CodeParameter(method) { Name = "param1", ParameterKind = CodeParameterKind.QueryParameter, Type = new CodeType(method) { Name = "SomeCustomType", ActionOf = true, TypeDefinition = new CodeClass(method) { Name = "SomeCustomType" } } }; method.Parameters.Add(parameter); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root); Assert.Equal(2, model.GetChildElements(true).Count()); }
public void AddsUsingsForErrorTypesForRequestExecutor() { var main = root.AddNamespace("main"); var models = main.AddNamespace($"{main.Name}.models"); models.AddClass(new CodeClass { Name = "somemodel", Kind = CodeClassKind.Model, }); // so move to models namespace finds the models namespace var requestBuilder = main.AddClass(new CodeClass { Name = "somerequestbuilder", Kind = CodeClassKind.RequestBuilder, }).First(); var subNS = models.AddNamespace($"{models.Name}.subns"); // otherwise the import gets trimmed var errorClass = subNS.AddClass(new CodeClass { Name = "Error4XX", Kind = CodeClassKind.Model, IsErrorDefinition = true, }).First(); var requestExecutor = requestBuilder.AddMethod(new CodeMethod { Name = "get", Kind = CodeMethodKind.RequestExecutor, ReturnType = new CodeType { Name = "string" }, }).First(); requestExecutor.AddErrorMapping("4XX", new CodeType { Name = "Error4XX", TypeDefinition = errorClass, }); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.Contains("Error4XX", requestBuilder.StartBlock.Usings.Select(x => x.Declaration?.Name)); }
public void AccessorsTargetingEscapedPropertiesAreNotEscapedThemselves() { var model = root.AddClass(new CodeClass { Name = "SomeClass", Kind = CodeClassKind.Model }).First(); model.AddProperty(new CodeProperty { Name = "select", Type = new CodeType { Name = "string" }, Access = AccessModifier.Public, Kind = CodePropertyKind.Custom, }); root.AddNamespace("ApiSdk/models"); // so the interface copy refiner goes through ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); var getter = model.Methods.First(x => x.IsOfKind(CodeMethodKind.Getter)); var setter = model.Methods.First(x => x.IsOfKind(CodeMethodKind.Setter)); var tempWriter = LanguageWriter.GetLanguageWriter(GenerationLanguage.Go, DefaultPath, DefaultName); tempWriter.SetTextWriter(tw); tempWriter.Write(getter); var result = tw.ToString(); Assert.Contains("GetSelect", result); Assert.DoesNotContain("GetSelect_escaped", result); using var tw2 = new StringWriter(); tempWriter.SetTextWriter(tw2); tempWriter.Write(setter); result = tw2.ToString(); Assert.Contains("SetSelect", result); Assert.DoesNotContain("SetSelect_escaped", result); }
public void ReplacesRequestBuilderPropertiesByMethods() { var model = root.AddClass(new CodeClass() { Name = "userRequestBuilder", Kind = CodeClassKind.RequestBuilder }).First(); var requestBuilder = model.AddProperty(new CodeProperty() { Name = "breaks", Kind = CodePropertyKind.RequestBuilder, Type = new CodeType() { Name = "string" } }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.PHP }, root); Assert.Equal("breaks", requestBuilder.Name); Assert.Equal("userRequestBuilder", model.Name); }
public void AddsUsingsForCommandTypesUsedInCommandBuilder() { var requestBuilder = root.AddClass(new CodeClass { Name = "somerequestbuilder", Kind = CodeClassKind.RequestBuilder, }).First(); var subNS = root.AddNamespace($"{root.Name}.subns"); // otherwise the import gets trimmed var commandBuilder = requestBuilder.AddMethod(new CodeMethod { Name = "GetCommand", Kind = CodeMethodKind.CommandBuilder, ReturnType = new CodeType { Name = "Command", IsExternal = true } }).First(); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Shell }, root); var declaration = requestBuilder.StartBlock as ClassDeclaration; Assert.Contains("System.CommandLine", declaration.Usings.Select(x => x.Declaration?.Name)); }
public void AddsDefaultImports() { var model = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.Model }).First(); var requestBuilder = root.AddClass(new CodeClass { Name = "rb", Kind = CodeClassKind.RequestBuilder, }).First(); requestBuilder.AddMethod(new CodeMethod { Name = "get", Kind = CodeMethodKind.RequestExecutor, ReturnType = new CodeType { Name = "string", }, }); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root); Assert.NotEmpty(model.StartBlock.Usings); Assert.NotEmpty(requestBuilder.StartBlock.Usings); }
public void AddsUsingsForDiscriminatorTypes() { var parentModel = root.AddClass(new CodeClass { Name = "parentModel", Kind = CodeClassKind.Model, }).First(); var childModel = root.AddClass(new CodeClass { Name = "childModel", Kind = CodeClassKind.Model, }).First(); (childModel.StartBlock as ClassDeclaration).Inherits = new CodeType { Name = "parentModel", TypeDefinition = parentModel, }; var factoryMethod = parentModel.AddMethod(new CodeMethod { Name = "factory", Kind = CodeMethodKind.Factory, ReturnType = new CodeType { Name = "parentModel", TypeDefinition = parentModel, }, }).First(); factoryMethod.AddDiscriminatorMapping("ns.childmodel", new CodeType { Name = "childModel", TypeDefinition = childModel, }); Assert.Empty(parentModel.StartBlock.Usings); root.AddNamespace("ApiSdk/models"); // so the interface copy refiner goes through ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); Assert.Equal(childModel, parentModel.StartBlock.Usings.First(x => x.Declaration.Name.Equals("childModel", StringComparison.OrdinalIgnoreCase)).Declaration.TypeDefinition); Assert.Null(parentModel.StartBlock.Usings.FirstOrDefault(x => x.Declaration.Name.Equals("factory", StringComparison.OrdinalIgnoreCase))); }
public void CorrectsCoreType() { var model = root.AddClass(new CodeClass() { Name = "model", Kind = CodeClassKind.Model }).First(); model.AddProperty(new CodeProperty() { Name = "core", Kind = CodePropertyKind.RequestAdapter, Type = new CodeType { Name = HttpCoreDefaultName } }, new () { Name = "someDate", Kind = CodePropertyKind.Custom, Type = new CodeType { Name = DateTimeOffsetDefaultName, } }, new () { Name = "additionalData", Kind = CodePropertyKind.AdditionalData, Type = new CodeType { Name = AddiationalDataDefaultName } }, new () { Name = "pathParameters", Kind = CodePropertyKind.PathParameters, Type = new CodeType { Name = PathParametersDefaultName }, DefaultValue = PathParametersDefaultValue }); var executorMethod = model.AddMethod(new CodeMethod { Name = "executor", Kind = CodeMethodKind.RequestExecutor, ReturnType = new CodeType { Name = "string" } }).First(); executorMethod.AddParameter(new CodeParameter { Name = "handler", Kind = CodeParameterKind.ResponseHandler, Type = new CodeType { Name = HandlerDefaultName, } }); const string serializerDefaultName = "ISerializationWriter"; var serializationMethod = model.AddMethod(new CodeMethod { Name = "seriailization", Kind = CodeMethodKind.Serializer, ReturnType = new CodeType { Name = "string" } }).First(); serializationMethod.AddParameter(new CodeParameter { Name = "handler", Kind = CodeParameterKind.Serializer, Type = new CodeType { Name = serializerDefaultName, } }); var constructorMethod = model.AddMethod(new CodeMethod { Name = "constructor", Kind = CodeMethodKind.Constructor, ReturnType = new CodeType { Name = "void" } }).First(); constructorMethod.AddParameter(new CodeParameter { Name = "pathParameters", Kind = CodeParameterKind.PathParameters, Type = new CodeType { Name = PathParametersDefaultName }, }); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.TypeScript }, root); Assert.Empty(model.Properties.Where(x => HttpCoreDefaultName.Equals(x.Type.Name))); Assert.Empty(model.Properties.Where(x => FactoryDefaultName.Equals(x.Type.Name))); Assert.Empty(model.Properties.Where(x => DateTimeOffsetDefaultName.Equals(x.Type.Name))); Assert.Empty(model.Properties.Where(x => AddiationalDataDefaultName.Equals(x.Type.Name))); Assert.Empty(model.Properties.Where(x => PathParametersDefaultName.Equals(x.Type.Name))); Assert.Empty(model.Properties.Where(x => PathParametersDefaultValue.Equals(x.DefaultValue))); Assert.Empty(model.Methods.Where(x => DeserializeDefaultName.Equals(x.ReturnType.Name))); Assert.Empty(model.Methods.SelectMany(x => x.Parameters).Where(x => HandlerDefaultName.Equals(x.Type.Name))); Assert.Empty(model.Methods.SelectMany(x => x.Parameters).Where(x => serializerDefaultName.Equals(x.Type.Name))); Assert.Single(constructorMethod.Parameters.Where(x => x.Type is CodeComposedTypeBase)); }
public void AddsMethodsOverloads() { var builder = root.AddClass(new CodeClass { Name = "model", Kind = CodeClassKind.RequestBuilder }).First(); var executor = builder.AddMethod(new CodeMethod { Name = "executor", Kind = CodeMethodKind.RequestExecutor, ReturnType = new CodeType { Name = "string" } }).First(); executor.AddParameter(new() { Name = "handler", Kind = CodeParameterKind.ResponseHandler, Type = new CodeType { Name = "string" } }, new() { Name = "config", Kind = CodeParameterKind.RequestConfiguration, Type = new CodeType { Name = "string" } }, new() { Name = "body", Kind = CodeParameterKind.RequestBody, Type = new CodeType { Name = "string" } }); var generator = builder.AddMethod(new CodeMethod { Name = "generator", Kind = CodeMethodKind.RequestGenerator, ReturnType = new CodeType { Name = "string" } }).First(); generator.AddParameter(executor.Parameters.Where(x => !x.IsOfKind(CodeParameterKind.ResponseHandler)).ToArray()); ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); var childMethods = builder.Methods; Assert.Contains(childMethods, x => x.IsOverload && x.IsOfKind(CodeMethodKind.RequestExecutor) && x.Parameters.Count() == 1); //body only Assert.Contains(childMethods, x => x.IsOverload && x.IsOfKind(CodeMethodKind.RequestGenerator) && x.Parameters.Count() == 1); //body only Assert.Contains(childMethods, x => !x.IsOverload && x.IsOfKind(CodeMethodKind.RequestExecutor) && x.Parameters.Count() == 3); // body + query + response handler Assert.Contains(childMethods, x => !x.IsOverload && x.IsOfKind(CodeMethodKind.RequestGenerator) && x.Parameters.Count() == 2); // body + query config Assert.Equal(4, childMethods.Count()); Assert.Equal(2, childMethods.Count(x => x.IsOverload)); }