public void EscapesReservedKeywords()
{
var model = root.AddClass(new CodeClass(root)
{
Name = "break",
ClassKind = CodeClassKind.Model
}).First();
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.CSharp
}, root);
Assert.NotEqual("break", model.Name);
Assert.Contains("@", model.Name);
}
public ShellCodeClass AddClass(string Name, object Position, object Bases, object ImplementedInterfaces,
vsCMAccess Access)
{
return
(new ShellCodeClass(
_namespace.AddClass(Name, Position, Bases, ImplementedInterfaces, Access) as CodeClass2));
}
public CodeMethodWriterTests()
{
languageWriter = LanguageWriter.GetLanguageWriter(GenerationLanguage.PHP, DefaultPath, DefaultName);
stringWriter = new StringWriter();
languageWriter.SetTextWriter(stringWriter);
root = CodeNamespace.InitRootNamespace();
root.Name = "Microsoft\\Graph";
_codeMethodWriter = new CodeMethodWriter(new PhpConventionService());
parentClass = new CodeClass()
{
Name = "parentClass"
};
root.AddClass(parentClass);
method = new CodeMethod()
{
Name = MethodName,
IsAsync = true,
Description = "This is a very good method to try all the good things"
};
method.ReturnType = new CodeType()
{
Name = ReturnTypeName
};
_refiner = new PhpRefiner(new GenerationConfiguration {
Language = GenerationLanguage.PHP
});
parentClass.AddMethod(method);
}
public CodeMethodWriterTests()
{
writer = LanguageWriter.GetLanguageWriter(GenerationLanguage.Ruby, DefaultPath, DefaultName);
tw = new StringWriter();
writer.SetTextWriter(tw);
root = CodeNamespace.InitRootNamespace();
parentClass = new CodeClass {
Name = "parentClass"
};
root.AddClass(parentClass);
method = new CodeMethod {
Name = MethodName,
};
method.ReturnType = new CodeType {
Name = ReturnTypeName
};
voidMethod = new CodeMethod {
Name = MethodName,
};
voidMethod.ReturnType = new CodeType {
Name = "void"
};
parentClass.AddMethod(voidMethod);
parentClass.AddMethod(method);
}
public void AddsExceptionInheritanceOnErrorClasses()
{
var model = root.AddClass(new CodeClass {
Name = "somemodel",
Kind = CodeClassKind.Model,
IsErrorDefinition = true,
}).First();
ILanguageRefiner.Refine(new GenerationConfiguration {
Language = GenerationLanguage.CSharp
}, root);
var declaration = model.StartBlock as ClassDeclaration;
Assert.Contains("ApiException", declaration.Usings.Select(x => x.Name));
Assert.Equal("ApiException", declaration.Inherits.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.Ruby
}, root); //using CSharp so the cancelletionToken doesn't get removed
Assert.False(method.Parameters.Any());
Assert.DoesNotContain(cancellationParam, method.Parameters);
}
protected override object NewClass(NewCodeElementItemParams newItemParams, string path)
{
return(_namespace.AddClass(path,
newItemParams.Position,
newItemParams.Bases.ToCSVDTEParameter(),
newItemParams.ImplementedInterfaces.ToCSVDTEParameter(),
newItemParams.AccessKind
));
}
public TypeScriptLanguageRefinerTests()
{
root = CodeNamespace.InitRootNamespace();
graphNS = root.AddNamespace("graph");
parentClass = new () {
Name = "parentClass"
};
graphNS.AddClass(parentClass);
}
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 WritesModelFactoryBody()
{
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,
},
IsStatic = true,
}).First();
factoryMethod.AddDiscriminatorMapping("ns.childmodel", new CodeType {
Name = "childModel",
TypeDefinition = childModel,
});
factoryMethod.DiscriminatorPropertyName = "@odata.type";
factoryMethod.AddParameter(new CodeParameter {
Name = "parseNode",
Kind = CodeParameterKind.ParseNode,
Type = new CodeType {
Name = "ParseNode",
TypeDefinition = new CodeClass {
Name = "ParseNode",
},
IsExternal = true,
},
Optional = false,
});
var factoryFunction = root.AddFunction(new CodeFunction(factoryMethod)).First();
writer.Write(factoryFunction);
var result = tw.ToString();
Assert.Contains("const mappingValueNode = parseNode.getChildNode(\"@odata.type\")", result);
Assert.Contains("if (mappingValueNode) {", result);
Assert.Contains("const mappingValue = mappingValueNode.getStringValue()", result);
Assert.Contains("if (mappingValue) {", result);
Assert.Contains("switch (mappingValue) {", result);
Assert.Contains("case \"ns.childmodel\":", result);
Assert.Contains("return new ChildModel();", result);
Assert.Contains("return new ParentModel();", result);
AssertExtensions.CurlyBracesAreClosed(result, 1);
}
private static CodeClass GetParentClassInStaticContext()
{
CodeClass parent = new CodeClass()
{
Name = "parent"
};
CodeNamespace rootNamespace = CodeNamespace.InitRootNamespace();
rootNamespace.AddClass(parent);
return(parent);
}
public CodeClassDeclarationWriterTests()
{
codeElementWriter = new CodeClassDeclarationWriter(new GoConventionService());
writer = LanguageWriter.GetLanguageWriter(GenerationLanguage.Go, DefaultPath, DefaultName);
tw = new StringWriter();
writer.SetTextWriter(tw);
root = CodeNamespace.InitRootNamespace();
parentClass = new () {
Name = "parentClass"
};
root.AddClass(parentClass);
}
/// <summary>
/// Adds a class to the <see cref="CodeNamespace"/> and supports adding a partial class.
/// </summary>
/// <param name="codeNamespace"><see cref="CodeNamespace"/> instance.</param>
/// <param name="name">Name of the class.</param>
/// <param name="baseName">Name of the base class. Null indicates no base class.</param>
/// <param name="access">Class access.</param>
/// <param name="classKind">Class kind.</param>
/// <returns><see cref="CodeClass"/> instance.</returns>
internal static CodeClass AddClassWithPartialSupport(this CodeNamespace codeNamespace, string name, string baseName,
vsCMAccess access, vsCMClassKind classKind)
{
// Workaround to support existing partial class, set name after.
CodeClass codeClass = codeNamespace.AddClass(Resources.TempClassName, AppConstants.PLACE_AT_THE_END, baseName, null, access);
(codeClass as CodeClass2).ClassKind = classKind;
codeClass.Name = name;
return(codeClass);
}
public CodePropertyWriterTests()
{
stringWriter = new StringWriter();
languageWriter = LanguageWriter.GetLanguageWriter(GenerationLanguage.PHP, DefaultPath, DefaultName);
languageWriter.SetTextWriter(stringWriter);
parentClass = new CodeClass()
{
Name = "ParentClass", Description = "This is an amazing class", Kind = CodeClassKind.Model
};
root.AddClass(parentClass);
_refiner = new PhpRefiner(new() { Language = GenerationLanguage.PHP });
propertyWriter = new CodePropertyWriter(new PhpConventionService());
}
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)));
}
/// <summary>
/// Finds the or create class element.
/// </summary>
/// <param name="cn">The cn.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
public static CodeClass2 FindOrCreateClassElement(CodeNamespace cn, string name)
{
foreach (CodeElement ce in cn.Members)
{
if (ce is CodeClass2 && ce.Name == name)
{
return((CodeClass2)ce);
}
}
return
((CodeClass2)
cn.AddClass(name, 0 /* au debut */, null /*classes de bases*/, null /*interfaces*/,
vsCMAccess.vsCMAccessPublic));
}
public CodeMethodWriterTests()
{
writer = LanguageWriter.GetLanguageWriter(GenerationLanguage.CSharp, DefaultPath, DefaultName);
tw = new StringWriter();
writer.SetTextWriter(tw);
root = CodeNamespace.InitRootNamespace();
parentClass = new CodeClass {
Name = "parentClass"
};
root.AddClass(parentClass);
method = new CodeMethod {
Name = MethodName,
};
var model = root.AddClass(new CodeClass {
Name = ReturnTypeName,
Kind = CodeClassKind.Model
}).First();
method.ReturnType = new CodeType {
Name = ReturnTypeName,
TypeDefinition = model,
};
parentClass.AddMethod(method);
}
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));
}
private void AddRequestBodyParameters(bool useComplexTypeForBody = false)
{
var stringType = new CodeType {
Name = "string",
};
var requestConfigClass = parentClass.AddInnerClass(new CodeClass {
Name = "RequestConfig",
Kind = CodeClassKind.RequestConfiguration,
}).First();
requestConfigClass.AddProperty(new() {
Name = "h",
Kind = CodePropertyKind.Headers,
Type = stringType,
},
new () {
Name = "q",
Kind = CodePropertyKind.QueryParameters,
Type = stringType,
},
new () {
Name = "o",
Kind = CodePropertyKind.Options,
Type = stringType,
});
method.AddParameter(new CodeParameter {
Name = "b",
Kind = CodeParameterKind.RequestBody,
Type = useComplexTypeForBody ? new CodeType {
Name = "SomeComplexTypeForRequestBody",
TypeDefinition = root.AddClass(new CodeClass {
Name = "SomeComplexTypeForRequestBody",
Kind = CodeClassKind.Model,
}).First(),
} : stringType,
});
method.AddParameter(new CodeParameter {
Name = "c",
Kind = CodeParameterKind.RequestConfiguration,
Type = new CodeType {
Name = "RequestConfig",
TypeDefinition = requestConfigClass,
ActionOf = true,
},
Optional = true,
});
method.AddParameter(new CodeParameter {
Name = "r",
Kind = CodeParameterKind.ResponseHandler,
Type = stringType,
});
}
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 ReplacesImportsSubNamespace()
{
var rootNS = parentClass.Parent as CodeNamespace;
rootNS.RemoveChildElement(parentClass);
graphNS.AddClass(parentClass);
var declaration = parentClass.StartBlock as CodeClass.Declaration;
var subNS = graphNS.AddNamespace($"{graphNS.Name}.messages");
var messageClassDef = new CodeClass(subNS)
{
Name = "Message",
};
declaration.Usings.Add(new (parentClass) {
Name = "graph",
Declaration = new(parentClass) {
Name = "Message",
TypeDefinition = messageClassDef,
}
});
/// <summary>
/// Get the specified class from the given namespace. Creates new class if no exists.
/// </summary>
/// <param name="p_fcm"></param>
/// <param name="p_testingNameSpace"></param>
/// <param name="p_className"></param>
/// <returns></returns>
private static CodeClass2 GetClass(FileCodeModel2 p_fcm, CodeNamespace p_testingNameSpace, string p_className)
{
CodeClass2 securedClass = null;
foreach (CodeElement2 codeElement in p_fcm.CodeElements)
{
securedClass = FindClassRecursive(codeElement, p_className);
if (securedClass != null)
{
break;
}
}
if (securedClass == null)
{
// Add a class to the namespace.
securedClass = (CodeClass2)p_testingNameSpace.AddClass(p_className, -1, null, null, vsCMAccess.vsCMAccessPublic);
securedClass.DataTypeKind = vsCMDataTypeKind.vsCMDataTypeKindPartial;
securedClass.AddAttribute("TestClass", string.Empty);
}
return(securedClass);
}
// add a class to the given namespace
private void AddClassToNamespace(CodeNamespace ns)
{
// add a class
CodeClass chess = (CodeClass)ns.AddClass("Chess", -1, null, null, vsCMAccess.vsCMAccessPublic);
// add a function with a parameter and a comment
CodeFunction move = (CodeFunction)chess.AddFunction("Move", vsCMFunction.vsCMFunctionFunction, "int", -1, vsCMAccess.vsCMAccessPublic, null);
move.AddParameter("IsOK", "bool", -1);
move.Comment = "This is the move function";
// add some text to the body of the function
EditPoint editPoint = (EditPoint)move.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
editPoint.Indent(null, 0);
editPoint.Insert("int a = 1;");
editPoint.Insert(Environment.NewLine);
editPoint.Indent(null, 3);
editPoint.Insert("int b = 3;");
editPoint.Insert(Environment.NewLine);
editPoint.Indent(null, 3);
editPoint.Insert("return a + b; //");
}
public void EscapesReservedKeywordsInInternalDeclaration()
{
var model = root.AddClass(new CodeClass(root)
{
Name = "break",
ClassKind = CodeClassKind.Model
}).First();
var nUsing = new CodeUsing(model)
{
Name = "some.ns",
};
nUsing.Declaration = new CodeType(nUsing)
{
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);
}
private void AddSerializationProperties()
{
var addData = parentClass.AddProperty(new CodeProperty {
Name = "additionalData",
Kind = CodePropertyKind.AdditionalData,
}).First();
addData.Type = new CodeType {
Name = "string"
};
var dummyProp = parentClass.AddProperty(new CodeProperty {
Name = "dummyProp",
}).First();
dummyProp.Type = new CodeType {
Name = "string"
};
var dummyCollectionProp = parentClass.AddProperty(new CodeProperty {
Name = "dummyColl",
}).First();
dummyCollectionProp.Type = new CodeType {
Name = "string",
CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Array,
};
var dummyComplexCollection = parentClass.AddProperty(new CodeProperty {
Name = "dummyComplexColl"
}).First();
var complexTypeClass = root.AddClass(new CodeClass
{
Name = "SomeComplexType"
}).First();
dummyComplexCollection.Type = new CodeType {
Name = "Complex",
CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Array,
TypeDefinition = complexTypeClass
};
var dummyEnumProp = parentClass.AddProperty(new CodeProperty {
Name = "dummyEnumCollection",
}).First();
var enumDefinition = root.AddEnum(new CodeEnum
{
Name = "EnumType"
}).First();
dummyEnumProp.Type = new CodeType {
Name = "SomeEnum",
TypeDefinition = enumDefinition
};
parentClass.AddProperty(new CodeProperty {
Name = "definedInParent",
Type = new CodeType {
Name = "string"
},
OriginalPropertyFromBaseType = new CodeProperty {
Name = "definedInParent",
Type = new CodeType {
Name = "string"
}
}
});
}
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 WriteRequestExecutor()
{
CodeProperty[] properties =
{
new CodeProperty {
Kind = CodePropertyKind.RequestAdapter, Name = "requestAdapter"
},
new CodeProperty {
Kind = CodePropertyKind.UrlTemplate, Name = "urlTemplate"
},
new CodeProperty {
Kind = CodePropertyKind.PathParameters, Name = "pathParameters"
},
};
parentClass.AddProperty(properties);
var codeMethod = new CodeMethod()
{
Name = "post",
HttpMethod = HttpMethod.Post,
ReturnType = new CodeType()
{
IsExternal = true,
Name = "StreamInterface"
},
Description = "This will send a POST request",
Kind = CodeMethodKind.RequestExecutor
};
codeMethod.AddParameter(new CodeParameter
{
Name = "ResponseHandler",
Kind = CodeParameterKind.ResponseHandler,
Optional = true,
Type = new CodeType
{
Name = "ResponseHandler",
IsNullable = true
}
});
var codeMethodRequestGenerator = new CodeMethod()
{
Kind = CodeMethodKind.RequestGenerator,
HttpMethod = HttpMethod.Post,
Name = "createPostRequestInformation",
ReturnType = new CodeType()
{
Name = "RequestInformation"
}
};
parentClass.AddMethod(codeMethod);
parentClass.AddMethod(codeMethodRequestGenerator);
var error4XX = root.AddClass(new CodeClass {
Name = "Error4XX",
}).First();
var error5XX = root.AddClass(new CodeClass {
Name = "Error5XX",
}).First();
var error401 = root.AddClass(new CodeClass {
Name = "Error401",
}).First();
codeMethod.AddErrorMapping("4XX", new CodeType {
Name = "Error4XX", TypeDefinition = error4XX
});
codeMethod.AddErrorMapping("5XX", new CodeType {
Name = "Error5XX", TypeDefinition = error5XX
});
codeMethod.AddErrorMapping("403", new CodeType {
Name = "Error403", TypeDefinition = error401
});
_codeMethodWriter.WriteCodeElement(codeMethod, languageWriter);
var result = stringWriter.ToString();
Assert.Contains("Promise", result);
Assert.Contains("$requestInfo = $this->createPostRequestInformation();", result);
Assert.Contains("RejectedPromise", result);
Assert.Contains("catch(Exception $ex)", result);
Assert.Contains("'403' => array(Error403::class, 'createFromDiscriminatorValue')", result);
Assert.Contains("return $this->requestAdapter->sendPrimitiveAsync($requestInfo, StreamInterface::class, $responseHandler, $errorMappings);", result);
}
public void WritesExecutableCommandForPagedGetRequestModel()
{
method.Kind = CodeMethodKind.CommandBuilder;
method.Description = "Test description";
method.SimpleName = "User";
method.HttpMethod = HttpMethod.Get;
var userClass = root.AddClass(new CodeClass
{
Name = "User",
Kind = CodeClassKind.Model
}).First();
var stringType = new CodeType
{
Name = "user",
TypeDefinition = userClass,
};
var generatorMethod = new CodeMethod
{
Kind = CodeMethodKind.RequestGenerator,
Name = "CreateGetRequestInformation",
HttpMethod = method.HttpMethod
};
method.OriginalMethod = new CodeMethod
{
Kind = CodeMethodKind.RequestExecutor,
HttpMethod = method.HttpMethod,
ReturnType = stringType,
Parent = method.Parent,
PagingInformation = new()
{
NextLinkName = "nextLink",
ItemName = "item"
},
};
var codeClass = method.Parent as CodeClass;
codeClass.AddMethod(generatorMethod);
AddRequestProperties();
AddRequestBodyParameters(method.OriginalMethod);
AddPathQueryAndHeaderParameters(generatorMethod);
writer.Write(method);
var result = tw.ToString();
Assert.Contains("var command = new Command(\"user\");", result);
Assert.Contains("command.Description = \"Test description\";", result);
Assert.Contains("var qOption = new Option<string>(\"-q\", getDefaultValue: ()=> \"test\", description: \"The q option\")", result);
Assert.Contains("qOption.IsRequired = false;", result);
Assert.Contains("var jsonNoIndentOption = new Option<bool>(\"--json-no-indent\", r => {", result);
Assert.Contains("var allOption = new Option<bool>(\"--all\")", result);
Assert.Contains("command.AddOption(qOption);", result);
Assert.Contains("command.AddOption(jsonNoIndentOption);", result);
Assert.Contains("command.AddOption(outputOption);", result);
Assert.Contains("command.AddOption(allOption);", result);
Assert.Contains("command.SetHandler(async (invocationContext) => {", result);
Assert.Contains("var q = invocationContext.ParseResult.GetValueForOption(qOption);", result);
Assert.Contains("var all = invocationContext.ParseResult.GetValueForOption(allOption)", result);
Assert.Contains("var requestInfo = CreateGetRequestInformation", result);
Assert.Contains("requestInfo.PathParameters.Add(\"test%2Dpath\", testPath);", result);
Assert.Contains("var pagingData = new PageLinkData(requestInfo, null, itemName: \"item\", nextLinkName: \"nextLink\");", result);
Assert.Contains("var pageResponse = await pagingService.GetPagedDataAsync((info, handler, token) => RequestAdapter.SendNoContentAsync(info, cancellationToken: token, responseHandler: handler), pagingData, all, cancellationToken);", result);
Assert.Contains("formatterOptions = output.GetOutputFormatterOptions(new FormatterOptionsModel(!jsonNoIndent));", result);
Assert.Contains("IOutputFormatter? formatter = null;", result);
Assert.Contains("if (pageResponse?.StatusCode >= 200 && pageResponse?.StatusCode < 300) {", result);
Assert.Contains("formatter = outputFormatterFactory.GetFormatter(output);", result);
Assert.Contains("response = await outputFilter?.FilterOutputAsync(response, query, cancellationToken)", result);
Assert.Contains("formatter = outputFormatterFactory.GetFormatter(FormatterType.TEXT);", result);
Assert.Contains("await formatter.WriteOutputAsync(response, formatterOptions, cancellationToken);", result);
Assert.Contains("});", result);
Assert.Contains("return command;", result);
}
