From 39dec9a18153a97fce1cdba901d460a7596c070b Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Mon, 2 Nov 2026 22:45:46 +0530 Subject: [PATCH 1/4] feat(core): support numerical enums in CodeDOM and OpenAPI schema parsing --- src/Kiota.Builder/CodeDOM/CodeEnum.cs | 10 +++++++++- src/Kiota.Builder/CodeDOM/CodeEnumOption.cs | 3 ++- .../Extensions/OpenApiSchemaExtensions.cs | 5 +++-- src/Kiota.Builder/KiotaBuilder.cs | 12 +++++++++++- 4 files changed, 25 insertions(+), 5 deletions(-) diff --git a/src/Kiota.Builder/CodeDOM/CodeEnum.cs b/src/Kiota.Builder/CodeDOM/CodeEnum.cs index c4c48550e5..6c9f88ea04 100644 --- a/src/Kiota.Builder/CodeDOM/CodeEnum.cs +++ b/src/Kiota.Builder/CodeDOM/CodeEnum.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.Linq; @@ -13,6 +13,14 @@ public bool Flags { get; set; } + public bool IsNumeric + { + get; set; + } + public string? Format + { + get; set; + } public CodeDocumentation Documentation { get; set; } = new(); private readonly ConcurrentQueue OptionsInternal = new(); // this structure is used to maintain the order of the options diff --git a/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs b/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs index a709fb8fe3..79fb0badf7 100644 --- a/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs +++ b/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs @@ -1,4 +1,4 @@ -using Kiota.Builder.Extensions; +using Kiota.Builder.Extensions; namespace Kiota.Builder.CodeDOM; @@ -6,6 +6,7 @@ public class CodeEnumOption : CodeElement, IDocumentedElement, ITypeDefinition, { /// public string SerializationName { get; set; } = string.Empty; + public bool IsNumeric { get; set; } public CodeDocumentation Documentation { get; set; } = new(); /// public bool IsNameEscaped diff --git a/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs b/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs index c24a659896..bbaa8bf7c5 100644 --- a/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs +++ b/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs @@ -304,9 +304,10 @@ public static bool IsODataPrimitiveType(this IOpenApiSchema schema) public static bool IsEnum(this IOpenApiSchema? schema) { if (schema is null || schema.Enum is null) return false; - return schema.Enum.Any(static x => x.GetValueKind() is JsonValueKind.String && + return schema.Enum.Any(static x => (x.GetValueKind() is JsonValueKind.String && x.GetValue() is string value && - !string.IsNullOrEmpty(value)); // number and boolean enums are not supported + !string.IsNullOrEmpty(value)) || + x.GetValueKind() is JsonValueKind.Number); } public static bool IsComposedEnum(this IOpenApiSchema? schema) { diff --git a/src/Kiota.Builder/KiotaBuilder.cs b/src/Kiota.Builder/KiotaBuilder.cs index 7af1c5c484..86aff14178 100644 --- a/src/Kiota.Builder/KiotaBuilder.cs +++ b/src/Kiota.Builder/KiotaBuilder.cs @@ -2387,10 +2387,14 @@ private CodeElement AddModelDeclarationIfDoesntExist(OpenApiUrlTreeNode currentN { enumFlagsExtension = flagsExtension; } + var isNumeric = schema.Type is JsonSchemaType.Integer or JsonSchemaType.Number + || (schema.Enum is { Count: > 0 } && schema.Enum.OfType().All(static x => x.GetValueKind() is JsonValueKind.Number)); var newEnum = new CodeEnum { Name = declarationName, Flags = enumFlagsExtension?.IsFlags ?? false, + IsNumeric = isNumeric, + Format = schema.Format, Documentation = new() { DescriptionTemplate = !string.IsNullOrEmpty(schemaDescription) || !string.IsNullOrEmpty(schema.GetReferenceId()) ? @@ -2409,9 +2413,14 @@ private static void SetEnumOptions(IOpenApiSchema schema, CodeEnum target) OpenApiEnumValuesDescriptionExtension? extensionInformation = null; if (schema.Extensions is not null && schema.Extensions.TryGetValue(OpenApiEnumValuesDescriptionExtension.Name, out var rawExtension) && rawExtension is OpenApiEnumValuesDescriptionExtension localExtInfo) extensionInformation = localExtInfo; + if (!target.IsNumeric && schema.Enum is { Count: > 0 } && schema.Enum.OfType().All(static x => x.GetValueKind() is JsonValueKind.Number)) + { + target.IsNumeric = true; + target.Format ??= schema.Format; + } target.AddOption(schema.Enum?.OfType() .Where(static x => x.GetValueKind() is JsonValueKind.String or JsonValueKind.Number) - .Select(static x => x.GetValueKind() is JsonValueKind.String ? x.GetValue() : x.GetValue().ToString(CultureInfo.InvariantCulture)) + .Select(static x => x.GetValueKind() is JsonValueKind.String ? x.GetValue() : (x.TryGetValue(out var l) ? l.ToString(CultureInfo.InvariantCulture) : (x.TryGetValue(out var d) ? d.ToString(CultureInfo.InvariantCulture) : x.ToJsonString()))) .Where(static x => !string.IsNullOrEmpty(x)) .Distinct(StringComparer.OrdinalIgnoreCase) .Select((x) => @@ -2423,6 +2432,7 @@ private static void SetEnumOptions(IOpenApiSchema schema, CodeEnum target) name : x).CleanupSymbolName(), SerializationName = x, + IsNumeric = target.IsNumeric, Documentation = new() { DescriptionTemplate = optionDescription?.Description?.CleanupDescription() ?? string.Empty, From 4bbf71105fcc80983ff6fc9a43542912b5046abf Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Mon, 2 Nov 2026 22:49:19 +0530 Subject: [PATCH 2/4] feat(writers): add numerical enum generation support across language writers --- CHANGELOG.md | 2 ++ .../Writers/CSharp/CodeEnumWriter.cs | 22 +++++++++++++++-- .../Writers/Go/CodeEnumWriter.cs | 24 ++++++++++++++++--- .../Writers/Php/CodeEnumWriter.cs | 11 +++++++-- .../Writers/Python/CodeEnumWriter.cs | 12 ++++++++-- .../Writers/Ruby/CodeEnumWriter.cs | 2 +- .../Writers/TypeScript/CodeConstantWriter.cs | 9 ++++++- .../Writers/TypeScript/CodeFunctionWriter.cs | 5 +++- 8 files changed, 75 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 00b22ffec2..d7ce40c08d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- Add numerical enum generation support across C#, TypeScript, Python, Go, PHP, and Ruby language writers. [#5165](https://github.com/microsoft/kiota/issues/5165) + ### Changed - Python: check inherited-model discriminators once before type dispatch to avoid repeated truthiness checks that cause excessive CodeQL extraction work in large factories. diff --git a/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs index 5265ac159a..81669e0a8e 100644 --- a/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs @@ -38,7 +38,18 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write writer.WriteLine("[Flags]"); conventions.WriteDeprecationAttribute(codeElement, writer); if (!hasDescription) conventions.WritePragmaDisable(writer, CSharpConventionService.CS1591); - writer.WriteLine($"{conventions.GetAccessModifier(codeElement.Access)} enum {codeElement.Name.ToFirstCharacterUpperCase()}"); + var numericTypeSuffix = codeElement.IsNumeric && !string.IsNullOrEmpty(codeElement.Format) ? codeElement.Format.ToLowerInvariant() switch + { + "int64" => " : long", + "int8" => " : sbyte", + "uint8" => " : byte", + "int16" => " : short", + "uint16" => " : ushort", + "uint32" => " : uint", + "uint64" => " : ulong", + _ => string.Empty, + } : string.Empty; + writer.WriteLine($"{conventions.GetAccessModifier(codeElement.Access)} enum {codeElement.Name.ToFirstCharacterUpperCase()}{numericTypeSuffix}"); if (!hasDescription) conventions.WritePragmaRestore(writer, CSharpConventionService.CS1591); writer.StartBlock(); var idx = 0; @@ -51,7 +62,14 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write writer.WriteLine($"[EnumMember(Value = \"{option.SerializationName.SanitizeCSharpDoubleQuote()}\")]"); } if (!hasDescription) conventions.WritePragmaDisable(writer, CSharpConventionService.CS1591); - writer.WriteLine($"{option.Name.ToFirstCharacterUpperCase()}{(codeElement.Flags ? " = " + GetEnumFlag(idx) : string.Empty)},"); + if (codeElement.IsNumeric) + { + writer.WriteLine($"{option.Name.ToFirstCharacterUpperCase()} = {option.SerializationName},"); + } + else + { + writer.WriteLine($"{option.Name.ToFirstCharacterUpperCase()}{(codeElement.Flags ? " = " + GetEnumFlag(idx) : string.Empty)},"); + } if (!hasDescription) conventions.WritePragmaRestore(writer, CSharpConventionService.CS1591); idx++; } diff --git a/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs index 0d1c2aedd0..6c062f6ee0 100644 --- a/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs @@ -34,7 +34,8 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write writer.WriteLine(); // gofmt: exactly one blank line before each top-level declaration conventions.WriteShortDescription(codeElement, writer); conventions.WriteDeprecation(codeElement, writer); - writer.WriteLines($"type {typeName} int", + var underlyingType = codeElement.IsNumeric && string.Equals(codeElement.Format, "int64", StringComparison.OrdinalIgnoreCase) ? "int64" : "int"; + writer.WriteLines($"type {typeName} {underlyingType}", string.Empty, "const ("); writer.IncreaseIndent(); @@ -51,7 +52,9 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write if (item.Documentation.DescriptionAvailable) conventions.WriteDescriptionItem(GoConventionService.RemoveInvalidDescriptionCharacters(item.Documentation.DescriptionTemplate), writer); - if (isMultiValue) + if (codeElement.IsNumeric) + writer.WriteLine($"{item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()} {typeName} = {item.WireName}"); + else if (isMultiValue) writer.WriteLine($"{item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()} = {(int)Math.Pow(2, power)}"); else writer.WriteLine($"{item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()}{(power == 0 ? $" {typeName} = iota" : string.Empty)}"); @@ -76,7 +79,22 @@ private static void WriteStringFunction(CodeEnum codeElement, LanguageWriter wri var enumOptions = codeElement.Options.ToList(); writer.WriteLine(); // gofmt: exactly one blank line before each top-level declaration - if (isMultiValue) + if (codeElement.IsNumeric) + { + writer.StartBlock($"func (i {typeName}) String() string {{"); + writer.StartBlock("switch i {"); + foreach (var item in enumOptions) + { + writer.WriteLine($"case {item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()}:"); + writer.IncreaseIndent(); + writer.WriteLine($"return \"{item.WireName.SanitizeDoubleQuote()}\""); + writer.DecreaseIndent(); + } + writer.CloseBlock(); + writer.WriteLine("return \"\""); + writer.CloseBlock(); + } + else if (isMultiValue) { writer.StartBlock($"func (i {typeName}) String() string {{"); writer.WriteLine("var values []string"); diff --git a/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs index f8385dff69..c472b7cbf1 100644 --- a/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs @@ -45,7 +45,7 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write { writer.WriteLine(string.Empty); } - writer.WriteLine($"class {codeElement?.Name.ToFirstCharacterUpperCase()} extends Enum {{"); + writer.WriteLine($"class {codeElement.Name.ToFirstCharacterUpperCase()} extends Enum {{"); writer.IncreaseIndent(); var reservedNames = enumProperties.Select(static option => GetEnumValueName(option.Name)).ToHashSet(StringComparer.Ordinal); var emittedNames = new HashSet(StringComparer.Ordinal); @@ -60,7 +60,14 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write candidate = $"{constantName}_{++suffix}"; constantName = candidate; } - writer.WriteLine($"public const {constantName} = \"{PhpConventionService.SanitizePhpDoubleQuoteLiteral(enumProperty.WireName)}\";"); + if (codeElement?.IsNumeric ?? false) + { + writer.WriteLine($"public const {constantName} = {enumProperty.WireName};"); + } + else + { + writer.WriteLine($"public const {constantName} = \"{PhpConventionService.SanitizePhpDoubleQuoteLiteral(enumProperty.WireName)}\";"); + } } } [GeneratedRegex(@"([A-Z]{1})", RegexOptions.Singleline, 500)] diff --git a/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs index 1d26d0a9e7..89ae966ee2 100644 --- a/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs @@ -14,7 +14,8 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write ArgumentNullException.ThrowIfNull(writer); writer.WriteLine("from enum import Enum"); writer.WriteLine(); - writer.WriteLine($"class {codeElement.Name}(str, Enum):"); + var baseType = codeElement.IsNumeric ? (string.Equals(codeElement.Format, "float", StringComparison.OrdinalIgnoreCase) || string.Equals(codeElement.Format, "double", StringComparison.OrdinalIgnoreCase) ? "float" : "int") : "str"; + writer.WriteLine($"class {codeElement.Name}({baseType}, Enum):"); conventions.WriteDeprecationWarning(codeElement, writer); writer.IncreaseIndent(); if (!codeElement.Options.Any()) @@ -26,7 +27,14 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write codeElement.Options.ToList().ForEach(x => { conventions.WriteInLineDescription(x, writer); - writer.WriteLine($"{x.Name} = \"{x.WireName.SanitizeDoubleQuote()}\","); + if (codeElement.IsNumeric) + { + writer.WriteLine($"{x.Name} = {x.WireName},"); + } + else + { + writer.WriteLine($"{x.Name} = \"{x.WireName.SanitizeDoubleQuote()}\","); + } }); } } diff --git a/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs index d1f0965b77..9018aa744b 100644 --- a/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs @@ -23,7 +23,7 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write conventions.WriteDeprecationComment(codeElement, writer); writer.StartBlock($"{codeElement.Name.ToFirstCharacterUpperCase()} = {{"); // the value is what goes on the wire, the key is what Ruby code looks the member up by - var options = codeElement.Options.Select(static x => $"{x.Name.ToFirstCharacterUpperCase()}: {RubyConventionService.ToRubyStringLiteral(x.WireName)}").ToArray(); + var options = codeElement.Options.Select(x => $"{x.Name.ToFirstCharacterUpperCase()}: {(codeElement.IsNumeric ? x.WireName : RubyConventionService.ToRubyStringLiteral(x.WireName))}").ToArray(); for (var i = 0; i < options.Length; i++) writer.WriteLine(i < options.Length - 1 ? $"{options[i]}," : options[i]); writer.CloseBlock("}.freeze"); diff --git a/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs b/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs index 2dec2e9cab..25fb1576d5 100644 --- a/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs +++ b/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs @@ -229,7 +229,14 @@ private void WriteEnumObjectConstant(CodeConstant codeElement, LanguageWriter wr codeEnum.Options.ToList().ForEach(x => { conventions.WriteShortDescription(x, writer); - writer.WriteLine($"{x.Name.ToFirstCharacterUpperCase()}: \"{x.WireName.SanitizeDoubleQuote()}\","); + if (codeEnum.IsNumeric) + { + writer.WriteLine($"{x.Name.ToFirstCharacterUpperCase()}: {x.WireName},"); + } + else + { + writer.WriteLine($"{x.Name.ToFirstCharacterUpperCase()}: \"{x.WireName.SanitizeDoubleQuote()}\","); + } }); writer.CloseBlock("} as const;"); } diff --git a/src/Kiota.Builder/Writers/TypeScript/CodeFunctionWriter.cs b/src/Kiota.Builder/Writers/TypeScript/CodeFunctionWriter.cs index 6e915305fe..03ac7b321b 100644 --- a/src/Kiota.Builder/Writers/TypeScript/CodeFunctionWriter.cs +++ b/src/Kiota.Builder/Writers/TypeScript/CodeFunctionWriter.cs @@ -782,9 +782,12 @@ private static string GetDefaultValueLiteralForProperty(CodeProperty codePropert if (codeProperty.Type is CodeType propertyType && propertyType.TypeDefinition is CodeEnum enumDefinition && enumDefinition.CodeEnumObject is not null) { - var codeEnumOption = enumDefinition.Options.First(x => + var codeEnumOption = enumDefinition.Options.FirstOrDefault(x => x.SymbolName.Equals(codeProperty.DefaultValue.Trim('"').CleanupSymbolName(), + StringComparison.OrdinalIgnoreCase) || + x.WireName.Equals(codeProperty.DefaultValue.Trim('"'), StringComparison.OrdinalIgnoreCase)); + if (codeEnumOption is null) return string.Empty; var enumDefault = $"{enumDefinition.CodeEnumObject.Name.ToFirstCharacterUpperCase()}.{codeEnumOption.Name.Trim('"').CleanupSymbolName().ToFirstCharacterUpperCase()}"; if (!string.IsNullOrEmpty(enumDefault) && !enumDefault.EqualsIgnoreCase("\"null\"") && IsCollectionOfEnum(codeProperty)) { From eea8cebe6bc65906bec27aba26399a78b7fad133 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Mon, 2 Nov 2026 22:55:14 +0530 Subject: [PATCH 3/4] test: add unit and writer tests for numerical enum generation --- .../Kiota.Builder.Tests/KiotaBuilderTests.cs | 167 +++++++++++++++++- .../Writers/CSharp/CodeEnumWriterTests.cs | 42 ++++- .../Writers/Go/CodeEnumWriterTests.cs | 32 +++- .../Writers/Php/CodeEnumWriterTests.cs | 17 +- .../Writers/Python/CodeEnumWriterTests.cs | 15 +- .../Writers/Ruby/CodeEnumWriterTests.cs | 14 +- .../TypeScript/CodeConstantWriterTests.cs | 17 +- 7 files changed, 297 insertions(+), 7 deletions(-) diff --git a/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs b/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs index ea63320bb2..76ada9218f 100644 --- a/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs +++ b/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs @@ -12610,4 +12610,169 @@ public async Task PerOperationUrlTemplateOverrideSetForOptionalQueryOutlierAgain Assert.NotNull(patchGenerator); Assert.False(patchGenerator.HasUrlTemplateOverride); } -} + + [Fact] + public async Task ParsesNumericalEnumInformationAsync() + { + var tempFilePath = Path.GetTempFileName(); + await using var fs = await GetDocumentStreamAsync(@"openapi: 3.0.1 +info: + title: Test Service + version: 1.0.0 +paths: + /status: + get: + responses: + '200': + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Status' +components: + schemas: + Status: + type: integer + format: int32 + enum: + - 10 + - 20 + - 30"); + var mockLogger = new Mock>(); + var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration { ClientClassName = "Graph", OpenAPIFilePath = tempFilePath }, _httpClient); + var document = await builder.CreateOpenApiDocumentAsync(fs, cancellationToken: TestContext.Current.CancellationToken); + var node = builder.CreateUriSpace(document); + var codeModel = builder.CreateSourceModel(node); + var modelsNS = codeModel.FindNamespaceByName("ApiSdk.models"); + Assert.NotNull(modelsNS); + var enumDef = modelsNS.FindChildByName("Status", false); + Assert.NotNull(enumDef); + Assert.True(enumDef.IsNumeric); + Assert.Equal("int32", enumDef.Format); + Assert.Equal(3, enumDef.Options.Count()); + var first = enumDef.Options.ElementAt(0); + Assert.Equal("10", first.SerializationName); + Assert.Equal("OneZero", first.Name); + Assert.True(first.IsNumeric); + var second = enumDef.Options.ElementAt(1); + Assert.Equal("20", second.SerializationName); + Assert.Equal("TwoZero", second.Name); + Assert.True(second.IsNumeric); + var third = enumDef.Options.ElementAt(2); + Assert.Equal("30", third.SerializationName); + Assert.Equal("ThreeZero", third.Name); + Assert.True(third.IsNumeric); + } + + [Fact] + public async Task ParsesNumericalEnumWithNegativeAndSparseValuesAsync() + { + var tempFilePath = Path.GetTempFileName(); + await using var fs = await GetDocumentStreamAsync(@"openapi: 3.0.1 +info: + title: Test Service + version: 1.0.0 +paths: + /priority: + get: + responses: + '200': + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Priority' +components: + schemas: + Priority: + type: integer + format: int64 + enum: + - -1 + - 0 + - 100"); + var mockLogger = new Mock>(); + var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration { ClientClassName = "Graph", OpenAPIFilePath = tempFilePath }, _httpClient); + var document = await builder.CreateOpenApiDocumentAsync(fs, cancellationToken: TestContext.Current.CancellationToken); + var node = builder.CreateUriSpace(document); + var codeModel = builder.CreateSourceModel(node); + var modelsNS = codeModel.FindNamespaceByName("ApiSdk.models"); + Assert.NotNull(modelsNS); + var enumDef = modelsNS.FindChildByName("Priority", false); + Assert.NotNull(enumDef); + Assert.True(enumDef.IsNumeric); + Assert.Equal("int64", enumDef.Format); + Assert.Equal(3, enumDef.Options.Count()); + var first = enumDef.Options.ElementAt(0); + Assert.Equal("-1", first.SerializationName); + Assert.Equal("minus_1", first.Name); + Assert.True(first.IsNumeric); + var second = enumDef.Options.ElementAt(1); + Assert.Equal("0", second.SerializationName); + Assert.Equal("Zero", second.Name); + Assert.True(second.IsNumeric); + var third = enumDef.Options.ElementAt(2); + Assert.Equal("100", third.SerializationName); + Assert.Equal("OneZeroZero", third.Name); + Assert.True(third.IsNumeric); + } + + [Fact] + public async Task ParsesNumericalEnumWithXMsEnumNamesAsync() + { + var tempFilePath = Path.GetTempFileName(); + await using var fs = await GetDocumentStreamAsync(@"openapi: 3.0.1 +info: + title: Test Service + version: 1.0.0 +paths: + /task: + get: + responses: + '200': + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/TaskStatus' +components: + schemas: + TaskStatus: + type: integer + format: int32 + enum: + - 10 + - 20 + x-ms-enum: + name: TaskStatus + modelAsString: false + values: + - value: 10 + name: Active + description: Active task + - value: 20 + name: Completed + description: Completed task"); + var mockLogger = new Mock>(); + var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration { ClientClassName = "Graph", OpenAPIFilePath = tempFilePath }, _httpClient); + var document = await builder.CreateOpenApiDocumentAsync(fs, cancellationToken: TestContext.Current.CancellationToken); + var node = builder.CreateUriSpace(document); + var codeModel = builder.CreateSourceModel(node); + var modelsNS = codeModel.FindNamespaceByName("ApiSdk.models"); + Assert.NotNull(modelsNS); + var enumDef = modelsNS.FindChildByName("TaskStatus", false); + Assert.NotNull(enumDef); + Assert.True(enumDef.IsNumeric); + Assert.Equal(2, enumDef.Options.Count()); + var first = enumDef.Options.ElementAt(0); + Assert.Equal("10", first.SerializationName); + Assert.Equal("Active", first.Name); + Assert.Equal("Active task", first.Documentation.DescriptionTemplate); + Assert.True(first.IsNumeric); + var second = enumDef.Options.ElementAt(1); + Assert.Equal("20", second.SerializationName); + Assert.Equal("Completed", second.Name); + Assert.Equal("Completed task", second.Documentation.DescriptionTemplate); + Assert.True(second.IsNumeric); + } +} \ No newline at end of file diff --git a/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs index b838c82917..fa147f7bb9 100644 --- a/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs @@ -168,4 +168,44 @@ public void WritesAccessModifier(AccessModifier accessModifier) AssertExtensions.CurlyBracesAreClosed(result, 1); Assert.Contains(Option.Name, result); } -} + + [Fact] + public void WritesNumericalEnumWithExplicitValues() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Active", SerializationName = "10" }); + currentEnum.AddOption(new CodeEnumOption { Name = "Inactive", SerializationName = "20" }); + currentEnum.AddOption(new CodeEnumOption { Name = "Suspended", SerializationName = "30" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("public enum SomeEnum", result); + Assert.Contains("Active = 10,", result); + Assert.Contains("Inactive = 20,", result); + Assert.Contains("Suspended = 30,", result); + Assert.Contains("[EnumMember(Value = \"10\")]", result); + } + + [Fact] + public void WritesNumericalEnumWithInt64Format() + { + currentEnum.IsNumeric = true; + currentEnum.Format = "int64"; + currentEnum.AddOption(new CodeEnumOption { Name = "BigValue", SerializationName = "9223372036854775807" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("public enum SomeEnum : long", result); + Assert.Contains("BigValue = 9223372036854775807,", result); + } + + [Fact] + public void WritesNumericalEnumWithNegativeValues() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "MinusOne", SerializationName = "-1" }); + currentEnum.AddOption(new CodeEnumOption { Name = "Zero", SerializationName = "0" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("MinusOne = -1,", result); + Assert.Contains("Zero = 0,", result); + } +} \ No newline at end of file diff --git a/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs index e8d3c2ba84..e0ec7faf7e 100644 --- a/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs @@ -232,4 +232,34 @@ public void EscapesEnumWireValues() Assert.Contains("return []string{\"line1\\\"\\nline2\"}[i]", result); Assert.Contains("case \"line1\\\"\\nline2\":", result); } -} + + [Fact] + public void WritesNumericalEnum() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "active", SerializationName = "10" }); + currentEnum.AddOption(new CodeEnumOption { Name = "inactive", SerializationName = "20" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains($"type {EnumName.ToFirstCharacterUpperCase()} int", result); + Assert.Contains("ACTIVE_SOMEENUM", result); + Assert.Contains("SomeEnum = 10", result); + Assert.Contains("INACTIVE_SOMEENUM", result); + Assert.Contains("SomeEnum = 20", result); + Assert.Contains("switch i {", result); + Assert.Contains("case ACTIVE_SOMEENUM:", result); + Assert.Contains("return \"10\"", result); + } + + [Fact] + public void WritesNumericalEnumWithInt64Format() + { + currentEnum.IsNumeric = true; + currentEnum.Format = "int64"; + currentEnum.AddOption(new CodeEnumOption { Name = "bigValue", SerializationName = "9223372036854775807" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains($"type {EnumName.ToFirstCharacterUpperCase()} int64", result); + Assert.Contains("BIGVALUE_SOMEENUM SomeEnum = 9223372036854775807", result); + } +} \ No newline at end of file diff --git a/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs index 0bbddb1681..5ee27c3067 100644 --- a/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs @@ -100,4 +100,19 @@ public async Task EscapesDollarSignInEnumWireValuesToPreventPhpInterpolationAsyn Assert.Contains("public const OPTION1 = \"\\${env('HOME')}\";", result); Assert.DoesNotContain("\"${env('HOME')}\"", result); } -} + + [Fact] + public async Task WritesNumericalEnumAsync() + { + var declaration = currentEnum.Parent as CodeNamespace; + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "active", SerializationName = "10" }); + currentEnum.AddOption(new CodeEnumOption { Name = "inactive", SerializationName = "20" }); + await ILanguageRefiner.RefineAsync(new GenerationConfiguration { Language = GenerationLanguage.PHP }, declaration, cancellationToken: TestContext.Current.CancellationToken); + _codeEnumWriter.WriteCodeElement(currentEnum, writer); + var result = tw.ToString(); + Assert.Contains("class SomeEnum extends Enum {", result); + Assert.Contains("public const ACTIVE = 10;", result); + Assert.Contains("public const INACTIVE = 20;", result); + } +} \ No newline at end of file diff --git a/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs index 1e4326db29..de92258abf 100644 --- a/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs @@ -131,4 +131,17 @@ public void RemoveInvalidDescriptionCharactersHandlesInjection(string input, str var result = Kiota.Builder.Writers.Python.PythonConventionService.RemoveInvalidDescriptionCharacters(input!); Assert.Equal(expected, result); } -} + + [Fact] + public void WritesNumericalEnum() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Active", SerializationName = "10" }); + currentEnum.AddOption(new CodeEnumOption { Name = "Inactive", SerializationName = "20" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("(int, Enum):", result); + Assert.Contains("Active = 10,", result); + Assert.Contains("Inactive = 20,", result); + } +} \ No newline at end of file diff --git a/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs index 83cc2a8bd2..9fb18db270 100644 --- a/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs @@ -104,4 +104,16 @@ public void WritesDeprecationComment() Assert.True(tag >= 0, tw.ToString()); Assert.Equal("SomeEnum = {", lines[tag + 1]); } -} + + [Fact] + public void WritesNumericalEnum() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Active", SerializationName = "10" }); + currentEnum.AddOption(new CodeEnumOption { Name = "Inactive", SerializationName = "20" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("Active: 10,", result); + Assert.Contains("Inactive: 20", result); + } +} \ No newline at end of file diff --git a/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs index a8fe910afb..2f5b9fa902 100644 --- a/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs @@ -713,4 +713,19 @@ private void AddRequestBodyParameters(bool useComplexTypeForBody = false) Optional = true, }); } -} + + [Fact] + public void WritesNumericalEnum() + { + AddCodeEnum(); + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Active", SerializationName = "10" }); + currentEnum.AddOption(new CodeEnumOption { Name = "Inactive", SerializationName = "20" }); + codeConstantWriter.WriteCodeElement(currentEnum.CodeEnumObject, writer); + var result = tw.ToString(); + Assert.Contains("export const SomeEnumObject = {", result); + Assert.Contains("Active: 10,", result); + Assert.Contains("Inactive: 20,", result); + Assert.Contains("as const;", result); + } +} \ No newline at end of file From 6cf55e2f6dd898b0d03966919fd44bcbd211c959 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Fri, 20 Nov 2026 23:58:35 +0530 Subject: [PATCH 4/4] =?UTF-8?q?=EF=BB=BFfix:=20resolve=20numeric=20enum=20?= =?UTF-8?q?review=20findings=20and=20CI=20failures?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Java defaults: format wire values as string literals for forValue(...) in CodeMethodWriter. - Fractional enums: revert to primitive floating types in C# and Go refiners, and throw in writers if encountered. - C# defaults: resolve enum default values by matching SerializationName, WireName, or Name. - Literal validation: validate numeric literals in C#, Go, Python, TypeScript, PHP, and Ruby writers to prevent code injection. - Go flags & math import: format numeric flags enums in Go without math.Pow and restrict math package import to non-numeric flags enums. - Python fractional enums: inherit from float, Enum when enum is fractional. - Tests & formatting: update MapsNumberEnumToDoubleTypeAsync for numeric enum return type, format all modified files with UTF-8 BOM, and add comprehensive unit tests. Signed-off-by: Hardik Kaurani --- src/Kiota.Builder/CodeDOM/CodeEnum.cs | 16 ++- src/Kiota.Builder/CodeDOM/CodeEnumOption.cs | 7 +- .../Extensions/OpenApiSchemaExtensions.cs | 14 ++ src/Kiota.Builder/KiotaBuilder.cs | 5 +- src/Kiota.Builder/Refiners/CSharpRefiner.cs | 1 + .../Refiners/CommonLanguageRefiner.cs | 40 ++++++ src/Kiota.Builder/Refiners/GoRefiner.cs | 3 +- .../Writers/CSharp/CodeEnumWriter.cs | 25 +++- .../Writers/CSharp/CodeMethodWriter.cs | 14 +- .../Writers/Go/CodeEnumWriter.cs | 34 ++++- .../Writers/Java/CodeMethodWriter.cs | 9 +- .../Writers/Php/CodeEnumWriter.cs | 13 +- .../Writers/Python/CodeEnumWriter.cs | 15 ++- .../Writers/Ruby/CodeEnumWriter.cs | 14 +- .../Writers/TypeScript/CodeConstantWriter.cs | 4 +- .../Kiota.Builder.Tests/KiotaBuilderTests.cs | 122 +++++++++++++++++- .../Refiners/CSharpLanguageRefinerTests.cs | 31 +++++ .../Refiners/GoLanguageRefinerTests.cs | 50 +++++++ .../Writers/CSharp/CodeEnumWriterTests.cs | 22 +++- .../Writers/CSharp/CodeMethodWriterTests.cs | 58 +++++++++ .../Writers/Go/CodeEnumWriterTests.cs | 43 +++++- .../Writers/Java/CodeMethodWriterTests.cs | 50 +++++++ .../Writers/Php/CodeEnumWriterTests.cs | 26 +++- .../Writers/Python/CodeEnumWriterTests.cs | 41 +++++- .../Writers/Ruby/CodeEnumWriterTests.cs | 26 +++- .../TypeScript/CodeConstantWriterTests.cs | 28 +++- 26 files changed, 685 insertions(+), 26 deletions(-) diff --git a/src/Kiota.Builder/CodeDOM/CodeEnum.cs b/src/Kiota.Builder/CodeDOM/CodeEnum.cs index 6c9f88ea04..87530ab319 100644 --- a/src/Kiota.Builder/CodeDOM/CodeEnum.cs +++ b/src/Kiota.Builder/CodeDOM/CodeEnum.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.Linq; @@ -21,6 +21,20 @@ public string? Format { get; set; } + private bool? _isFractional; + public bool IsFractional + { + get => _isFractional ?? (IsNumeric && ( + string.Equals(Format, "float", StringComparison.OrdinalIgnoreCase) || + string.Equals(Format, "double", StringComparison.OrdinalIgnoreCase) || + string.Equals(Format, "decimal", StringComparison.OrdinalIgnoreCase) || + Options.Any(static x => x.WireName.Contains('.', StringComparison.Ordinal) || + x.WireName.Contains('e', StringComparison.OrdinalIgnoreCase) || + (!long.TryParse(x.WireName, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out _) && + double.TryParse(x.WireName, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _))) + )); + set => _isFractional = value; + } public CodeDocumentation Documentation { get; set; } = new(); private readonly ConcurrentQueue OptionsInternal = new(); // this structure is used to maintain the order of the options diff --git a/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs b/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs index 79fb0badf7..be79d67b2f 100644 --- a/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs +++ b/src/Kiota.Builder/CodeDOM/CodeEnumOption.cs @@ -1,4 +1,4 @@ -using Kiota.Builder.Extensions; +using Kiota.Builder.Extensions; namespace Kiota.Builder.CodeDOM; @@ -6,7 +6,10 @@ public class CodeEnumOption : CodeElement, IDocumentedElement, ITypeDefinition, { /// public string SerializationName { get; set; } = string.Empty; - public bool IsNumeric { get; set; } + public bool IsNumeric + { + get; set; + } public CodeDocumentation Documentation { get; set; } = new(); /// public bool IsNameEscaped diff --git a/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs b/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs index bbaa8bf7c5..edeef3080c 100644 --- a/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs +++ b/src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; using System.Text.Json; +using System.Text.Json.Nodes; using Kiota.Builder.OpenApiExtensions; using Microsoft.OpenApi; @@ -309,6 +310,19 @@ public static bool IsEnum(this IOpenApiSchema? schema) !string.IsNullOrEmpty(value)) || x.GetValueKind() is JsonValueKind.Number); } + public static bool IsNumericEnum(this IOpenApiSchema? schema) + { + if (schema is null || schema.Enum is null || schema.Enum.Count == 0) return false; + var jsonValues = schema.Enum.OfType().ToArray(); + if (jsonValues.Length == 0 || jsonValues.Length != schema.Enum.Count) return false; + + return jsonValues.All(static x => + x.GetValueKind() is JsonValueKind.Number || + (x.GetValueKind() is JsonValueKind.String && + x.TryGetValue(out var s) && + !string.IsNullOrEmpty(s) && + decimal.TryParse(s, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _))); + } public static bool IsComposedEnum(this IOpenApiSchema? schema) { if (schema is null) return false; diff --git a/src/Kiota.Builder/KiotaBuilder.cs b/src/Kiota.Builder/KiotaBuilder.cs index 86aff14178..17e504c369 100644 --- a/src/Kiota.Builder/KiotaBuilder.cs +++ b/src/Kiota.Builder/KiotaBuilder.cs @@ -2387,8 +2387,7 @@ private CodeElement AddModelDeclarationIfDoesntExist(OpenApiUrlTreeNode currentN { enumFlagsExtension = flagsExtension; } - var isNumeric = schema.Type is JsonSchemaType.Integer or JsonSchemaType.Number - || (schema.Enum is { Count: > 0 } && schema.Enum.OfType().All(static x => x.GetValueKind() is JsonValueKind.Number)); + var isNumeric = schema.IsNumericEnum(); var newEnum = new CodeEnum { Name = declarationName, @@ -2413,7 +2412,7 @@ private static void SetEnumOptions(IOpenApiSchema schema, CodeEnum target) OpenApiEnumValuesDescriptionExtension? extensionInformation = null; if (schema.Extensions is not null && schema.Extensions.TryGetValue(OpenApiEnumValuesDescriptionExtension.Name, out var rawExtension) && rawExtension is OpenApiEnumValuesDescriptionExtension localExtInfo) extensionInformation = localExtInfo; - if (!target.IsNumeric && schema.Enum is { Count: > 0 } && schema.Enum.OfType().All(static x => x.GetValueKind() is JsonValueKind.Number)) + if (!target.IsNumeric && schema.IsNumericEnum()) { target.IsNumeric = true; target.Format ??= schema.Format; diff --git a/src/Kiota.Builder/Refiners/CSharpRefiner.cs b/src/Kiota.Builder/Refiners/CSharpRefiner.cs index 47cae5ae4e..70f0be314b 100644 --- a/src/Kiota.Builder/Refiners/CSharpRefiner.cs +++ b/src/Kiota.Builder/Refiners/CSharpRefiner.cs @@ -72,6 +72,7 @@ public override Task RefineAsync(CodeNamespace generatedCode, CancellationToken CapitalizeNamespacesFirstLetters(generatedCode); ReplaceBinaryByNativeType(generatedCode, "Stream", "System.IO"); MakeEnumPropertiesNullable(generatedCode); + RevertFractionalEnumsToPrimitives(generatedCode, "float", "double"); /* Exclude the following as their names will be capitalized making the change unnecessary in this case sensitive language * code classes, class declarations, property names, using declarations, namespace names * Exclude CodeMethod as the return type will also be capitalized (excluding the CodeType is not enough since this is evaluated at the code method level) diff --git a/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs b/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs index 446c635521..b5e5ae2f51 100644 --- a/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs +++ b/src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs @@ -1720,4 +1720,44 @@ private static void ShortenCodeElementNameIfOversized(CodeNamespace parentNamesp } } } + protected static void RevertFractionalEnumsToPrimitives(CodeElement currentElement, string floatTypeName, string doubleTypeName) + { + if (currentElement is CodeNamespace ns) + { + var fractionalEnums = ns.GetChildElements(true).OfType().Where(static x => x.IsFractional).ToArray(); + if (fractionalEnums.Length != 0) + { + var fractionalEnumSet = fractionalEnums.ToHashSet(); + ReplaceFractionalEnumReferences(currentElement, fractionalEnumSet, floatTypeName, doubleTypeName); + foreach (var fractionalEnum in fractionalEnums) + { + var parent = fractionalEnum.GetImmediateParentOfType(); + parent?.RemoveChildElement(fractionalEnum); + } + } + } + } + private static void ReplaceFractionalEnumReferences(CodeElement current, HashSet fractionalEnums, string floatTypeName, string doubleTypeName) + { + if (current is CodeProperty prop && prop.Type is CodeType propType && propType.TypeDefinition is CodeEnum propEnum && fractionalEnums.Contains(propEnum)) + { + propType.TypeDefinition = null; + propType.Name = string.Equals(propEnum.Format, "float", StringComparison.OrdinalIgnoreCase) ? floatTypeName : doubleTypeName; + propType.IsExternal = true; + prop.DefaultValue = string.Empty; + } + else if (current is CodeParameter param && param.Type is CodeType paramType && paramType.TypeDefinition is CodeEnum paramEnum && fractionalEnums.Contains(paramEnum)) + { + paramType.TypeDefinition = null; + paramType.Name = string.Equals(paramEnum.Format, "float", StringComparison.OrdinalIgnoreCase) ? floatTypeName : doubleTypeName; + paramType.IsExternal = true; + } + else if (current is CodeMethod method && method.ReturnType is CodeType returnType && returnType.TypeDefinition is CodeEnum returnEnum && fractionalEnums.Contains(returnEnum)) + { + returnType.TypeDefinition = null; + returnType.Name = string.Equals(returnEnum.Format, "float", StringComparison.OrdinalIgnoreCase) ? floatTypeName : doubleTypeName; + returnType.IsExternal = true; + } + CrawlTree(current, x => ReplaceFractionalEnumReferences(x, fractionalEnums, floatTypeName, doubleTypeName)); + } } diff --git a/src/Kiota.Builder/Refiners/GoRefiner.cs b/src/Kiota.Builder/Refiners/GoRefiner.cs index 74c2ef4481..886b962869 100644 --- a/src/Kiota.Builder/Refiners/GoRefiner.cs +++ b/src/Kiota.Builder/Refiners/GoRefiner.cs @@ -95,6 +95,7 @@ public override Task RefineAsync(CodeNamespace generatedCode, CancellationToken RemoveModelPropertiesThatDependOnSubNamespaces( generatedCode ); + RevertFractionalEnumsToPrimitives(generatedCode, "float32", "float64"); FixConstructorClashes(generatedCode, x => $"{x}Escaped"); ReplaceReservedNames( generatedCode, @@ -825,7 +826,7 @@ x.Type is CodeType pType && new (static x => x is CodeMethod @method && @method.IsOfKind(CodeMethodKind.RequestExecutor) && (method.ReturnType.Name.Equals(KiotaBuilder.UntypedNodeName, StringComparison.OrdinalIgnoreCase) || method.Parameters.Any(x => x.Kind is CodeParameterKind.RequestBody && x.Type.Name.Equals(KiotaBuilder.UntypedNodeName, StringComparison.OrdinalIgnoreCase))), SerializationNamespaceName, KiotaBuilder.UntypedNodeName), - new (static x => x is CodeEnum @enum && @enum.Flags,"", "math"), + new (static x => x is CodeEnum @enum && @enum.Flags && !@enum.IsNumeric, "", "math"), }; private const string MultipartBodyClassName = "MultipartBody"; private const string AbstractionsNamespaceName = "github.com/microsoft/kiota-abstractions-go"; diff --git a/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs index 81669e0a8e..8849d71021 100644 --- a/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CodeEnumWriter.cs @@ -19,6 +19,8 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write if (!codeElement.Options.Any()) return; + if (codeElement.IsFractional) + throw new InvalidOperationException($"Floating-point enums are not supported in C# ('{codeElement.Name}')."); var codeNamespace = codeElement.Parent as CodeNamespace; if (codeNamespace != null) { @@ -64,7 +66,9 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write if (!hasDescription) conventions.WritePragmaDisable(writer, CSharpConventionService.CS1591); if (codeElement.IsNumeric) { - writer.WriteLine($"{option.Name.ToFirstCharacterUpperCase()} = {option.SerializationName},"); + if (!TryValidateNumericLiteral(codeElement, option.SerializationName, out var validatedValue)) + throw new InvalidOperationException($"Invalid integer enum value '{option.SerializationName}' for option '{option.Name}' in enum '{codeElement.Name}'."); + writer.WriteLine($"{option.Name.ToFirstCharacterUpperCase()} = {validatedValue},"); } else { @@ -78,4 +82,23 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write } private static readonly Func GetEnumFlag = static idx => (idx == 0 ? 1 : Math.Pow(2, idx)).ToString(CultureInfo.InvariantCulture); + private static bool TryValidateNumericLiteral(CodeEnum codeElement, string rawValue, out string validatedValue) + { + if (string.Equals(codeElement.Format, "uint64", StringComparison.OrdinalIgnoreCase)) + { + if (ulong.TryParse(rawValue, NumberStyles.Integer, CultureInfo.InvariantCulture, out var ulongVal)) + { + validatedValue = ulongVal.ToString(CultureInfo.InvariantCulture); + return true; + } + } + else if (long.TryParse(rawValue, NumberStyles.Integer, CultureInfo.InvariantCulture, out var longVal)) + { + validatedValue = longVal.ToString(CultureInfo.InvariantCulture); + return true; + } + + validatedValue = string.Empty; + return false; + } } diff --git a/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs index e26ae505da..6d512e67b5 100644 --- a/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/CSharp/CodeMethodWriter.cs @@ -295,9 +295,19 @@ private void WriteConstructorBody(CodeClass parentClass, CodeMethod currentMetho .ThenBy(static x => x.Name)) { var defaultValue = propWithDefault.DefaultValue; - if (propWithDefault.Type is CodeType { TypeDefinition: CodeEnum }) + if (propWithDefault.Type is CodeType { TypeDefinition: CodeEnum enumDefinition }) { - defaultValue = $"{conventions.GetTypeString(propWithDefault.Type, currentMethod).TrimEnd('?')}.{defaultValue.Trim('"').CleanupSymbolName().ToFirstCharacterUpperCase()}"; + var rawDefault = defaultValue.Trim('"'); + var matchingOption = enumDefinition.Options.FirstOrDefault(x => + x.SerializationName.Equals(rawDefault, StringComparison.OrdinalIgnoreCase) || + x.WireName.Equals(rawDefault, StringComparison.OrdinalIgnoreCase) || + x.Name.Equals(rawDefault, StringComparison.OrdinalIgnoreCase)); + + var memberName = matchingOption is not null + ? matchingOption.Name.ToFirstCharacterUpperCase() + : rawDefault.CleanupSymbolName().ToFirstCharacterUpperCase(); + + defaultValue = $"{conventions.GetTypeString(propWithDefault.Type, currentMethod).TrimEnd('?')}.{memberName}"; } else if (propWithDefault.Type.IsNullable && defaultValue.TrimQuotes().Equals(NullValueString, StringComparison.OrdinalIgnoreCase)) diff --git a/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs index 6c062f6ee0..28bca768a0 100644 --- a/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Go/CodeEnumWriter.cs @@ -1,4 +1,5 @@ using System; +using System.Globalization; using System.Linq; using Kiota.Builder.CodeDOM; @@ -30,6 +31,9 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write writer.CloseBlock(")"); } + if (codeElement.IsFractional) + throw new InvalidOperationException($"Floating-point enums are not supported in Go ('{codeElement.Name}')."); + var typeName = codeElement.Name.ToFirstCharacterUpperCase(); writer.WriteLine(); // gofmt: exactly one blank line before each top-level declaration conventions.WriteShortDescription(codeElement, writer); @@ -53,7 +57,11 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write conventions.WriteDescriptionItem(GoConventionService.RemoveInvalidDescriptionCharacters(item.Documentation.DescriptionTemplate), writer); if (codeElement.IsNumeric) - writer.WriteLine($"{item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()} {typeName} = {item.WireName}"); + { + if (!long.TryParse(item.WireName, NumberStyles.Integer, CultureInfo.InvariantCulture, out var goIntVal)) + throw new InvalidOperationException($"Invalid integer enum value '{item.WireName}' for option '{item.Name}' in enum '{codeElement.Name}'."); + writer.WriteLine($"{item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()} {typeName} = {goIntVal.ToString(CultureInfo.InvariantCulture)}"); + } else if (isMultiValue) writer.WriteLine($"{item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()} = {(int)Math.Pow(2, power)}"); else @@ -79,7 +87,29 @@ private static void WriteStringFunction(CodeEnum codeElement, LanguageWriter wri var enumOptions = codeElement.Options.ToList(); writer.WriteLine(); // gofmt: exactly one blank line before each top-level declaration - if (codeElement.IsNumeric) + if (codeElement.IsNumeric && isMultiValue) + { + writer.StartBlock($"func (i {typeName}) String() string {{"); + writer.WriteLine("var values []string"); + writer.StartBlock("options := []struct {"); + writer.WriteLine($"val {typeName}"); + writer.WriteLine("name string"); + writer.DecreaseIndent(); + writer.StartBlock("}{"); + foreach (var item in enumOptions) + { + writer.WriteLine($"{{{item.Name.ToUpperInvariant()}_{typeName.ToUpperInvariant()}, \"{item.WireName.SanitizeDoubleQuote()}\"}},"); + } + writer.CloseBlock(); + writer.StartBlock("for _, opt := range options {"); + writer.StartBlock("if opt.val != 0 && i&opt.val == opt.val {"); + writer.WriteLine("values = append(values, opt.name)"); + writer.CloseBlock(); + writer.CloseBlock(); + writer.WriteLine("return strings.Join(values, \",\")"); + writer.CloseBlock(); + } + else if (codeElement.IsNumeric) { writer.StartBlock($"func (i {typeName}) String() string {{"); writer.StartBlock("switch i {"); diff --git a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs index b17a38a7ba..8a8c279870 100644 --- a/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs +++ b/src/Kiota.Builder/Writers/Java/CodeMethodWriter.cs @@ -394,7 +394,14 @@ private void WriteConstructorBody(CodeClass parentClass, CodeMethod currentMetho var defaultValue = propWithDefault.DefaultValue.SanitizeQuotedStringLiteral(); if (propWithDefault.Type is CodeType propertyType && propertyType.TypeDefinition is CodeEnum enumDefinition) { - defaultValue = $"{enumDefinition.Name}.forValue({defaultValue})"; + var trimmedDefault = defaultValue.Trim('"'); + var matchingOption = enumDefinition.Options.FirstOrDefault(x => + x.SerializationName.Equals(trimmedDefault, StringComparison.OrdinalIgnoreCase) || + x.WireName.Equals(trimmedDefault, StringComparison.OrdinalIgnoreCase) || + x.Name.Equals(trimmedDefault, StringComparison.OrdinalIgnoreCase)); + + var wireValue = matchingOption is not null ? matchingOption.WireName : trimmedDefault; + defaultValue = $"{enumDefinition.Name}.forValue(\"{wireValue.SanitizeDoubleQuote()}\")"; } else if (propWithDefault.Type.IsNullable && defaultValue.TrimQuotes().Equals(NullValueString, StringComparison.OrdinalIgnoreCase)) diff --git a/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs index c472b7cbf1..d60a555bc5 100644 --- a/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Php/CodeEnumWriter.cs @@ -62,7 +62,18 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write } if (codeElement?.IsNumeric ?? false) { - writer.WriteLine($"public const {constantName} = {enumProperty.WireName};"); + if (long.TryParse(enumProperty.WireName, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out var phpIntVal)) + { + writer.WriteLine($"public const {constantName} = {phpIntVal.ToString(System.Globalization.CultureInfo.InvariantCulture)};"); + } + else if (double.TryParse(enumProperty.WireName, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var phpDoubleVal)) + { + writer.WriteLine($"public const {constantName} = {phpDoubleVal.ToString(System.Globalization.CultureInfo.InvariantCulture)};"); + } + else + { + throw new InvalidOperationException($"Invalid numeric enum value '{enumProperty.WireName}' for option '{enumProperty.Name}' in enum '{codeElement.Name}'."); + } } else { diff --git a/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs index 89ae966ee2..a8fb93b721 100644 --- a/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Python/CodeEnumWriter.cs @@ -14,7 +14,7 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write ArgumentNullException.ThrowIfNull(writer); writer.WriteLine("from enum import Enum"); writer.WriteLine(); - var baseType = codeElement.IsNumeric ? (string.Equals(codeElement.Format, "float", StringComparison.OrdinalIgnoreCase) || string.Equals(codeElement.Format, "double", StringComparison.OrdinalIgnoreCase) ? "float" : "int") : "str"; + var baseType = codeElement.IsNumeric ? (codeElement.IsFractional ? "float" : "int") : "str"; writer.WriteLine($"class {codeElement.Name}({baseType}, Enum):"); conventions.WriteDeprecationWarning(codeElement, writer); writer.IncreaseIndent(); @@ -29,7 +29,18 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write conventions.WriteInLineDescription(x, writer); if (codeElement.IsNumeric) { - writer.WriteLine($"{x.Name} = {x.WireName},"); + if (codeElement.IsFractional) + { + if (!double.TryParse(x.WireName, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var doubleVal)) + throw new InvalidOperationException($"Invalid float enum value '{x.WireName}' for option '{x.Name}' in enum '{codeElement.Name}'."); + writer.WriteLine($"{x.Name} = {doubleVal.ToString(System.Globalization.CultureInfo.InvariantCulture)},"); + } + else + { + if (!long.TryParse(x.WireName, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out var longVal)) + throw new InvalidOperationException($"Invalid integer enum value '{x.WireName}' for option '{x.Name}' in enum '{codeElement.Name}'."); + writer.WriteLine($"{x.Name} = {longVal.ToString(System.Globalization.CultureInfo.InvariantCulture)},"); + } } else { diff --git a/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs b/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs index 9018aa744b..1c0604b7d5 100644 --- a/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs +++ b/src/Kiota.Builder/Writers/Ruby/CodeEnumWriter.cs @@ -23,11 +23,23 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write conventions.WriteDeprecationComment(codeElement, writer); writer.StartBlock($"{codeElement.Name.ToFirstCharacterUpperCase()} = {{"); // the value is what goes on the wire, the key is what Ruby code looks the member up by - var options = codeElement.Options.Select(x => $"{x.Name.ToFirstCharacterUpperCase()}: {(codeElement.IsNumeric ? x.WireName : RubyConventionService.ToRubyStringLiteral(x.WireName))}").ToArray(); + var options = codeElement.Options.Select(x => $"{x.Name.ToFirstCharacterUpperCase()}: {(codeElement.IsNumeric ? GetRubyNumericLiteral(codeElement, x) : RubyConventionService.ToRubyStringLiteral(x.WireName))}").ToArray(); for (var i = 0; i < options.Length; i++) writer.WriteLine(i < options.Length - 1 ? $"{options[i]}," : options[i]); writer.CloseBlock("}.freeze"); if (codeElement.Parent is CodeNamespace ns2) conventions.WriteNamespaceClosing(ns2, writer); } + private static string GetRubyNumericLiteral(CodeEnum codeElement, CodeEnumOption option) + { + if (long.TryParse(option.WireName, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out var rubyIntVal)) + { + return rubyIntVal.ToString(System.Globalization.CultureInfo.InvariantCulture); + } + if (double.TryParse(option.WireName, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var rubyDoubleVal)) + { + return rubyDoubleVal.ToString(System.Globalization.CultureInfo.InvariantCulture); + } + throw new InvalidOperationException($"Invalid numeric enum value '{option.WireName}' for option '{option.Name}' in enum '{codeElement.Name}'."); + } } diff --git a/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs b/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs index 25fb1576d5..36c63de99d 100644 --- a/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs +++ b/src/Kiota.Builder/Writers/TypeScript/CodeConstantWriter.cs @@ -231,7 +231,9 @@ private void WriteEnumObjectConstant(CodeConstant codeElement, LanguageWriter wr conventions.WriteShortDescription(x, writer); if (codeEnum.IsNumeric) { - writer.WriteLine($"{x.Name.ToFirstCharacterUpperCase()}: {x.WireName},"); + if (!double.TryParse(x.WireName, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var numVal)) + throw new InvalidOperationException($"Invalid numeric enum value '{x.WireName}' for option '{x.Name}' in enum '{codeEnum.Name}'."); + writer.WriteLine($"{x.Name.ToFirstCharacterUpperCase()}: {numVal.ToString(System.Globalization.CultureInfo.InvariantCulture)},"); } else { diff --git a/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs b/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs index 76ada9218f..44313d6b1d 100644 --- a/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs +++ b/tests/Kiota.Builder.Tests/KiotaBuilderTests.cs @@ -7992,7 +7992,10 @@ public async Task MapsNumberEnumToDoubleTypeAsync() Assert.NotNull(getRB); var getMethod = getRB.Methods.FirstOrDefault(static x => x.IsOfKind(CodeMethodKind.RequestExecutor) && "Get".Equals(x.Name, StringComparison.OrdinalIgnoreCase)); Assert.NotNull(getMethod); - Assert.Equal("double", getMethod.ReturnType.Name); + Assert.Equal("meGetResponse", getMethod.ReturnType.Name); + var enumDef = requestBuilderNS.FindChildByName("meGetResponse", false); + Assert.NotNull(enumDef); + Assert.True(enumDef.IsNumeric); } [InlineData("MV22X/MV72X", "MV22XMV72X")] [Theory] @@ -12775,4 +12778,119 @@ public async Task ParsesNumericalEnumWithXMsEnumNamesAsync() Assert.Equal("Completed task", second.Documentation.DescriptionTemplate); Assert.True(second.IsNumeric); } -} \ No newline at end of file + + [Fact] + public async Task ParsesFractionalEnumAsync() + { + var tempFilePath = Path.GetTempFileName(); + await using var fs = await GetDocumentStreamAsync(@"openapi: 3.0.1 +info: + title: Test Service + version: 1.0.0 +paths: + /rate: + get: + responses: + '200': + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Rate' +components: + schemas: + Rate: + type: number + enum: + - 1.5 + - 2.5"); + var mockLogger = new Mock>(); + var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration { ClientClassName = "Graph", OpenAPIFilePath = tempFilePath }, _httpClient); + var document = await builder.CreateOpenApiDocumentAsync(fs, cancellationToken: TestContext.Current.CancellationToken); + var node = builder.CreateUriSpace(document); + var codeModel = builder.CreateSourceModel(node); + var modelsNS = codeModel.FindNamespaceByName("ApiSdk.models"); + Assert.NotNull(modelsNS); + var enumDef = modelsNS.FindChildByName("Rate", false); + Assert.NotNull(enumDef); + Assert.True(enumDef.IsNumeric); + Assert.True(enumDef.IsFractional); + Assert.Equal(2, enumDef.Options.Count()); + Assert.Equal("1.5", enumDef.Options.ElementAt(0).SerializationName); + Assert.Equal("2.5", enumDef.Options.ElementAt(1).SerializationName); + } + + [Fact] + public async Task RejectsStringEnumEntriesUnderIntegerTypeFromBeingNumericEnumAsync() + { + var tempFilePath = Path.GetTempFileName(); + await using var fs = await GetDocumentStreamAsync(@"openapi: 3.0.1 +info: + title: Test Service + version: 1.0.0 +paths: + /status: + get: + responses: + '200': + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Status' +components: + schemas: + Status: + type: integer + enum: + - foo; drop(); + - bar"); + var mockLogger = new Mock>(); + var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration { ClientClassName = "Graph", OpenAPIFilePath = tempFilePath }, _httpClient); + var document = await builder.CreateOpenApiDocumentAsync(fs, cancellationToken: TestContext.Current.CancellationToken); + var node = builder.CreateUriSpace(document); + var codeModel = builder.CreateSourceModel(node); + var modelsNS = codeModel.FindNamespaceByName("ApiSdk.models"); + Assert.NotNull(modelsNS); + var enumDef = modelsNS.FindChildByName("Status", false); + Assert.NotNull(enumDef); + Assert.False(enumDef.IsNumeric); + } + + [Fact] + public async Task RejectsMixedEnumEntriesFromBeingNumericEnumAsync() + { + var tempFilePath = Path.GetTempFileName(); + await using var fs = await GetDocumentStreamAsync(@"openapi: 3.0.1 +info: + title: Test Service + version: 1.0.0 +paths: + /status: + get: + responses: + '200': + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Status' +components: + schemas: + Status: + type: integer + enum: + - 10 + - foo"); + var mockLogger = new Mock>(); + var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration { ClientClassName = "Graph", OpenAPIFilePath = tempFilePath }, _httpClient); + var document = await builder.CreateOpenApiDocumentAsync(fs, cancellationToken: TestContext.Current.CancellationToken); + var node = builder.CreateUriSpace(document); + var codeModel = builder.CreateSourceModel(node); + var modelsNS = codeModel.FindNamespaceByName("ApiSdk.models"); + Assert.NotNull(modelsNS); + var enumDef = modelsNS.FindChildByName("Status", false); + Assert.NotNull(enumDef); + Assert.False(enumDef.IsNumeric); + } +} diff --git a/tests/Kiota.Builder.Tests/Refiners/CSharpLanguageRefinerTests.cs b/tests/Kiota.Builder.Tests/Refiners/CSharpLanguageRefinerTests.cs index cc96e1b0aa..85c506b96d 100644 --- a/tests/Kiota.Builder.Tests/Refiners/CSharpLanguageRefinerTests.cs +++ b/tests/Kiota.Builder.Tests/Refiners/CSharpLanguageRefinerTests.cs @@ -1042,5 +1042,36 @@ public async Task AddsUsingsForUnionTypeWrapperWithNoFieldsAsync() Assert.Contains(declaration.Usings, x => x.Declaration?.Name == "System"); Assert.Contains(declaration.Usings, x => x.Declaration?.Name == "System.Collections.Generic"); } + + [Fact] + public async Task RevertsFractionalEnumsToPrimitiveAsync() + { + var fractionalEnum = root.AddEnum(new CodeEnum + { + Name = "Rate", + IsNumeric = true, + }).First(); + fractionalEnum.AddOption( + new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }, + new CodeEnumOption { Name = "TwoFive", SerializationName = "2.5" } + ); + + var model = root.AddClass(new CodeClass + { + Name = "Invoice", + Kind = CodeClassKind.Model, + }).First(); + var prop = model.AddProperty(new CodeProperty + { + Name = "rate", + Type = new CodeType { TypeDefinition = fractionalEnum }, + }).First(); + + await ILanguageRefiner.RefineAsync(new GenerationConfiguration { Language = GenerationLanguage.CSharp }, root, cancellationToken: TestContext.Current.CancellationToken); + + Assert.Null((prop.Type as CodeType)?.TypeDefinition); + Assert.Equal("double", prop.Type.Name); + Assert.DoesNotContain(root.GetChildElements(true).OfType(), x => x.Name == "Rate"); + } #endregion } diff --git a/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs b/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs index aa23f3494c..97b4f9cf23 100644 --- a/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs +++ b/tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs @@ -1403,5 +1403,55 @@ public async Task EscapesReservedKeywordsInMethodParametersAsync() Assert.DoesNotContain(method.Parameters, p => p.Name == "type"); Assert.DoesNotContain(method.Parameters, p => p.Name == "select"); } + + [Fact] + public async Task RevertsFractionalEnumsToPrimitiveAsync() + { + var fractionalEnum = root.AddEnum(new CodeEnum + { + Name = "Rate", + IsNumeric = true, + }).First(); + fractionalEnum.AddOption( + new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }, + new CodeEnumOption { Name = "TwoFive", SerializationName = "2.5" } + ); + + var model = root.AddClass(new CodeClass + { + Name = "Invoice", + Kind = CodeClassKind.Model, + }).First(); + var prop = model.AddProperty(new CodeProperty + { + Name = "rate", + Type = new CodeType { TypeDefinition = fractionalEnum }, + }).First(); + + await ILanguageRefiner.RefineAsync(new GenerationConfiguration { Language = GenerationLanguage.Go }, root, cancellationToken: TestContext.Current.CancellationToken); + + Assert.Null((prop.Type as CodeType)?.TypeDefinition); + Assert.Equal("float64", prop.Type.Name); + Assert.DoesNotContain(root.GetChildElements(true).OfType(), x => x.Name == "Rate"); + } + + [Fact] + public async Task DoesNotImportMathForNumericalFlagsEnumAsync() + { + var flagsEnum = root.AddEnum(new CodeEnum + { + Name = "Permission", + Flags = true, + IsNumeric = true, + }).First(); + flagsEnum.AddOption( + new CodeEnumOption { Name = "Read", SerializationName = "1" }, + new CodeEnumOption { Name = "Write", SerializationName = "2" } + ); + + await ILanguageRefiner.RefineAsync(new GenerationConfiguration { Language = GenerationLanguage.Go }, root, cancellationToken: TestContext.Current.CancellationToken); + + Assert.DoesNotContain(flagsEnum.Usings, x => x.Name == "math"); + } #endregion } diff --git a/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs index fa147f7bb9..5a9cb98138 100644 --- a/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/CSharp/CodeEnumWriterTests.cs @@ -208,4 +208,24 @@ public void WritesNumericalEnumWithNegativeValues() Assert.Contains("MinusOne = -1,", result); Assert.Contains("Zero = 0,", result); } -} \ No newline at end of file + + [Theory] + [InlineData("10; delete_database();")] + [InlineData("10\" or 1=1")] + [InlineData("system('calc')")] + [InlineData("abc")] + public void ThrowsOnHostileNumericValue(string hostileValue) + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Hostile", SerializationName = hostileValue }); + Assert.Throws(() => writer.Write(currentEnum)); + } + + [Fact] + public void ThrowsOnFractionalEnum() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }); + Assert.Throws(() => writer.Write(currentEnum)); + } +} diff --git a/tests/Kiota.Builder.Tests/Writers/CSharp/CodeMethodWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/CSharp/CodeMethodWriterTests.cs index 949ea1f02b..374f5a835c 100644 --- a/tests/Kiota.Builder.Tests/Writers/CSharp/CodeMethodWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/CSharp/CodeMethodWriterTests.cs @@ -2811,4 +2811,62 @@ public void WritesRequestGeneratorContentTypeQuotes() Assert.DoesNotContain('\u2028', result); Assert.DoesNotContain('\u2029', result); } + + [Fact] + public void WritesConstructorWithNumericalEnumDefaultResolvedByWireValue() + { + setup(); + var modelsNamespace = root.AddNamespace("models"); + method.Kind = CodeMethodKind.Constructor; + var codeEnum = modelsNamespace.AddEnum(new CodeEnum + { + Name = "TaskStatus", + IsNumeric = true, + }).First(); + codeEnum.AddOption( + new CodeEnumOption { Name = "Active", SerializationName = "10" }, + new CodeEnumOption { Name = "Inactive", SerializationName = "20" }, + new CodeEnumOption { Name = "MinusOne", SerializationName = "-1" }, + new CodeEnumOption { Name = "Zero", SerializationName = "0" } + ); + + parentClass.AddProperty( + new CodeProperty + { + Name = "status", + DefaultValue = "10", + Kind = CodePropertyKind.Custom, + Type = new CodeType { TypeDefinition = codeEnum } + }, + new CodeProperty + { + Name = "inactiveStatus", + DefaultValue = "20", + Kind = CodePropertyKind.Custom, + Type = new CodeType { TypeDefinition = codeEnum } + }, + new CodeProperty + { + Name = "negativeStatus", + DefaultValue = "-1", + Kind = CodePropertyKind.Custom, + Type = new CodeType { TypeDefinition = codeEnum } + }, + new CodeProperty + { + Name = "zeroStatus", + DefaultValue = "0", + Kind = CodePropertyKind.Custom, + Type = new CodeType { TypeDefinition = codeEnum } + } + ); + + writer.Write(method); + var result = tw.ToString(); + Assert.Contains("Status = global::models.TaskStatus.Active;", result); + Assert.DoesNotContain("OneZero", result); + Assert.Contains("InactiveStatus = global::models.TaskStatus.Inactive;", result); + Assert.Contains("NegativeStatus = global::models.TaskStatus.MinusOne;", result); + Assert.Contains("ZeroStatus = global::models.TaskStatus.Zero;", result); + } } diff --git a/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs index e0ec7faf7e..53442f2f57 100644 --- a/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs @@ -262,4 +262,45 @@ public void WritesNumericalEnumWithInt64Format() Assert.Contains($"type {EnumName.ToFirstCharacterUpperCase()} int64", result); Assert.Contains("BIGVALUE_SOMEENUM SomeEnum = 9223372036854775807", result); } -} \ No newline at end of file + + [Fact] + public void WritesNumericalFlagsEnum() + { + currentEnum.IsNumeric = true; + currentEnum.Flags = true; + currentEnum.AddOption(new CodeEnumOption { Name = "read", SerializationName = "1" }); + currentEnum.AddOption(new CodeEnumOption { Name = "write", SerializationName = "2" }); + currentEnum.AddOption(new CodeEnumOption { Name = "execute", SerializationName = "4" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("READ_SOMEENUM", result); + Assert.Contains("SomeEnum = 1", result); + Assert.Contains("WRITE_SOMEENUM", result); + Assert.Contains("SomeEnum = 2", result); + Assert.Contains("EXECUTE_SOMEENUM", result); + Assert.Contains("SomeEnum = 4", result); + Assert.Contains("options := []struct {", result); + Assert.Contains("strings.Join(values, \",\")", result); + Assert.DoesNotContain("math.Pow", result); + } + + [Theory] + [InlineData("10; delete_database();")] + [InlineData("10\" or 1=1")] + [InlineData("system('calc')")] + [InlineData("abc")] + public void ThrowsOnHostileNumericValue(string hostileValue) + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Hostile", SerializationName = hostileValue }); + Assert.Throws(() => writer.Write(currentEnum)); + } + + [Fact] + public void ThrowsOnFractionalEnum() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }); + Assert.Throws(() => writer.Write(currentEnum)); + } +} diff --git a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs index 336c8b2211..ac0572a729 100644 --- a/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Java/CodeMethodWriterTests.cs @@ -2577,4 +2577,54 @@ public void WritesRequestGeneratorContentTypeQuotes() var result = tw.ToString(); Assert.Contains("\"application/json; profile=\\\"CamelCase\\\"\"", result); } + + [Fact] + public void WritesConstructorWithNumericalEnumDefaultValue() + { + setup(); + var modelsNamespace = root.AddNamespace("models"); + method.Kind = CodeMethodKind.Constructor; + var codeEnum = modelsNamespace.AddEnum(new CodeEnum + { + Name = "Status", + IsNumeric = true, + }).First(); + codeEnum.AddOption( + new CodeEnumOption { Name = "Active", SerializationName = "10" }, + new CodeEnumOption { Name = "Inactive", SerializationName = "20" }, + new CodeEnumOption { Name = "MinusOne", SerializationName = "-1" }, + new CodeEnumOption { Name = "Zero", SerializationName = "0" } + ); + + parentClass.AddProperty( + new CodeProperty + { + Name = "status", + DefaultValue = "10", + Kind = CodePropertyKind.Custom, + Type = new CodeType { TypeDefinition = codeEnum } + }, + new CodeProperty + { + Name = "negativeStatus", + DefaultValue = "-1", + Kind = CodePropertyKind.Custom, + Type = new CodeType { TypeDefinition = codeEnum } + }, + new CodeProperty + { + Name = "zeroStatus", + DefaultValue = "0", + Kind = CodePropertyKind.Custom, + Type = new CodeType { TypeDefinition = codeEnum } + } + ); + + writer.Write(method); + var result = tw.ToString(); + Assert.Contains("this.setStatus(Status.forValue(\"10\"));", result); + Assert.DoesNotContain("Status.forValue(10)", result); + Assert.Contains("this.setNegativeStatus(Status.forValue(\"-1\"));", result); + Assert.Contains("this.setZeroStatus(Status.forValue(\"0\"));", result); + } } diff --git a/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs index 5ee27c3067..dac4c3bd18 100644 --- a/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Php/CodeEnumWriterTests.cs @@ -115,4 +115,28 @@ public async Task WritesNumericalEnumAsync() Assert.Contains("public const ACTIVE = 10;", result); Assert.Contains("public const INACTIVE = 20;", result); } -} \ No newline at end of file + + [Fact] + public void WritesFractionalNumericalEnum() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }); + currentEnum.AddOption(new CodeEnumOption { Name = "OneSevenFive", SerializationName = "1.75" }); + _codeEnumWriter.WriteCodeElement(currentEnum, writer); + var result = tw.ToString(); + Assert.Contains("public const ONE_FIVE = 1.5;", result); + Assert.Contains("public const ONE_SEVEN_FIVE = 1.75;", result); + } + + [Theory] + [InlineData("10; delete_database();")] + [InlineData("10\" or 1=1")] + [InlineData("system('calc')")] + [InlineData("abc")] + public void ThrowsOnHostileNumericValue(string hostileValue) + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Hostile", SerializationName = hostileValue }); + Assert.Throws(() => _codeEnumWriter.WriteCodeElement(currentEnum, writer)); + } +} diff --git a/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs index de92258abf..6bb3b984af 100644 --- a/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Python/CodeEnumWriterTests.cs @@ -144,4 +144,43 @@ public void WritesNumericalEnum() Assert.Contains("Active = 10,", result); Assert.Contains("Inactive = 20,", result); } -} \ No newline at end of file + + [Fact] + public void WritesFractionalEnumWithoutExplicitFormat() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }); + currentEnum.AddOption(new CodeEnumOption { Name = "OneSevenFive", SerializationName = "1.75" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("(float, Enum):", result); + Assert.Contains("OneFive = 1.5,", result); + Assert.Contains("OneSevenFive = 1.75,", result); + } + + [Fact] + public void WritesFractionalEnumWithExplicitFloatOrDoubleFormat() + { + currentEnum.IsNumeric = true; + currentEnum.Format = "double"; + currentEnum.AddOption(new CodeEnumOption { Name = "OneZero", SerializationName = "1.0" }); + currentEnum.AddOption(new CodeEnumOption { Name = "TwoZero", SerializationName = "2.0" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("(float, Enum):", result); + Assert.Contains("OneZero = 1,", result); + Assert.Contains("TwoZero = 2,", result); + } + + [Theory] + [InlineData("10; delete_database();")] + [InlineData("10\" or 1=1")] + [InlineData("system('calc')")] + [InlineData("abc")] + public void ThrowsOnHostileNumericValue(string hostileValue) + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Hostile", SerializationName = hostileValue }); + Assert.Throws(() => writer.Write(currentEnum)); + } +} diff --git a/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs index 9fb18db270..35d72eec7d 100644 --- a/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/Ruby/CodeEnumWriterTests.cs @@ -116,4 +116,28 @@ public void WritesNumericalEnum() Assert.Contains("Active: 10,", result); Assert.Contains("Inactive: 20", result); } -} \ No newline at end of file + + [Fact] + public void WritesFractionalNumericalEnum() + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }); + currentEnum.AddOption(new CodeEnumOption { Name = "OneSevenFive", SerializationName = "1.75" }); + writer.Write(currentEnum); + var result = tw.ToString(); + Assert.Contains("OneFive: 1.5,", result); + Assert.Contains("OneSevenFive: 1.75", result); + } + + [Theory] + [InlineData("10; delete_database();")] + [InlineData("10\" or 1=1")] + [InlineData("system('calc')")] + [InlineData("abc")] + public void ThrowsOnHostileNumericValue(string hostileValue) + { + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Hostile", SerializationName = hostileValue }); + Assert.Throws(() => writer.Write(currentEnum)); + } +} diff --git a/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs b/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs index 2f5b9fa902..ea0e897c1b 100644 --- a/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs +++ b/tests/Kiota.Builder.Tests/Writers/TypeScript/CodeConstantWriterTests.cs @@ -728,4 +728,30 @@ public void WritesNumericalEnum() Assert.Contains("Inactive: 20,", result); Assert.Contains("as const;", result); } -} \ No newline at end of file + + [Fact] + public void WritesFractionalNumericalEnum() + { + AddCodeEnum(); + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "OneFive", SerializationName = "1.5" }); + currentEnum.AddOption(new CodeEnumOption { Name = "OneSevenFive", SerializationName = "1.75" }); + codeConstantWriter.WriteCodeElement(currentEnum.CodeEnumObject, writer); + var result = tw.ToString(); + Assert.Contains("OneFive: 1.5,", result); + Assert.Contains("OneSevenFive: 1.75,", result); + } + + [Theory] + [InlineData("10; delete_database();")] + [InlineData("10\" or 1=1")] + [InlineData("system('calc')")] + [InlineData("abc")] + public void ThrowsOnHostileNumericValue(string hostileValue) + { + AddCodeEnum(); + currentEnum.IsNumeric = true; + currentEnum.AddOption(new CodeEnumOption { Name = "Hostile", SerializationName = hostileValue }); + Assert.Throws(() => codeConstantWriter.WriteCodeElement(currentEnum.CodeEnumObject, writer)); + } +}