public void AddsInnerClasses()
{
var model = root.AddClass(new CodeClass {
Name = "model",
Kind = CodeClassKind.Model
}).First();
var method = model.AddMethod(new CodeMethod {
Name = "method1",
ReturnType = new CodeType {
Name = "string",
IsExternal = true
}
}).First();
var parameter = new CodeParameter {
Name = "param1",
Kind = CodeParameterKind.RequestConfiguration,
Type = new CodeType {
Name = "SomeCustomType",
ActionOf = true,
TypeDefinition = new CodeClass {
Name = "SomeCustomType"
}
}
};
method.AddParameter(parameter);
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Java
}, root);
Assert.Equal(2, model.GetChildElements(true).Count());
}
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).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,
},
IsStatic = true,
}).First();
factoryMethod.AddDiscriminatorMapping("ns.childmodel", new CodeType {
Name = "childModel",
TypeDefinition = childModel,
});
Assert.False(factoryMethod.Parent is CodeFunction);
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.TypeScript
}, root);
Assert.Equal(childModel, (factoryMethod.Parent as CodeFunction).StartBlock.Usings.First(x => x.Name.Equals("childModel", StringComparison.OrdinalIgnoreCase)).Declaration.TypeDefinition);
}
public void DoesNotEscapesReservedKeywordsForClassOrPropertyKind()
{
// Arrange
var model = root.AddClass(new CodeClass {
Name = "break", // this a keyword
Kind = CodeClassKind.Model,
}).First();
var property = model.AddProperty(new CodeProperty
{
Name = "alias",// this a keyword
Type = new CodeType
{
Name = "string"
}
}).First();
// Act
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.CSharp
}, root);
// Assert
Assert.Equal("break", model.Name);
Assert.DoesNotContain("@", model.Name); // classname will be capitalized
Assert.Equal("alias", property.Name);
Assert.DoesNotContain("@", property.Name); // classname will be capitalized
}
public void AddsUsingsForErrorTypesForRequestExecutor()
{
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 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.TypeScript
}, root);
var declaration = requestBuilder.StartBlock;
Assert.Contains("Error4XX", declaration.Usings.Select(x => x.Declaration?.Name));
}
public void AddsEnumSetImport()
{
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 = "SomeEnum",
TypeDefinition = new CodeEnum(model)
{
Name = "SomeEnum",
Flags = true,
}
}
});
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Java
}, root);
Assert.NotEmpty((model.StartBlock as CodeClass.Declaration).Usings.Where(x => "EnumSet".Equals(x.Name)));
}
public void DoesNotKeepCancellationParametersInRequestExecutors()
{
var model = root.AddClass(new CodeClass
{
Name = "model",
Kind = CodeClassKind.RequestBuilder
}).First();
var method = model.AddMethod(new CodeMethod
{
Name = "getMethod",
Kind = CodeMethodKind.RequestExecutor,
ReturnType = new CodeType
{
Name = "string"
}
}).First();
var cancellationParam = new CodeParameter
{
Name = "cancelletionToken",
Optional = true,
Kind = CodeParameterKind.Cancellation,
Description = "Cancellation token to use when cancelling requests",
Type = new CodeType {
Name = "CancelletionToken", IsExternal = true
},
};
method.AddParameter(cancellationParam);
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.TypeScript
}, root); //using CSharp so the cancelletionToken doesn't get removed
Assert.False(method.Parameters.Any());
Assert.DoesNotContain(cancellationParam, method.Parameters);
}
public void ReplacesModelsByInterfaces()
{
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 executorMethod = requestBuilder.AddMethod(new CodeMethod {
Name = "Execute",
Kind = CodeMethodKind.RequestExecutor,
ReturnType = new CodeType {
Name = model.Name,
TypeDefinition = model,
},
}).First();
var executorParameter = new CodeParameter {
Name = "requestBody",
Kind = CodeParameterKind.RequestBody,
Type = new CodeType {
Name = model.Name,
TypeDefinition = model,
},
};
executorMethod.AddParameter(executorParameter);
var property = model.AddProperty(new CodeProperty {
Name = "someProp",
Kind = CodePropertyKind.Custom,
Type = new CodeType {
Name = model.Name,
TypeDefinition = model,
},
}).First();
Assert.Empty(root.GetChildElements(true).OfType <CodeInterface>());
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Go
}, root);
Assert.Single(root.GetChildElements(true).OfType <CodeInterface>());
var inter = root.GetChildElements(true).OfType <CodeInterface>().First();
Assert.NotEqual(model.Name, inter.Name);
var propertyType = property.Type as CodeType;
Assert.NotNull(propertyType);
Assert.Equal(inter, propertyType.TypeDefinition);
var executorParameterType = executorParameter.Type as CodeType;
Assert.NotNull(executorParameterType);
Assert.Equal(inter, executorParameterType.TypeDefinition);
var executorMethodReturnType = executorMethod.ReturnType as CodeType;
Assert.NotNull(executorMethodReturnType);
Assert.Equal(inter, executorMethodReturnType.TypeDefinition);
}
public void AddStaticMethodsUsingsForDeserializer()
{
var model = graphNS.AddClass(new CodeClass {
Name = "somemodel",
Kind = CodeClassKind.Model,
IsErrorDefinition = true,
}).First();
model.AddMethod(new CodeMethod {
Name = "Deserialize",
Kind = CodeMethodKind.Deserializer,
IsAsync = false,
ReturnType = new CodeType {
Name = "void",
IsExternal = true,
},
});
var subNs = graphNS.AddNamespace($"{graphNS.Name}.subns");
var propertyModel = subNs.AddClass(new CodeClass {
Name = "somepropertyModel",
Kind = CodeClassKind.Model,
IsErrorDefinition = true,
}).First();
propertyModel.AddMethod(new CodeMethod {
Name = "factory",
Kind = CodeMethodKind.Factory,
IsAsync = false,
IsStatic = true,
ReturnType = new CodeType {
Name = "void",
IsExternal = true,
},
});
model.AddProperty(new CodeProperty {
Name = "someProperty",
Type = new CodeType {
Name = "somepropertyModel",
TypeDefinition = propertyModel,
},
});
Assert.Empty(graphNS.GetChildElements(true).OfType <CodeFunction>());
Assert.Single(model.GetChildElements(true).OfType <CodeMethod>());
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.TypeScript
}, graphNS);
Assert.Empty(model.GetChildElements(true).OfType <CodeMethod>().Where(x => x.IsOfKind(CodeMethodKind.Factory)));
Assert.Single(subNs.GetChildElements(true).OfType <CodeFunction>());
var function = subNs.GetChildElements(true).OfType <CodeFunction>().First();
Assert.Single(model.Usings.Where(x => !x.IsExternal && x.Declaration.TypeDefinition == function));
}
public void AddsErrorImportForEnums()
{
var testEnum = root.AddEnum(new CodeEnum {
Name = "TestEnum",
}).First();
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Go
}, root);
Assert.Single(testEnum.Usings.Where(x => x.Name == "errors"));
}
public void ReplacesIndexersByMethodsWithParameter()
{
var model = root.AddClass(new CodeClass(root)
{
Name = "model",
ClassKind = CodeClassKind.Model
}).First();
var requestBuilder = root.AddClass(new CodeClass(root)
{
Name = "requestBuilder",
ClassKind = CodeClassKind.Model
}).First();
requestBuilder.AddProperty(new CodeProperty(requestBuilder)
{
Name = "pathSegment",
DefaultValue = "path",
Type = new CodeType(requestBuilder)
{
Name = "string",
}
});
requestBuilder.SetIndexer(new CodeIndexer(requestBuilder)
{
Name = "idx",
ReturnType = new CodeType(requestBuilder)
{
Name = "model",
TypeDefinition = model,
},
});
var collectionRequestBuilder = root.AddClass(new CodeClass(root)
{
Name = "CollectionRequestBUilder",
}).First();
collectionRequestBuilder.AddProperty(new CodeProperty(collectionRequestBuilder)
{
Name = "collection",
Type = new CodeType(requestBuilder)
{
Name = "requestBuilder",
TypeDefinition = requestBuilder,
},
});
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Java
}, root);
Assert.Single(requestBuilder.GetChildElements(true).OfType <CodeProperty>());
Assert.Empty(requestBuilder.GetChildElements(true).OfType <CodeIndexer>());
Assert.Single(collectionRequestBuilder.GetChildElements(true).OfType <CodeMethod>().Where(x => x.IsOfKind(CodeMethodKind.IndexerBackwardCompatibility)));
Assert.Single(collectionRequestBuilder.GetChildElements(true).OfType <CodeProperty>());
}
public void RemovesPropertyRelyingOnSubModules()
{
var models = root.AddNamespace("ApiSdk.models");
var submodels = models.AddNamespace($"{models.Name}.submodels");
var propertyModel = submodels.AddClass(new CodeClass {
Name = "propertyModel",
Kind = CodeClassKind.Model
}).First();
var mainModel = models.AddClass(new CodeClass {
Name = "mainModel",
Kind = CodeClassKind.Model
}).First();
var property = mainModel.AddProperty(new CodeProperty {
Name = "property",
Type = new CodeType {
Name = "propertyModel",
TypeDefinition = propertyModel
},
Kind = CodePropertyKind.Custom
}).First();
mainModel.AddMethod(new CodeMethod {
Name = $"get{property.Name}",
Kind = CodeMethodKind.Getter,
ReturnType = new CodeType {
Name = "propertyModel",
TypeDefinition = propertyModel
},
AccessedProperty = property
});
var setter = mainModel.AddMethod(new CodeMethod {
Name = $"get{property.Name}",
Kind = CodeMethodKind.Getter,
ReturnType = new CodeType {
Name = "void",
IsExternal = true,
},
AccessedProperty = property
}).First();
setter.AddParameter(new CodeParameter {
Name = "value",
Type = new CodeType {
Name = "propertyModel",
TypeDefinition = propertyModel
}
});
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Go
}, root);
Assert.Empty(mainModel.Properties);
Assert.Empty(mainModel.Methods.Where(x => x.IsAccessor));
}
public void EscapesReservedKeywords()
{
var model = root.AddClass(new CodeClass {
Name = "break",
Kind = CodeClassKind.Model
}).First();
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.TypeScript
}, root);
Assert.NotEqual("break", model.Name);
Assert.Contains("escaped", model.Name);
}
public void FailsExceptionInheritanceOnErrorClassesWhichAlreadyInherit()
{
var model = root.AddClass(new CodeClass {
Name = "somemodel",
Kind = CodeClassKind.Model,
IsErrorDefinition = true,
}).First();
model.StartBlock.Inherits = new CodeType {
Name = "SomeOtherModel"
};
Assert.Throws <InvalidOperationException>(() => ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Go
}, root));
}
public void AddsUsingsForFactoryMethods()
{
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.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,
});
var requestBuilderClass = root.AddClass(new CodeClass {
Name = "somerequestbuilder",
Kind = CodeClassKind.RequestBuilder,
}).First();
var requestExecutor = requestBuilderClass.AddMethod(new CodeMethod {
Name = "get",
Kind = CodeMethodKind.RequestExecutor,
ReturnType = new CodeType {
Name = parentModel.Name,
TypeDefinition = parentModel,
},
}).First();
Assert.Empty(requestBuilderClass.StartBlock.Usings);
root.AddNamespace("ApiSdk/models"); // so the interface copy refiner goes through
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Go
}, root);
Assert.Equal(factoryMethod, requestBuilderClass.StartBlock.Usings.First(x => x.Declaration.Name.Equals("factory", StringComparison.OrdinalIgnoreCase)).Declaration.TypeDefinition);
}
public void AddInheritedAndMethodTypesImports()
{
var model = root.AddClass(new CodeClass {
Name = "model",
Kind = CodeClassKind.Model
}).First();
var declaration = model.StartBlock as ClassDeclaration;
declaration.Inherits = new (){
Name = "someInterface"
};
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Ruby, ClientNamespaceName = graphNS.Name
}, root);
Assert.Equal("someInterface", declaration.Usings.First(usingDef => usingDef.Declaration != null).Declaration?.Name);
}
public void AddsExceptionInheritanceOnErrorClasses()
{
var model = root.AddClass(new CodeClass {
Name = "somemodel",
Kind = CodeClassKind.Model,
IsErrorDefinition = true,
}).First();
root.AddNamespace("ApiSdk/models"); // so the interface copy refiner goes through
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Go
}, root);
Assert.Contains("ApiError", model.StartBlock.Usings.Select(x => x.Name));
Assert.Equal("ApiError", model.StartBlock.Inherits.Name);
}
public void AddsExceptionInheritanceOnErrorClasses()
{
var model = root.AddClass(new CodeClass {
Name = "somemodel",
Kind = CodeClassKind.Model,
IsErrorDefinition = true,
}).First();
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.TypeScript
}, root);
var declaration = model.StartBlock;
Assert.Contains("ApiError", declaration.Usings.Select(x => x.Name));
Assert.Equal("ApiError", declaration.Inherits.Name);
}
public void MovesClassesWithNamespaceNamesUnderNamespace()
{
var graphNS = root.AddNamespace("graph");
var modelNS = graphNS.AddNamespace("graph.model");
var model = graphNS.AddClass(new CodeClass {
Name = "model",
Kind = CodeClassKind.Model
}).First();
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.CSharp
}, root);
Assert.Single(root.GetChildElements(true));
Assert.Single(graphNS.GetChildElements(true));
Assert.Single(modelNS.GetChildElements(true));
Assert.Equal(modelNS, model.Parent);
}
public void ReplacesReservedEnumOptions()
{
var model = root.AddEnum(new CodeEnum
{
Name = "model",
}).First();
var option = new CodeEnumOption {
Name = "break", // this a keyword
};
model.AddOption(option);
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.Java
}, root);
Assert.Equal("break_escaped", option.Name);
Assert.Equal("break", option.SerializationName);
}
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();
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.PHP
}, root);
Assert.NotEmpty(model.StartBlock.Usings);
}
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 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 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 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 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();
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 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 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)));
}
