test(ruby): assert request body for parameter-group dispatchers

Tests previously stubbed the URL but never verified the wire body, so
the silent-drop bug fixed in b87038b — `update_organization_membership`
shipping a PUT with no body when only the `role` group managed it —
slipped past the suite. Two changes catch this class of regression:

- `buildCallArgsStub` now passes optional parameter groups too, not
  just required ones. The old behavior left the dispatcher code path
  unexercised whenever a group was optional, hiding the bug entirely.

- New `buildBodyMatcher` emits a webmock `.with(body: hash_including(...))`
  matcher whenever an operation has any parameter group dispatched into
  the body. The matcher includes required non-group body fields plus
  the first variant's wire-name leaves, so any mismatch (missing body,
  dropped variant leaf, wrong wire name) fails the test.

Verified by temporarily reverting b87038b: the regenerated
`test_update_organization_membership` errors with
`WebMock::NetConnectNotAllowedError` because the request body is empty
and doesn't match the stub. Restoring the fix makes it pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: gjtorikian

src/ruby/tests.ts

@@ -77,24 +77,24 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
  const resolved = lookupResolved(op, lookup);
  const hiddenParams = buildHiddenParams(resolved);
  const callArgs = buildCallArgsStub(op, modelByName, hiddenParams);
+ const bodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams);
 
  // Collect method info for the parameterized 401 test (T20).
  authMethodManifest.push({ method, httpMethodSym, stubUrl, callArgs });
 
  const stubRegex = stubUrlRegex(stubUrl);
  lines.push(`  def test_${method}_returns_expected_result`);
+ lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
+ if (bodyMatcher) lines.push(`      .with(body: ${bodyMatcher})`);
  if (isList) {
- lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
  lines.push(`      .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)`);
  lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
  lines.push('    assert_kind_of WorkOS::Types::ListStruct, result');
  } else if (op.response.kind === 'primitive') {
- lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
  lines.push(`      .to_return(body: "{}", status: 200)`);
  lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
  lines.push('    assert_nil result');
  } else {
- lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
  lines.push(`      .to_return(body: "{}", status: 200)`);
  lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
  lines.push('    refute_nil result');
@@ -331,9 +331,11 @@ function buildCallArgsStub(op: Operation, modelByName: Map<string, Model>, hidde
  parts.push(`${name}: ${stubValueFor(q.type)}`);
  }
 
- // Required parameter group kwargs: instantiate the first variant's class.
+ // Parameter group kwargs (required and optional): instantiate the first
+ // variant's class. Optional groups are exercised too so the dispatcher
+ // code path is covered — passing nothing would skip the body block and
+ // hide silent-drop bugs (see workos/oagen-emitters#66).
  for (const group of op.parameterGroups ?? []) {
- if (group.optional) continue;
  const name = fieldName(group.name);
  if (seen.has(name)) continue;
  seen.add(name);
@@ -348,6 +350,58 @@ function buildCallArgsStub(op: Operation, modelByName: Map<string, Model>, hidde
  return parts.join(', ');
 }
 
+/**
+ * Build a Ruby `hash_including(...)` matcher describing the wire body the
+ * SDK should send for an operation whose body is constructed (in part) by a
+ * parameter-group dispatcher. Returns `null` for operations without body
+ * groups — those are still stubbed without a body matcher.
+ *
+ * The matcher includes every required non-group body field plus the first
+ * variant's wire-name leaves for each group dispatched into the body. This
+ * catches regressions where the dispatcher silently drops a passed group
+ * (the original `update_organization_membership` regression).
+ */
+function buildBodyMatcher(op: Operation, modelByName: Map<string, Model>, hiddenParams: Set<string>): string | null {
+ const httpMethod = op.httpMethod.toLowerCase();
+ const hasBodyMethod = !['get', 'head', 'delete'].includes(httpMethod);
+ const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
+ if (!hasBodyMethod || !hasGroups) return null;
+
+ const groupedParamNames = new Set<string>();
+ for (const group of op.parameterGroups ?? []) {
+ for (const variant of group.variants) {
+ for (const p of variant.parameters) groupedParamNames.add(p.name);
+ }
+ }
+
+ const entries: string[] = [];
+
+ // Required non-group body fields, keyed by wire name.
+ if (op.requestBody) {
+ const bodyModel = resolveBodyModel(op.requestBody, modelByName);
+ if (bodyModel) {
+ for (const f of bodyModel.fields) {
+ if (!f.required) continue;
+ if (hiddenParams.has(f.name)) continue;
+ if (groupedParamNames.has(f.name)) continue;
+ entries.push(`"${f.name}" => ${stubValueFor(f.type)}`);
+ }
+ }
+ }
+
+ // First variant of each group: its leaves get pumped into the body.
+ for (const group of op.parameterGroups ?? []) {
+ const firstVariant = group.variants[0];
+ if (!firstVariant) continue;
+ for (const p of firstVariant.parameters) {
+ entries.push(`"${p.name}" => ${stubValueFor(p.type)}`);
+ }
+ }
+
+ if (entries.length === 0) return null;
+ return `hash_including(${entries.join(', ')})`;
+}
+
 function resolveBodyModel(ref: TypeRef, modelByName: Map<string, Model>): Model | null {
  if (ref.kind === 'model') return modelByName.get(ref.name) ?? null;
  if (ref.kind === 'nullable') return resolveBodyModel(ref.inner, modelByName);