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));
}
