From 4292b8503684946fe19bd7830e083b3155c161cc Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Tue, 15 Nov 2022 14:13:17 -0800 Subject: [PATCH 01/18] remove parent name prefix from inner classes --- src/Kiota.Builder/Refiners/JavaRefiner.cs | 33 +++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/src/Kiota.Builder/Refiners/JavaRefiner.cs b/src/Kiota.Builder/Refiners/JavaRefiner.cs index 0ac67cc55e..bd9f7a5573 100644 --- a/src/Kiota.Builder/Refiners/JavaRefiner.cs +++ b/src/Kiota.Builder/Refiners/JavaRefiner.cs @@ -18,6 +18,7 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance cancellationToken.ThrowIfCancellationRequested(); LowerCaseNamespaceNames(generatedCode); AddInnerClasses(generatedCode, false, string.Empty); + RemoveParentNamePrefixFromInnerClasses(generatedCode); InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(generatedCode); ReplaceIndexersByMethodsWithParameter(generatedCode, generatedCode, true); cancellationToken.ThrowIfCancellationRequested(); @@ -299,6 +300,38 @@ private void InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(C CrawlTree(currentElement, InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors); } + private static void RemoveParentNamePrefixFromInnerClasses(CodeElement currentElement){ + if(currentElement is CodeClass currentClass) { + var parentNamespace = currentClass.GetImmediateParentOfType(); + var innerClasses = currentClass + .Methods + .SelectMany(static x => x.Parameters) + .Where(static x => x.Type.ActionOf && x.IsOfKind(CodeParameterKind.RequestConfiguration)) + .SelectMany(static x => x.Type.AllTypes) + .Select(static x => x.TypeDefinition) + .OfType(); + + // ensure we do not miss out the types present in request configuration objects i.e. the query parameters + var nestedQueryParameters = innerClasses + .SelectMany(static x => x.Properties) + .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters)) + .SelectMany(static x => x.Type.AllTypes) + .Select(static x => x.TypeDefinition) + .OfType(); + + var nestedClasses = new List(); + nestedClasses.AddRange(innerClasses); + nestedClasses.AddRange(nestedQueryParameters); + + foreach(var innerClass in nestedClasses) { + if(innerClass.Name.StartsWith(currentClass.Name, StringComparison.OrdinalIgnoreCase)){ + innerClass.Name = innerClass.Name[currentClass.Name.Length..]; + } + } + } + CrawlTree(currentElement, x => RemoveParentNamePrefixFromInnerClasses(x)); + } + // Namespaces in Java by convention are all lower case, like: // com.microsoft.kiota.serialization private static void LowerCaseNamespaceNames(CodeElement currentElement) { From d6b645cb2e298eae3ecc13c9f6a32fd6f5bb2f83 Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Wed, 16 Nov 2022 16:01:26 -0800 Subject: [PATCH 02/18] Config/query class refrences match new name --- src/Kiota.Builder/Refiners/JavaRefiner.cs | 55 ++++++++++++++++++----- 1 file changed, 43 insertions(+), 12 deletions(-) diff --git a/src/Kiota.Builder/Refiners/JavaRefiner.cs b/src/Kiota.Builder/Refiners/JavaRefiner.cs index bd9f7a5573..21af5c29c7 100644 --- a/src/Kiota.Builder/Refiners/JavaRefiner.cs +++ b/src/Kiota.Builder/Refiners/JavaRefiner.cs @@ -18,7 +18,7 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance cancellationToken.ThrowIfCancellationRequested(); LowerCaseNamespaceNames(generatedCode); AddInnerClasses(generatedCode, false, string.Empty); - RemoveParentNamePrefixFromInnerClasses(generatedCode); + RemoveClassNamePrefixFromNestedClasses(generatedCode); InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(generatedCode); ReplaceIndexersByMethodsWithParameter(generatedCode, generatedCode, true); cancellationToken.ThrowIfCancellationRequested(); @@ -299,10 +299,9 @@ private void InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(C CrawlTree(currentElement, InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors); } - - private static void RemoveParentNamePrefixFromInnerClasses(CodeElement currentElement){ + private static void RemoveClassNamePrefixFromNestedClasses(CodeElement currentElement) { if(currentElement is CodeClass currentClass) { - var parentNamespace = currentClass.GetImmediateParentOfType(); + var prefix = currentClass.Name; var innerClasses = currentClass .Methods .SelectMany(static x => x.Parameters) @@ -322,18 +321,50 @@ private static void RemoveParentNamePrefixFromInnerClasses(CodeElement currentEl var nestedClasses = new List(); nestedClasses.AddRange(innerClasses); nestedClasses.AddRange(nestedQueryParameters); - + foreach(var innerClass in nestedClasses) { - if(innerClass.Name.StartsWith(currentClass.Name, StringComparison.OrdinalIgnoreCase)){ - innerClass.Name = innerClass.Name[currentClass.Name.Length..]; - } + if(innerClass.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) + innerClass.Name = innerClass.Name[prefix.Length..]; + + if(innerClass.IsOfKind(CodeClassKind.RequestConfiguration)) + RemovePrefixFromQueryProperties(innerClass, prefix); + } + RemovePrefixFromRequestConfigParameters(currentClass, prefix); + } + CrawlTree(currentElement, x => RemoveClassNamePrefixFromNestedClasses(x)); + } + private static void RemovePrefixFromQueryProperties(CodeElement currentElement, String prefix) { + if(currentElement is CodeClass currentClass) { + var queryProperty = currentClass + .Properties + .Where(static x=> x.IsOfKind(CodePropertyKind.QueryParameters)) + .Select(static x => x.Type) + .OfType(); + + foreach(var property in queryProperty) { + if(property.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) + property.Name = property.Name[prefix.Length..]; + } + } + } + private static void RemovePrefixFromRequestConfigParameters(CodeElement currentElement, String prefix) { + if(currentElement is CodeClass currentClass) { + var parameters = currentClass + .Methods + .SelectMany(static x => x.Parameters) + .Where(static x => x.Type.ActionOf && x.IsOfKind(CodeParameterKind.RequestConfiguration)) + .Select(static x=> x.Type) + .OfType(); + + var paramList = new List(); + paramList.AddRange(parameters); + + foreach(var parameter in paramList ) { + if(parameter.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) + parameter.Name = parameter.Name[prefix.Length..]; } } - CrawlTree(currentElement, x => RemoveParentNamePrefixFromInnerClasses(x)); } - - // Namespaces in Java by convention are all lower case, like: - // com.microsoft.kiota.serialization private static void LowerCaseNamespaceNames(CodeElement currentElement) { if (currentElement is CodeNamespace codeNamespace) { From a000107c38d726ac8767ba362816803253c1081f Mon Sep 17 00:00:00 2001 From: Vincent Biret Date: Thu, 17 Nov 2022 09:03:19 -0500 Subject: [PATCH 03/18] - removes add inner classes that noops with default settings Signed-off-by: Vincent Biret --- src/Kiota.Builder/KiotaBuilder.cs | 2 +- src/Kiota.Builder/Refiners/CSharpRefiner.cs | 1 - src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs | 2 +- src/Kiota.Builder/Refiners/GoRefiner.cs | 3 +-- src/Kiota.Builder/Refiners/JavaRefiner.cs | 1 - src/Kiota.Builder/Refiners/ShellRefiner.cs | 1 - 6 files changed, 3 insertions(+), 7 deletions(-) diff --git a/src/Kiota.Builder/KiotaBuilder.cs b/src/Kiota.Builder/KiotaBuilder.cs index 8db6301620..c4a209c5ed 100644 --- a/src/Kiota.Builder/KiotaBuilder.cs +++ b/src/Kiota.Builder/KiotaBuilder.cs @@ -1412,7 +1412,7 @@ internal static void AddSerializationMembers(CodeClass model, bool includeAdditi } private CodeClass CreateOperationParameterClass(OpenApiUrlTreeNode node, OperationType operationType, OpenApiOperation operation, CodeClass parentClass) { - var parameters = node.PathItems[Constants.DefaultOpenApiLabel].Parameters.Union(operation.Parameters).Where(p => p.In == ParameterLocation.Query); + var parameters = node.PathItems[Constants.DefaultOpenApiLabel].Parameters.Union(operation.Parameters).Where(static p => p.In == ParameterLocation.Query); if(parameters.Any()) { var parameterClass = parentClass.AddInnerClass(new CodeClass { diff --git a/src/Kiota.Builder/Refiners/CSharpRefiner.cs b/src/Kiota.Builder/Refiners/CSharpRefiner.cs index 171a257766..0c13b12bb9 100644 --- a/src/Kiota.Builder/Refiners/CSharpRefiner.cs +++ b/src/Kiota.Builder/Refiners/CSharpRefiner.cs @@ -25,7 +25,6 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance AddRawUrlConstructorOverload(generatedCode); AddPropertiesAndMethodTypesImports(generatedCode, false, false, false); AddAsyncSuffix(generatedCode); - AddInnerClasses(generatedCode, false, string.Empty); cancellationToken.ThrowIfCancellationRequested(); AddParsableImplementsForModelClasses(generatedCode, "IParsable"); CapitalizeNamespacesFirstLetters(generatedCode); diff --git a/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs b/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs index cdd1a40eb8..4a2fdb83cb 100644 --- a/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs +++ b/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs @@ -475,7 +475,7 @@ internal void DisableActionOf(CodeElement current, params CodeParameterKind[] ki CrawlTree(current, x => DisableActionOf(x, kinds)); } internal void AddInnerClasses(CodeElement current, bool prefixClassNameWithParentName, string queryParametersBaseClassName = "", bool addToParentNamespace = false) { - if(current is CodeClass currentClass) { + if(current is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.RequestBuilder)) { var parentNamespace = currentClass.GetImmediateParentOfType(); var innerClasses = currentClass .Methods diff --git a/src/Kiota.Builder/Refiners/GoRefiner.cs b/src/Kiota.Builder/Refiners/GoRefiner.cs index 9fa5cf728c..19914482b0 100644 --- a/src/Kiota.Builder/Refiners/GoRefiner.cs +++ b/src/Kiota.Builder/Refiners/GoRefiner.cs @@ -20,8 +20,7 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance cancellationToken.ThrowIfCancellationRequested(); AddInnerClasses( generatedCode, - true, - null); + true); ReplaceIndexersByMethodsWithParameter( generatedCode, generatedCode, diff --git a/src/Kiota.Builder/Refiners/JavaRefiner.cs b/src/Kiota.Builder/Refiners/JavaRefiner.cs index 21af5c29c7..6f80442e4f 100644 --- a/src/Kiota.Builder/Refiners/JavaRefiner.cs +++ b/src/Kiota.Builder/Refiners/JavaRefiner.cs @@ -17,7 +17,6 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance return Task.Run(() => { cancellationToken.ThrowIfCancellationRequested(); LowerCaseNamespaceNames(generatedCode); - AddInnerClasses(generatedCode, false, string.Empty); RemoveClassNamePrefixFromNestedClasses(generatedCode); InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(generatedCode); ReplaceIndexersByMethodsWithParameter(generatedCode, generatedCode, true); diff --git a/src/Kiota.Builder/Refiners/ShellRefiner.cs b/src/Kiota.Builder/Refiners/ShellRefiner.cs index 8d5a48bf82..761f7adffd 100644 --- a/src/Kiota.Builder/Refiners/ShellRefiner.cs +++ b/src/Kiota.Builder/Refiners/ShellRefiner.cs @@ -25,7 +25,6 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance ); AddPropertiesAndMethodTypesImports(generatedCode, false, false, false); cancellationToken.ThrowIfCancellationRequested(); - AddInnerClasses(generatedCode, false); AddParsableImplementsForModelClasses(generatedCode, "IParsable"); CapitalizeNamespacesFirstLetters(generatedCode); cancellationToken.ThrowIfCancellationRequested(); From de0d1bf2572d68cf327e2b0dd4ab124989668628 Mon Sep 17 00:00:00 2001 From: Vincent Biret Date: Thu, 17 Nov 2022 09:41:29 -0500 Subject: [PATCH 04/18] - moves add inner class unit test to Go --- .../Refiners/GoLanguageRefinerTests.cs | 28 +++++++++++++++++++ .../Refiners/JavaLanguageRefinerTests.cs | 28 ------------------- 2 files changed, 28 insertions(+), 28 deletions(-) diff --git a/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs b/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs index ebc64a766d..299f28de93 100644 --- a/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs +++ b/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs @@ -12,6 +12,34 @@ public class GoLanguageRefinerTests { private readonly CodeNamespace root = CodeNamespace.InitRootNamespace(); #region CommonLangRefinerTests [Fact] + public async Task AddsInnerClasses() { + var model = root.AddClass(new CodeClass { + Name = "model", + Kind = CodeClassKind.RequestBuilder + }).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); + await ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root); + Assert.Equal(2, model.GetChildElements(true).Count()); + } + [Fact] public async Task TrimsCircularDiscriminatorReferences() { var modelsNS = root.AddNamespace("models"); var baseModel = modelsNS.AddClass(new CodeClass { diff --git a/tests/Kiota.Builder.Tests/Refiners/JavaLanguageRefinerTests.cs b/tests/Kiota.Builder.Tests/Refiners/JavaLanguageRefinerTests.cs index 8293e22ad8..f20b6a0a0d 100644 --- a/tests/Kiota.Builder.Tests/Refiners/JavaLanguageRefinerTests.cs +++ b/tests/Kiota.Builder.Tests/Refiners/JavaLanguageRefinerTests.cs @@ -253,34 +253,6 @@ public async Task ReplacesIndexersByMethodsWithParameter() { Assert.Single(collectionRequestBuilder.Properties); } [Fact] - public async Task 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); - await ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root); - Assert.Equal(2, model.GetChildElements(true).Count()); - } - [Fact] public async Task DoesNotKeepCancellationParametersInRequestExecutors() { var model = root.AddClass(new CodeClass From 6ed9b49e7c31a79b737afac6978e1e6a4a08f9b8 Mon Sep 17 00:00:00 2001 From: ramsessanchez <63934382+ramsessanchez@users.noreply.github.com> Date: Thu, 17 Nov 2022 11:13:23 -0800 Subject: [PATCH 05/18] Update src/Kiota.Builder/Refiners/JavaRefiner.cs Co-authored-by: Eastman --- src/Kiota.Builder/Refiners/JavaRefiner.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Kiota.Builder/Refiners/JavaRefiner.cs b/src/Kiota.Builder/Refiners/JavaRefiner.cs index 6f80442e4f..52d7c19535 100644 --- a/src/Kiota.Builder/Refiners/JavaRefiner.cs +++ b/src/Kiota.Builder/Refiners/JavaRefiner.cs @@ -299,7 +299,7 @@ private void InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(C CrawlTree(currentElement, InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors); } private static void RemoveClassNamePrefixFromNestedClasses(CodeElement currentElement) { - if(currentElement is CodeClass currentClass) { + if(currentElement is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.RequestBuilder)) { var prefix = currentClass.Name; var innerClasses = currentClass .Methods From 159ff0b7b0f937f7c4cfbf5084c9b44c6441b2aa Mon Sep 17 00:00:00 2001 From: ramsessanchez <63934382+ramsessanchez@users.noreply.github.com> Date: Thu, 17 Nov 2022 14:53:43 -0800 Subject: [PATCH 06/18] Apply suggestions from code review Co-authored-by: Vincent Biret --- src/Kiota.Builder/Refiners/JavaRefiner.cs | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/src/Kiota.Builder/Refiners/JavaRefiner.cs b/src/Kiota.Builder/Refiners/JavaRefiner.cs index 52d7c19535..e3de5d49b7 100644 --- a/src/Kiota.Builder/Refiners/JavaRefiner.cs +++ b/src/Kiota.Builder/Refiners/JavaRefiner.cs @@ -338,11 +338,11 @@ private static void RemovePrefixFromQueryProperties(CodeElement currentElement, .Properties .Where(static x=> x.IsOfKind(CodePropertyKind.QueryParameters)) .Select(static x => x.Type) - .OfType(); + .OfType() + .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); foreach(var property in queryProperty) { - if(property.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) - property.Name = property.Name[prefix.Length..]; + property.Name = property.Name[prefix.Length..]; } } } @@ -353,14 +353,12 @@ private static void RemovePrefixFromRequestConfigParameters(CodeElement currentE .SelectMany(static x => x.Parameters) .Where(static x => x.Type.ActionOf && x.IsOfKind(CodeParameterKind.RequestConfiguration)) .Select(static x=> x.Type) - .OfType(); + .OfType() + .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); - var paramList = new List(); - paramList.AddRange(parameters); - foreach(var parameter in paramList ) { - if(parameter.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) - parameter.Name = parameter.Name[prefix.Length..]; + foreach(var parameter in parameters) { + parameter.Name = parameter.Name[prefix.Length..]; } } } From 89a502252d5b3dffc52850feb73c59bee8196025 Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Thu, 17 Nov 2022 16:59:45 -0800 Subject: [PATCH 07/18] change the way we set httpMethod --- src/Kiota.Builder/Refiners/JavaRefiner.cs | 34 +++++++++++++++---- .../Writers/Java/CodeMethodWriter.cs | 10 +++--- 2 files changed, 32 insertions(+), 12 deletions(-) diff --git a/src/Kiota.Builder/Refiners/JavaRefiner.cs b/src/Kiota.Builder/Refiners/JavaRefiner.cs index e3de5d49b7..0cae58522e 100644 --- a/src/Kiota.Builder/Refiners/JavaRefiner.cs +++ b/src/Kiota.Builder/Refiners/JavaRefiner.cs @@ -307,7 +307,25 @@ private static void RemoveClassNamePrefixFromNestedClasses(CodeElement currentEl .Where(static x => x.Type.ActionOf && x.IsOfKind(CodeParameterKind.RequestConfiguration)) .SelectMany(static x => x.Type.AllTypes) .Select(static x => x.TypeDefinition) - .OfType(); + .OfType() + .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); + + // { + // x => x.SelectMany(static x => x.Properties) + // .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters)) + // .SelectMany(static x => x.Type.AllTypes) + // .Select(static x => x.TypeDefinition) + // .Select(static x => x.TypeDefinition) + // .OfType() + // ) + // .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); + + // .SelectMany(static x => x.Properties) + // .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters)) + // .SelectMany(static x => x.Type.AllTypes) + // .Select(static x => x.TypeDefinition) + // .OfType() + // .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); // ensure we do not miss out the types present in request configuration objects i.e. the query parameters var nestedQueryParameters = innerClasses @@ -315,14 +333,16 @@ private static void RemoveClassNamePrefixFromNestedClasses(CodeElement currentEl .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters)) .SelectMany(static x => x.Type.AllTypes) .Select(static x => x.TypeDefinition) - .OfType(); + .OfType().Union(innerClasses) + .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); + - var nestedClasses = new List(); - nestedClasses.AddRange(innerClasses); - nestedClasses.AddRange(nestedQueryParameters); + // var nestedClasses = new List(); + // nestedClasses.AddRange(innerClasses); + // nestedClasses.AddRange(nestedQueryParameters); - foreach(var innerClass in nestedClasses) { - if(innerClass.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) + foreach(var innerClass in nestedQueryParameters) { + //if(innerClass.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) innerClass.Name = innerClass.Name[prefix.Length..]; if(innerClass.IsOfKind(CodeClassKind.RequestConfiguration)) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index b5b364e0f8..0cc12dde71 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -485,11 +485,11 @@ private void WriteRequestGeneratorBody(CodeMethod codeElement, RequestParams req var urlTemplateParamsProperty = currentClass.GetPropertyOfKind(CodePropertyKind.PathParameters); var urlTemplateProperty = currentClass.GetPropertyOfKind(CodePropertyKind.UrlTemplate); var requestAdapterProperty = currentClass.GetPropertyOfKind(CodePropertyKind.RequestAdapter); - writer.WriteLine($"final RequestInformation {RequestInfoVarName} = new RequestInformation() {{{{"); - writer.IncreaseIndent(); - writer.WriteLine($"httpMethod = HttpMethod.{codeElement.HttpMethod?.ToString().ToUpperInvariant()};"); - writer.DecreaseIndent(); - writer.WriteLine("}};"); + writer.WriteLine($"final RequestInformation {RequestInfoVarName} = new RequestInformation();"); //{{{{"); + //writer.IncreaseIndent(); + writer.WriteLine($"{RequestInfoVarName}.httpMethod = HttpMethod.{codeElement.HttpMethod?.ToString().ToUpperInvariant()};"); + //writer.DecreaseIndent(); + //writer.WriteLine("}};"); writer.WriteLines($"{RequestInfoVarName}.urlTemplate = {GetPropertyCall(urlTemplateProperty, "\"\"")};", $"{RequestInfoVarName}.pathParameters = {GetPropertyCall(urlTemplateParamsProperty, "null")};"); if(codeElement.AcceptedResponseTypes.Any()) From 82f5146f1c48d7c687ac8e9f189a10b66b667172 Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Thu, 17 Nov 2022 17:07:21 -0800 Subject: [PATCH 08/18] refactor put statements --- src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index 0cc12dde71..96497906f5 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -431,12 +431,12 @@ private void WriteRequestExecutorBody(CodeMethod codeElement, RequestParams requ var errorMappingVarName = "null"; if(codeElement.ErrorMappings.Any()) { errorMappingVarName = "errorMapping"; - writer.WriteLine($"final HashMap> {errorMappingVarName} = new HashMap>({codeElement.ErrorMappings.Count()}) {{{{"); - writer.IncreaseIndent(); + writer.WriteLine($"final HashMap> {errorMappingVarName} = new HashMap>()"); //{codeElement.ErrorMappings.Count()}) {{{{"); + //writer.IncreaseIndent(); foreach(var errorMapping in codeElement.ErrorMappings) { - writer.WriteLine($"put(\"{errorMapping.Key.ToUpperInvariant()}\", {errorMapping.Value.Name.ToFirstCharacterUpperCase()}::{FactoryMethodName});"); + writer.WriteLine($"{errorMappingVarName}.put(\"{errorMapping.Key.ToUpperInvariant()}\", {errorMapping.Value.Name.ToFirstCharacterUpperCase()}::{FactoryMethodName});"); } - writer.CloseBlock("}};"); + //writer.CloseBlock("}};"); } var factoryParameter = codeElement.ReturnType is CodeType returnCodeType && returnCodeType.TypeDefinition is CodeClass ? $"{returnType}::{FactoryMethodName}" : $"{returnType}.class"; writer.WriteLine($"return this.requestAdapter.{sendMethodName}({RequestInfoVarName}, {factoryParameter}, {errorMappingVarName});"); From ea8de1a35c78f0f017fe527cdb90b6cfb6bb5946 Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Thu, 17 Nov 2022 17:45:50 -0800 Subject: [PATCH 09/18] missing semicolon --- src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index 96497906f5..a1485e68c0 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -431,7 +431,7 @@ private void WriteRequestExecutorBody(CodeMethod codeElement, RequestParams requ var errorMappingVarName = "null"; if(codeElement.ErrorMappings.Any()) { errorMappingVarName = "errorMapping"; - writer.WriteLine($"final HashMap> {errorMappingVarName} = new HashMap>()"); //{codeElement.ErrorMappings.Count()}) {{{{"); + writer.WriteLine($"final HashMap> {errorMappingVarName} = new HashMap>();"); //{codeElement.ErrorMappings.Count()}) {{{{"); //writer.IncreaseIndent(); foreach(var errorMapping in codeElement.ErrorMappings) { writer.WriteLine($"{errorMappingVarName}.put(\"{errorMapping.Key.ToUpperInvariant()}\", {errorMapping.Value.Name.ToFirstCharacterUpperCase()}::{FactoryMethodName});"); From 12eed7383c681688240a0992ff0b3f08386959b6 Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Fri, 18 Nov 2022 16:13:00 -0800 Subject: [PATCH 10/18] remove more anonymous methods and comments --- .../Writers/Java/CodeMethodWriter.cs | 25 ++++++++----------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index a1485e68c0..980665e566 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -402,25 +402,25 @@ private static void WriteDeserializerBodyForIntersectionModel(CodeClass parentCl } writer.WriteLine($"return new {DeserializerReturnType}();"); } + private const string DeserializerVarName = "deserializerMap"; private void WriteDeserializerBodyForInheritedModel(CodeMethod method, CodeClass parentClass, LanguageWriter writer, bool inherits) { var fieldToSerialize = parentClass.GetPropertiesOfKind(CodePropertyKind.Custom); writer.WriteLines( $"final {parentClass.Name.ToFirstCharacterUpperCase()} currentObject = this;", - $"return new {DeserializerReturnType}({(inherits ? "super." + method.Name.ToFirstCharacterLowerCase()+ "()" : fieldToSerialize.Count())}) {{{{"); + $"final {DeserializerReturnType} {DeserializerVarName} = new {DeserializerReturnType}({(inherits ? "super." + method.Name.ToFirstCharacterLowerCase()+ "()" : fieldToSerialize.Count())});"); if(fieldToSerialize.Any()) { - writer.IncreaseIndent(); fieldToSerialize .Where(static x => !x.ExistsInBaseType && x.Setter != null) .OrderBy(static x => x.Name) .Select(x => - $"this.put(\"{x.SerializationName ?? x.Name.ToFirstCharacterLowerCase()}\", (n) -> {{ currentObject.{x.Setter.Name.ToFirstCharacterLowerCase()}(n.{GetDeserializationMethodName(x.Type, method)}); }});") + $"{DeserializerVarName}.put(\"{x.SerializationName ?? x.Name.ToFirstCharacterLowerCase()}\", (n) -> {{ currentObject.{x.Setter.Name.ToFirstCharacterLowerCase()}(n.{GetDeserializationMethodName(x.Type, method)}); }});") .ToList() .ForEach(x => writer.WriteLine(x)); - writer.DecreaseIndent(); } - writer.WriteLine("}};"); + writer.WriteLine($"return {DeserializerVarName}"); } private const string FactoryMethodName = "createFromDiscriminatorValue"; + private const string ExecuterExceptionVar = "executionException"; private void WriteRequestExecutorBody(CodeMethod codeElement, RequestParams requestParams, LanguageWriter writer) { if(codeElement.HttpMethod == null) throw new InvalidOperationException("http method cannot be null"); var returnType = conventions.GetTypeString(codeElement.ReturnType, codeElement, false); @@ -431,20 +431,18 @@ private void WriteRequestExecutorBody(CodeMethod codeElement, RequestParams requ var errorMappingVarName = "null"; if(codeElement.ErrorMappings.Any()) { errorMappingVarName = "errorMapping"; - writer.WriteLine($"final HashMap> {errorMappingVarName} = new HashMap>();"); //{codeElement.ErrorMappings.Count()}) {{{{"); - //writer.IncreaseIndent(); + writer.WriteLine($"final HashMap> {errorMappingVarName} = new HashMap>();"); foreach(var errorMapping in codeElement.ErrorMappings) { writer.WriteLine($"{errorMappingVarName}.put(\"{errorMapping.Key.ToUpperInvariant()}\", {errorMapping.Value.Name.ToFirstCharacterUpperCase()}::{FactoryMethodName});"); } - //writer.CloseBlock("}};"); } var factoryParameter = codeElement.ReturnType is CodeType returnCodeType && returnCodeType.TypeDefinition is CodeClass ? $"{returnType}::{FactoryMethodName}" : $"{returnType}.class"; writer.WriteLine($"return this.requestAdapter.{sendMethodName}({RequestInfoVarName}, {factoryParameter}, {errorMappingVarName});"); writer.DecreaseIndent(); writer.StartBlock("} catch (URISyntaxException ex) {"); - writer.StartBlock($"return new java.util.concurrent.CompletableFuture<{returnType}>() {{{{"); - writer.WriteLine("this.completeExceptionally(ex);"); - writer.CloseBlock("}};"); + writer.WriteLine($"java.util.concurrent.CompletableFuture<{returnType}> {ExecuterExceptionVar} = new java.util.concurrent.CompletableFuture<{returnType}>();"); + writer.WriteLine($"{ExecuterExceptionVar}.completeExceptionally(ex);"); + writer.WriteLine($"return {ExecuterExceptionVar};"); writer.CloseBlock(); } private string GetSendRequestMethodName(bool isCollection, string returnType, bool isEnum) @@ -485,11 +483,8 @@ private void WriteRequestGeneratorBody(CodeMethod codeElement, RequestParams req var urlTemplateParamsProperty = currentClass.GetPropertyOfKind(CodePropertyKind.PathParameters); var urlTemplateProperty = currentClass.GetPropertyOfKind(CodePropertyKind.UrlTemplate); var requestAdapterProperty = currentClass.GetPropertyOfKind(CodePropertyKind.RequestAdapter); - writer.WriteLine($"final RequestInformation {RequestInfoVarName} = new RequestInformation();"); //{{{{"); - //writer.IncreaseIndent(); + writer.WriteLine($"final RequestInformation {RequestInfoVarName} = new RequestInformation();"); writer.WriteLine($"{RequestInfoVarName}.httpMethod = HttpMethod.{codeElement.HttpMethod?.ToString().ToUpperInvariant()};"); - //writer.DecreaseIndent(); - //writer.WriteLine("}};"); writer.WriteLines($"{RequestInfoVarName}.urlTemplate = {GetPropertyCall(urlTemplateProperty, "\"\"")};", $"{RequestInfoVarName}.pathParameters = {GetPropertyCall(urlTemplateParamsProperty, "null")};"); if(codeElement.AcceptedResponseTypes.Any()) From a5e18abdd3dd31c78d14d90bbfa048b2e7fe699f Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Fri, 18 Nov 2022 16:51:30 -0800 Subject: [PATCH 11/18] semicolon --- src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index 980665e566..d6f9a318f7 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -417,7 +417,7 @@ private void WriteDeserializerBodyForInheritedModel(CodeMethod method, CodeClass .ToList() .ForEach(x => writer.WriteLine(x)); } - writer.WriteLine($"return {DeserializerVarName}"); + writer.WriteLine($"return {DeserializerVarName};"); } private const string FactoryMethodName = "createFromDiscriminatorValue"; private const string ExecuterExceptionVar = "executionException"; From 8a70a84e2c1f63204723c4f3618edc6126622171 Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Mon, 21 Nov 2022 13:31:40 -0800 Subject: [PATCH 12/18] test update --- .../Writers/Java/CodeMethodWriterTests.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs index b1bf36f511..a70be28c53 100644 --- a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs @@ -20,6 +20,7 @@ public class CodeMethodWriterTests : IDisposable { private readonly CodeMethod method; private readonly CodeClass parentClass; private readonly CodeNamespace root; + private const string ExecuterExceptionVar = "executionException"; private const string MethodName = "methodName"; private const string ReturnTypeName = "Somecustomtype"; private const string MethodDescription = "some description"; @@ -499,9 +500,8 @@ public void WritesRequestExecutorBody() { Assert.Contains("put(\"5XX\", Error5XX::createFromDiscriminatorValue);", result); Assert.Contains("put(\"403\", Error403::createFromDiscriminatorValue);", result); Assert.Contains("sendAsync", result); - Assert.Contains("return new java.util.concurrent.CompletableFuture() {{", result); - Assert.Contains("this.completeExceptionally(ex);", result); - Assert.Contains("}};", result); + Assert.Contains($"java.util.concurrent.CompletableFuture {ExecuterExceptionVar} = = new java.util.concurrent.CompletableFuture();", result); + Assert.Contains($"{ExecuterExceptionVar}.completeExceptionally(ex);", result); AssertExtensions.CurlyBracesAreClosed(result); } [Fact] From 1f7dd2642c5e429c5b714d9187d17451bf8e940d Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Mon, 21 Nov 2022 13:47:28 -0800 Subject: [PATCH 13/18] remove equals sign --- tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs index a70be28c53..7fd6bcdef0 100644 --- a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs @@ -500,7 +500,7 @@ public void WritesRequestExecutorBody() { Assert.Contains("put(\"5XX\", Error5XX::createFromDiscriminatorValue);", result); Assert.Contains("put(\"403\", Error403::createFromDiscriminatorValue);", result); Assert.Contains("sendAsync", result); - Assert.Contains($"java.util.concurrent.CompletableFuture {ExecuterExceptionVar} = = new java.util.concurrent.CompletableFuture();", result); + Assert.Contains($"java.util.concurrent.CompletableFuture {ExecuterExceptionVar} = new java.util.concurrent.CompletableFuture();", result); Assert.Contains($"{ExecuterExceptionVar}.completeExceptionally(ex);", result); AssertExtensions.CurlyBracesAreClosed(result); } From f4582f2d0272426cd3b4ba9dacffec9ab6030ee2 Mon Sep 17 00:00:00 2001 From: ramsessanchez Date: Mon, 21 Nov 2022 14:44:38 -0800 Subject: [PATCH 14/18] consolidate loops --- src/Kiota.Builder/Refiners/JavaRefiner.cs | 36 ++++------------------- 1 file changed, 5 insertions(+), 31 deletions(-) diff --git a/src/Kiota.Builder/Refiners/JavaRefiner.cs b/src/Kiota.Builder/Refiners/JavaRefiner.cs index 0cae58522e..e517041daf 100644 --- a/src/Kiota.Builder/Refiners/JavaRefiner.cs +++ b/src/Kiota.Builder/Refiners/JavaRefiner.cs @@ -301,48 +301,23 @@ private void InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(C private static void RemoveClassNamePrefixFromNestedClasses(CodeElement currentElement) { if(currentElement is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.RequestBuilder)) { var prefix = currentClass.Name; - var innerClasses = currentClass + var requestConfigClasses = currentClass .Methods .SelectMany(static x => x.Parameters) .Where(static x => x.Type.ActionOf && x.IsOfKind(CodeParameterKind.RequestConfiguration)) .SelectMany(static x => x.Type.AllTypes) .Select(static x => x.TypeDefinition) - .OfType() - .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); - - // { - // x => x.SelectMany(static x => x.Properties) - // .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters)) - // .SelectMany(static x => x.Type.AllTypes) - // .Select(static x => x.TypeDefinition) - // .Select(static x => x.TypeDefinition) - // .OfType() - // ) - // .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); - - // .SelectMany(static x => x.Properties) - // .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters)) - // .SelectMany(static x => x.Type.AllTypes) - // .Select(static x => x.TypeDefinition) - // .OfType() - // .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); - + .OfType(); // ensure we do not miss out the types present in request configuration objects i.e. the query parameters - var nestedQueryParameters = innerClasses + var innerClasses = requestConfigClasses .SelectMany(static x => x.Properties) .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters)) .SelectMany(static x => x.Type.AllTypes) .Select(static x => x.TypeDefinition) - .OfType().Union(innerClasses) + .OfType().Union(requestConfigClasses) .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); - - - // var nestedClasses = new List(); - // nestedClasses.AddRange(innerClasses); - // nestedClasses.AddRange(nestedQueryParameters); - foreach(var innerClass in nestedQueryParameters) { - //if(innerClass.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) + foreach(var innerClass in innerClasses) { innerClass.Name = innerClass.Name[prefix.Length..]; if(innerClass.IsOfKind(CodeClassKind.RequestConfiguration)) @@ -376,7 +351,6 @@ private static void RemovePrefixFromRequestConfigParameters(CodeElement currentE .OfType() .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); - foreach(var parameter in parameters) { parameter.Name = parameter.Name[prefix.Length..]; } From 4c380611a9534dd17346153eea9304a2a674871c Mon Sep 17 00:00:00 2001 From: ramsessanchez <63934382+ramsessanchez@users.noreply.github.com> Date: Tue, 22 Nov 2022 12:04:41 -0800 Subject: [PATCH 15/18] Update src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs Co-authored-by: Vincent Biret --- src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index d6f9a318f7..d1ca767b89 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -406,7 +406,6 @@ private static void WriteDeserializerBodyForIntersectionModel(CodeClass parentCl private void WriteDeserializerBodyForInheritedModel(CodeMethod method, CodeClass parentClass, LanguageWriter writer, bool inherits) { var fieldToSerialize = parentClass.GetPropertiesOfKind(CodePropertyKind.Custom); writer.WriteLines( - $"final {parentClass.Name.ToFirstCharacterUpperCase()} currentObject = this;", $"final {DeserializerReturnType} {DeserializerVarName} = new {DeserializerReturnType}({(inherits ? "super." + method.Name.ToFirstCharacterLowerCase()+ "()" : fieldToSerialize.Count())});"); if(fieldToSerialize.Any()) { fieldToSerialize From cad9de45e74bb52d6b2f879a6d697d907423e28a Mon Sep 17 00:00:00 2001 From: ramsessanchez <63934382+ramsessanchez@users.noreply.github.com> Date: Tue, 22 Nov 2022 12:05:12 -0800 Subject: [PATCH 16/18] Update src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs Co-authored-by: Vincent Biret --- src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index d1ca767b89..b9eb83c51f 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -412,7 +412,7 @@ private void WriteDeserializerBodyForInheritedModel(CodeMethod method, CodeClass .Where(static x => !x.ExistsInBaseType && x.Setter != null) .OrderBy(static x => x.Name) .Select(x => - $"{DeserializerVarName}.put(\"{x.SerializationName ?? x.Name.ToFirstCharacterLowerCase()}\", (n) -> {{ currentObject.{x.Setter.Name.ToFirstCharacterLowerCase()}(n.{GetDeserializationMethodName(x.Type, method)}); }});") + $"{DeserializerVarName}.put(\"{x.SerializationName ?? x.Name.ToFirstCharacterLowerCase()}\", (n) -> {{ this.{x.Setter.Name.ToFirstCharacterLowerCase()}(n.{GetDeserializationMethodName(x.Type, method)}); }});") .ToList() .ForEach(x => writer.WriteLine(x)); } From be57a5747c3d6f9590535f7eae90310dcd24f339 Mon Sep 17 00:00:00 2001 From: ramsessanchez <63934382+ramsessanchez@users.noreply.github.com> Date: Tue, 22 Nov 2022 12:27:14 -0800 Subject: [PATCH 17/18] Update CHANGELOG.md --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b9558b3620..2cf45b1a88 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Fixed a bug in PHP generation where request bodies would not serialize single elements properly. [#1937](https://github.com/microsoft/kiota/pull/1937) - Fixed a bug where request information would always be set from scalar. [#1965](https://github.com/microsoft/kiota/pull/1965) - Fixed a bug where path parameters would be missing if no operation was present at the segment the parameter is defined. [#1940](https://github.com/microsoft/kiota/issues/1940) +- Fixed a bug where nested classes with long names caused compilation errors for java generated libraries. [#1949](https://github.com/microsoft/kiota/issues/1949) +- Removed use of anonymous classes in java generated libraries to reduce the number of java classes created at compilation time. [#1980](https://github.com/microsoft/kiota/pull/1980) ## [0.7.1] - 2022-11-01 From 2041c3c71079a7137d7f3397d38105f423a7b3c2 Mon Sep 17 00:00:00 2001 From: Vincent Biret Date: Wed, 30 Nov 2022 15:00:10 -0500 Subject: [PATCH 18/18] - fixes unit test for java executor method --- src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs | 2 +- tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index 8f4e088000..895d391a3f 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -439,7 +439,7 @@ private void WriteRequestExecutorBody(CodeMethod codeElement, RequestParams requ writer.WriteLine($"return this.requestAdapter.{sendMethodName}({RequestInfoVarName}, {factoryParameter}, {errorMappingVarName});"); writer.DecreaseIndent(); writer.StartBlock("} catch (URISyntaxException ex) {"); - writer.WriteLine($"java.util.concurrent.CompletableFuture<{signatureReturnType}> {ExecuterExceptionVar} = new java.util.concurrent.CompletableFuture<{signatureReturnType}>();"); + writer.WriteLine($"final java.util.concurrent.CompletableFuture<{signatureReturnType}> {ExecuterExceptionVar} = new java.util.concurrent.CompletableFuture<{signatureReturnType}>();"); writer.WriteLine($"{ExecuterExceptionVar}.completeExceptionally(ex);"); writer.WriteLine($"return {ExecuterExceptionVar};"); writer.CloseBlock(); diff --git a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs index 442aec4574..2a91a0e463 100644 --- a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs @@ -910,7 +910,7 @@ public void WritesRequestExecutorBodyForCollections() { writer.Write(method); var result = tw.ToString(); Assert.Contains("sendCollectionAsync", result); - Assert.Contains("return new java.util.concurrent.CompletableFuture>() {{", result); + Assert.Contains("final java.util.concurrent.CompletableFuture> executionException = new java.util.concurrent.CompletableFuture>()", result); AssertExtensions.CurlyBracesAreClosed(result); } [Fact]