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