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 WritesContainerCommandWithConflictingTypes()
{
method.Kind = CodeMethodKind.CommandBuilder;
method.SimpleName = "User";
// Types: A.B.T1
// A.B.C.T2
// A.B.C.D.T1
var ns1 = root.AddNamespace("Test.Name");
var ns2 = ns1.AddNamespace("Test.Name.Sub1");
var ns3 = ns2.AddNamespace("Test.Name.Sub1.Sub2");
var t1 = new CodeClass {
Name = "TestClass1", Kind = CodeClassKind.RequestBuilder
};
ns1.AddClass(t1);
var t2 = parentClass;
ns2.AddClass(t2);
var t1Sub = new CodeClass {
Name = "TestClass1", Kind = CodeClassKind.RequestBuilder
};
ns3.AddClass(t1Sub);
t1Sub.AddMethod(new CodeMethod {
Kind = CodeMethodKind.CommandBuilder, Name = "BuildTestMethod1", ReturnType = new CodeType()
});
t1Sub.AddMethod(new CodeMethod {
Kind = CodeMethodKind.CommandBuilder, Name = "BuildTestMethod2", ReturnType = new CodeType {
CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Array
}
});
method.AccessedProperty = new CodeProperty
{
Type = new CodeType
{
Name = "TestRequestBuilder",
TypeDefinition = t1Sub
}
};
AddRequestProperties();
writer.Write(method);
var result = tw.ToString();
Assert.Contains("var command = new Command(\"user\");", result);
Assert.Contains("var builder = new Test.Name.Sub1.Sub2.TestRequestBuilder", result);
Assert.Contains("command.AddCommand(builder.BuildTestMethod1());", result);
Assert.Contains("foreach (var cmd in builder.BuildTestMethod2()) {", result);
Assert.Contains("command.AddCommand(cmd);", result);
Assert.Contains("return command;", result);
}
public void OrdersWithMethodWithinClass()
{
var root = CodeNamespace.InitRootNamespace();
var comparer = new CodeElementOrderComparer();
var codeClass = new CodeClass {
Name = "Class"
};
root.AddClass(codeClass);
var method = new CodeMethod {
Name = "Method"
};
codeClass.AddMethod(method);
method.AddParameter(new CodeParameter {
Name = "param"
});
var dataSet = new List <Tuple <CodeElement, CodeElement, int> > {
new(null, null, 0),
new(null, new CodeClass(), -1),
new(new CodeClass(), null, 1),
new(new CodeUsing(), new CodeProperty(), -1000),
new(new CodeIndexer(), new CodeProperty(), 1000),
new(method, new CodeProperty(), 1101),
new(method, codeClass, -899)
};
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 void WritesRequestGeneratorBodyForScalar()
{
var configurationMock = new Mock <GenerationConfiguration>();
var refiner = new GoRefiner(configurationMock.Object);
method.Kind = CodeMethodKind.RequestGenerator;
method.HttpMethod = HttpMethod.Get;
var executor = parentClass.AddMethod(new CodeMethod {
Name = "executor",
HttpMethod = HttpMethod.Get,
Kind = CodeMethodKind.RequestExecutor,
ReturnType = new CodeType {
Name = "string",
IsExternal = true,
}
}).First();
AddRequestBodyParameters(executor);
AddRequestBodyParameters();
AddRequestProperties();
refiner.Refine(parentClass.Parent as CodeNamespace);
method.AcceptedResponseTypes.Add("application/json");
writer.Write(method);
var result = tw.ToString();
Assert.Contains($"requestInfo := {AbstractionsPackageHash}.NewRequestInformation()", result);
Assert.Contains("requestInfo.UrlTemplate = ", result);
Assert.Contains("requestInfo.PathParameters", result);
Assert.Contains("requestInfo.Headers[\"Accept\"] = \"application/json\"", result);
Assert.Contains($"Method = {AbstractionsPackageHash}.GET", result);
Assert.Contains("if c != nil", result);
Assert.Contains("requestInfo.AddRequestHeaders(", result);
Assert.Contains("if c.Q != nil", result);
Assert.Contains("requestInfo.AddQueryParameters(", result);
Assert.Contains("requestInfo.AddRequestOptions(", result);
Assert.Contains("requestInfo.SetContentFromScalar(m.requestAdapter", result);
Assert.Contains("return requestInfo, nil", result);
AssertExtensions.CurlyBracesAreClosed(result);
}
public void WritesIndexerCommands()
{
method.Kind = CodeMethodKind.CommandBuilder;
var type = new CodeClass {
Name = "TestClass", Kind = CodeClassKind.RequestBuilder
};
type.AddMethod(new CodeMethod {
Kind = CodeMethodKind.CommandBuilder, Name = "BuildTestMethod1", ReturnType = new CodeType()
});
type.AddMethod(new CodeMethod {
Kind = CodeMethodKind.CommandBuilder, Name = "BuildTestMethod2", ReturnType = new CodeType {
CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Array
}
});
type.Parent = CodeNamespace.InitRootNamespace();
type.Parent.Name = "Test.Name.Sub";
method.OriginalIndexer = new CodeIndexer {
ReturnType = new CodeType {
Name = "TestRequestBuilder",
TypeDefinition = type
}
};
AddRequestProperties();
writer.Write(method);
var result = tw.ToString();
Assert.Contains("var builder = new TestRequestBuilder", result);
Assert.Contains("var command = new Command(\"item\");", result);
Assert.Contains("command.AddCommand(builder.BuildTestMethod1());", result);
Assert.Contains("foreach (var cmd in builder.BuildTestMethod2()) {", result);
Assert.Contains("command.AddCommand(cmd);", result);
Assert.Contains("return command;", result);
}
private static void CreateCommandBuildersFromIndexers(CodeClass currentClass, IEnumerable <CodeIndexer> indexers)
{
foreach (var indexer in indexers)
{
var method = new CodeMethod
{
Name = "BuildCommand",
IsAsync = false,
Kind = CodeMethodKind.CommandBuilder,
OriginalIndexer = indexer
};
// ReturnType setter assigns the parent
method.ReturnType = CreateCommandType();
currentClass.AddMethod(method);
currentClass.RemoveChildElement(indexer);
}
}
public void WritesRootCommandWithCommandBuilderMethods()
{
method.Kind = CodeMethodKind.CommandBuilder;
method.OriginalMethod = new CodeMethod
{
Kind = CodeMethodKind.ClientConstructor
};
parentClass.AddMethod(new CodeMethod {
Name = "BuildUserCommand",
Kind = CodeMethodKind.CommandBuilder
});
writer.Write(method);
var result = tw.ToString();
Assert.Contains("var command = new RootCommand();", result);
Assert.Contains("command.AddCommand(BuildUserCommand());", result);
Assert.Contains("return command;", result);
}
public CodeMethodWriterTests()
{
writer = LanguageWriter.GetLanguageWriter(GenerationLanguage.CSharp, defaultPath, defaultName);
tw = new StringWriter();
writer.SetTextWriter(tw);
var root = CodeNamespace.InitRootNamespace();
parentClass = new CodeClass(root)
{
Name = "parentClass"
};
root.AddClass(parentClass);
method = new CodeMethod(parentClass)
{
Name = methodName,
};
method.ReturnType = new CodeType(method)
{
Name = returnTypeName
};
parentClass.AddMethod(method);
}
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);
}
private static void CreateCommandBuildersFromRequestExecutors(CodeClass currentClass, bool classHasIndexers, IEnumerable <CodeMethod> requestMethods)
{
foreach (var requestMethod in requestMethods)
{
CodeMethod clone = requestMethod.Clone() as CodeMethod;
var cmdName = clone.HttpMethod switch
{
HttpMethod.Get when classHasIndexers => "List",
HttpMethod.Post when classHasIndexers => "Create",
_ => clone.Name,
};
clone.IsAsync = false;
clone.Name = $"Build{cmdName}Command";
clone.Description = requestMethod.Description;
clone.ReturnType = CreateCommandType();
clone.Kind = CodeMethodKind.CommandBuilder;
clone.OriginalMethod = requestMethod;
clone.SimpleName = cmdName;
clone.ClearParameters();
currentClass.AddMethod(clone);
currentClass.RemoveChildElement(requestMethod);
}
}
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);
}