Add test for #3369 (#5154)

Author: markerikson

packages/rtk-query-codegen-openapi/test/__snapshots__/generateEndpoints.test.ts.snap

@@ -3205,6 +3205,57 @@ export const { useGetApiV1AnimalsQuery } = injectedRtkApi;
 "
 `;
 
+exports[`tests from issues > issue #3369: discriminated unions should use enum values, not schema names 1`] = `
+"import { api } from "./tmp/emptyApi";
+const injectedRtkApi = api.injectEndpoints({
+  endpoints: (build) => ({
+    getAllowances: build.query<GetAllowancesApiResponse, GetAllowancesApiArg>({
+      query: () => ({ url: \`/api/allowances\` }),
+    }),
+    createAllowance: build.mutation<
+      CreateAllowanceApiResponse,
+      CreateAllowanceApiArg
+    >({
+      query: (queryArg) => ({
+        url: \`/api/allowances/\${queryArg.id}\`,
+        method: "POST",
+        body: queryArg.allowance,
+      }),
+    }),
+  }),
+  overrideExisting: false,
+});
+export { injectedRtkApi as enhancedApi };
+export type GetAllowancesApiResponse = /** status 200 Success */ Allowance[];
+export type GetAllowancesApiArg = void;
+export type CreateAllowanceApiResponse = /** status 201 Created */ Allowance;
+export type CreateAllowanceApiArg = {
+  id: string;
+  allowance: Allowance;
+};
+export type EngineeringAllowance = {
+  allowance_type?: "engineering";
+  distribution?: "MARECO" | "LINEAR";
+  capacity_speed_limit?: number;
+};
+export type StandardAllowance = {
+  allowance_type?: "standard";
+  default_value?: number;
+  ranges?: {
+    min?: number;
+    max?: number;
+  }[];
+};
+export type Allowance =
+  | ({
+      allowance_type: "engineering";
+    } & EngineeringAllowance)
+  | ({
+      allowance_type: "standard";
+    } & StandardAllowance);
+"
+`;
+
 exports[`yaml parsing > should be able to use read a yaml file 1`] = `
 "import { api } from "./tmp/emptyApi";
 export const addTagTypes = ["pet", "store", "user"] as const;

packages/rtk-query-codegen-openapi/test/fixtures/issue-3369-discriminator-enum.json

@@ -0,0 +1,134 @@
+{
+  "openapi": "3.0.1",
+  "info": {
+    "title": "Discriminator Enum Test - Issue 3369",
+    "description": "Test that discriminated unions use enum values (e.g., 'standard') instead of schema names (e.g., 'StandardAllowance')",
+    "version": "1.0.0"
+  },
+  "servers": [
+    {
+      "url": "https://localhost:8000"
+    }
+  ],
+  "paths": {
+    "/api/allowances": {
+      "get": {
+        "operationId": "getAllowances",
+        "summary": "Get all allowances",
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/Allowance"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/allowances/{id}": {
+      "post": {
+        "operationId": "createAllowance",
+        "summary": "Create an allowance",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Allowance"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Allowance"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "Allowance": {
+        "oneOf": [
+          {
+            "$ref": "#/components/schemas/EngineeringAllowance"
+          },
+          {
+            "$ref": "#/components/schemas/StandardAllowance"
+          }
+        ],
+        "discriminator": {
+          "propertyName": "allowance_type"
+        }
+      },
+      "EngineeringAllowance": {
+        "type": "object",
+        "properties": {
+          "allowance_type": {
+            "type": "string",
+            "enum": ["engineering"]
+          },
+          "distribution": {
+            "type": "string",
+            "enum": ["MARECO", "LINEAR"]
+          },
+          "capacity_speed_limit": {
+            "type": "number",
+            "format": "double"
+          }
+        }
+      },
+      "StandardAllowance": {
+        "type": "object",
+        "properties": {
+          "allowance_type": {
+            "type": "string",
+            "enum": ["standard"]
+          },
+          "default_value": {
+            "type": "number"
+          },
+          "ranges": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "min": {
+                  "type": "number"
+                },
+                "max": {
+                  "type": "number"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

packages/rtk-query-codegen-openapi/test/generateEndpoints.test.ts

@@ -725,6 +725,24 @@ describe('tests from issues', () => {
     });
     expect(result).toMatchSnapshot();
   });
+
+  it('issue #3369: discriminated unions should use enum values, not schema names', async () => {
+    const result = await generateEndpoints({
+      apiFile: './tmp/emptyApi.ts',
+      schemaFile: './test/fixtures/issue-3369-discriminator-enum.json',
+    });
+
+    // The discriminator value should be 'engineering' and 'standard' (from enum)
+    // NOT 'EngineeringAllowance' and 'StandardAllowance' (schema names)
+    expect(result).toContain('allowance_type: "engineering"');
+    expect(result).toContain('allowance_type: "standard"');
+
+    // Should NOT use schema names as discriminator values
+    expect(result).not.toContain('allowance_type: "EngineeringAllowance"');
+    expect(result).not.toContain('allowance_type: "StandardAllowance"');
+
+    expect(result).toMatchSnapshot();
+  });
 });
 
 describe('openapi spec', () => {