fix(java): Fix java wire tests for sdks with oauth (#11335)

* updates

* update java version

* Automated update of seed files

---------

Co-authored-by: jsklan <[email protected]>

Author: jsklan

generators/java-v2/ast/src/ast/Type.ts

@@ -395,7 +395,7 @@ export class Type extends AstNode {
     }
 
     private writeIterable({ writer, iterable }: { writer: Writer; iterable: Iterable }): void {
-        writer.writeNode(OptionalClassReference);
+        writer.writeNode(IterableClassReference);
         writer.write("<");
         iterable.value.write(writer);
         writer.write(">");
@@ -462,3 +462,8 @@ export const InputStreamClassReference = new ClassReference({
     name: "InputStream",
     packageName: "java.io"
 });
+
+export const IterableClassReference = new ClassReference({
+    name: "Iterable",
+    packageName: "java.lang"
+});

generators/java-v2/ast/src/ast/TypeLiteral.ts

@@ -673,7 +673,9 @@ export class TypeLiteral extends AstNode {
         }
 
         if (values.length === 0) {
-            writer.write(`new ${classReference.name}<`);
+            writer.write("new ");
+            writer.writeNode(classReference);
+            writer.write("<");
             writer.writeNode(iterable.valueType);
             writer.write(">()");
             return;

generators/java-v2/dynamic-snippets/src/EndpointSnippetGenerator.ts

@@ -141,16 +141,106 @@ export class EndpointSnippetGenerator {
         endpoint: FernIr.dynamic.Endpoint;
         snippet: FernIr.dynamic.EndpointSnippetRequest;
     }): java.CodeBlock {
+        // For OAuth APIs, use withCredentials() instead of builder()
+        const isOAuth = endpoint.auth?.type === "oauth";
+
         return java.codeblock((writer) => {
             writer.writeNode(this.context.getRootClientClassReference());
             writer.write(` ${CLIENT_VAR_NAME} = `);
-            writer.writeNode(
-                java.TypeLiteral.builder({
-                    classReference: this.context.getRootClientClassReference(),
-                    parameters: this.getRootClientBuilderArgs({ endpoint, snippet })
-                })
+
+            if (isOAuth && snippet.auth?.type === "oauth") {
+                // OAuth: use withCredentials(clientId, clientSecret) pattern
+                const oauthValues = snippet.auth as FernIr.dynamic.OAuthValues;
+                writer.writeNode(this.context.getRootClientClassReference());
+                writer.write(`.withCredentials("${oauthValues.clientId}", "${oauthValues.clientSecret}")`);
+                writer.writeNewLineIfLastLineNot();
+                writer.indent();
+
+                // Add remaining builder args (url, environment, headers, etc.)
+                const otherArgs = this.getRootClientBuilderArgsExcludingAuth({ endpoint, snippet });
+                for (const arg of otherArgs) {
+                    writer.write(`.${arg.name}(`);
+                    if (!arg.value.shouldWriteInLine()) {
+                        writer.newLine();
+                    }
+                    writer.writeNode(arg.value);
+                    if (!arg.value.shouldWriteInLine()) {
+                        writer.newLine();
+                    }
+                    writer.writeLine(")");
+                }
+
+                writer.writeLine(".build()");
+                writer.dedent();
+            } else {
+                // Standard builder() pattern
+                writer.writeNode(
+                    java.TypeLiteral.builder({
+                        classReference: this.context.getRootClientClassReference(),
+                        parameters: this.getRootClientBuilderArgs({ endpoint, snippet })
+                    })
+                );
+            }
+        });
+    }
+
+    private getRootClientBuilderArgsExcludingAuth({
+        endpoint,
+        snippet
+    }: {
+        endpoint: FernIr.dynamic.Endpoint;
+        snippet: FernIr.dynamic.EndpointSnippetRequest;
+    }): java.BuilderParameter[] {
+        const builderArgs: java.BuilderParameter[] = [];
+
+        // Skip auth - it's handled by withCredentials()
+
+        const baseUrlArg = this.getRootClientBaseUrlArg({
+            baseUrl: snippet.baseURL,
+            environment: snippet.environment
+        });
+        if (baseUrlArg != null) {
+            builderArgs.push(baseUrlArg);
+        }
+        this.context.errors.scope(Scope.Headers);
+        if (this.context.ir.headers != null && snippet.headers != null) {
+            builderArgs.push(
+                ...this.getRootClientHeaderArgs({ headers: this.context.ir.headers, values: snippet.headers })
             );
+        }
+        this.context.errors.unscope();
+
+        const usedVariables = new Set<string>();
+        const allPathParams = [...(this.context.ir.pathParameters ?? []), ...(endpoint.request.pathParameters ?? [])];
+
+        allPathParams.forEach((param) => {
+            if (param.variable != null) {
+                usedVariables.add(param.variable);
+            }
         });
+
+        if (this.context.ir.variables != null && this.context.ir.variables.length > 0) {
+            for (const variable of this.context.ir.variables) {
+                if (usedVariables.has(variable.id)) {
+                    const variableName = variable.name.camelCase.unsafeName;
+                    builderArgs.push({
+                        name: variableName,
+                        value: java.TypeLiteral.string(`YOUR_${variable.name.screamingSnakeCase.unsafeName}`)
+                    });
+                }
+            }
+        }
+
+        this.context.errors.scope(Scope.PathParameters);
+        if (this.context.ir.pathParameters != null && this.context.ir.pathParameters.length > 0) {
+            const apiPathParams = this.context.ir.pathParameters.filter((param) => param.variable == null);
+            if (apiPathParams.length > 0) {
+                builderArgs.push(...this.getPathParameters({ namedParameters: apiPathParams, snippet }));
+            }
+        }
+        this.context.errors.unscope();
+
+        return builderArgs;
     }
 
     private buildFullCodeBlock({ body, options }: { body: java.CodeBlock; options: Options }): java.AstNode {

generators/java-v2/sdk/src/sdk-wire-tests/SdkWireTestGenerator.ts

@@ -484,35 +484,11 @@ export class SdkWireTestGenerator {
         let transformedSnippet = snippet;
 
         const isStreamingEndpoint = endpoint.response?.body?.type === "streaming";
-        const methodCamel = endpoint.name.camelCase.safeName;
-        const methodPascal = endpoint.name.pascalCase.safeName;
-        const requestPascal = methodPascal + "Request";
-        const streamRequestPascal = methodPascal + "StreamRequest";
 
         if (isStreamingEndpoint) {
-            // For streaming endpoints, ensure method name ends with "Stream"
-            // Only add suffix if it doesn't already end with "Stream"
-            if (!methodCamel.endsWith("Stream")) {
-                const nonStreamingMethodPattern = new RegExp(`\\.${methodCamel}\\s*\\(`, "g");
-                transformedSnippet = transformedSnippet.replace(nonStreamingMethodPattern, `.${methodCamel}Stream(`);
-            }
-
-            // For request types, only add "Stream" suffix if not already present
-            if (!methodPascal.endsWith("Stream")) {
-                const nonStreamingRequestPattern = new RegExp(`\\b${requestPascal}\\b`, "g");
-                transformedSnippet = transformedSnippet.replace(nonStreamingRequestPattern, streamRequestPascal);
-            }
-
             // For streaming endpoints, replace Optional<ResponseType> with Iterable<ResponseType>
+            // The Java SDK generator uses Iterable for streaming responses, not Optional
             transformedSnippet = transformedSnippet.replace(/Optional</g, "Iterable<");
-        } else {
-            // For non-streaming endpoints, ensure method name does NOT end with "Stream"
-            // Remove "Stream" suffix if present
-            const streamingMethodPattern = new RegExp(`\\.${methodCamel}Stream\\s*\\(`, "g");
-            transformedSnippet = transformedSnippet.replace(streamingMethodPattern, `.${methodCamel}(`);
-
-            const streamingRequestPattern = new RegExp(`\\b${streamRequestPascal}\\b`, "g");
-            transformedSnippet = transformedSnippet.replace(streamingRequestPattern, requestPascal);
         }
 
         if (endpoint.name.originalName === "listUsernames") {

generators/java-v2/sdk/src/sdk-wire-tests/builders/TestClassBuilder.ts

@@ -69,17 +69,26 @@ export class TestClassBuilder {
             // Note: For OAuth APIs, each test method enqueues its own OAuth token response
             // because the token is fetched lazily on first API call
 
-            writer.writeLine(`client = ${clientClassName}.builder()`);
-            writer.indent();
-
-            this.generateEnvironmentConfiguration(writer);
+            // For OAuth APIs, use withCredentials() instead of builder()
+            const isOAuth = this.isOAuthApi();
+            if (isOAuth) {
+                writer.writeLine(`client = ${clientClassName}.withCredentials("test-client-id", "test-client-secret")`);
+                writer.indent();
+                this.generateEnvironmentConfiguration(writer);
+                writer.writeLine(".build();");
+            } else {
+                writer.writeLine(`client = ${clientClassName}.builder()`);
+                writer.indent();
+
+                this.generateEnvironmentConfiguration(writer);
+
+                const authConfig = this.getAuthClientBuilderCalls();
+                if (authConfig) {
+                    writer.writeLine(authConfig);
+                }
 
-            const authConfig = this.getAuthClientBuilderCalls();
-            if (authConfig) {
-                writer.writeLine(authConfig);
+                writer.writeLine(".build();");
             }
-
-            writer.writeLine(".build();");
             writer.dedent();
             writer.dedent();
             writer.writeLine("}");

generators/java-v2/sdk/src/sdk-wire-tests/builders/TestMethodBuilder.ts

@@ -96,6 +96,16 @@ export class TestMethodBuilder {
             writer.writeLine("Assertions.assertNotNull(request);");
             writer.writeLine(`Assertions.assertEquals("${endpoint.method}", request.getMethod());`);
 
+            // For OAuth APIs, validate that the Authorization header contains the Bearer token
+            if (isOAuth) {
+                writer.writeLine("");
+                writer.writeLine("// Validate OAuth Authorization header");
+                writer.writeLine(
+                    'Assertions.assertEquals("Bearer test-token", request.getHeader("Authorization"), ' +
+                        '"OAuth Authorization header should contain Bearer token from OAuth flow");'
+                );
+            }
+
             this.headerValidator.generateHeaderValidation(writer, testExample);
 
             if (expectedRequestJson !== undefined && expectedRequestJson !== null) {

generators/java/sdk/versions.yml

@@ -1,3 +1,13 @@
+# yaml-language-server: $schema=../../../fern-versions-yml.schema.json
+
+- version: 3.27.3
+  changelogEntry:
+    - summary: |
+        Fix streaming endpoint return types to use Iterable instead of Optional, fix missing ArrayList import for empty list literals, and fix OAuth wire tests to use withCredentials() pattern.
+      type: fix
+  createdAt: "2025-12-18"
+  irVersion: 61
+
 - version: 3.27.2
   changelogEntry:
     - summary: |