use grandparentType to determine if in non-selected type

Author: lopert

src/methods/validate-fixture-input.ts

@@ -67,7 +67,7 @@ export function validateFixtureInput(
                 errors.push(`Cannot validate ${responseKey}: missing parent type information`);
               } else {
                 const typenameResponseKey = typenameResponseKeyStack[typenameResponseKeyStack.length - 1];
-                if (isValueExpectedForType(currentValue, parentType, schema, typenameResponseKey)) {
+                if (isValueExpectedForType(currentValue, parentType, schema, typeInfo, typenameResponseKey)) {
                   errors.push(`Missing expected fixture data for ${responseKey}`);
                 }
               }
@@ -255,6 +255,7 @@ function processNestedArrays(
  * @param fixtureValue - The fixture value to check
  * @param parentType - The parent type from typeInfo
  * @param schema - The GraphQL schema to resolve possible types for abstract types
+ * @param typeInfo - TypeInfo instance to check for abstract types in ancestry
  * @param typenameKey - The response key for the __typename field (supports aliases like `type: __typename`)
  * @returns True if the value is expected for the parent type, false otherwise
  *
@@ -263,16 +264,28 @@ function processNestedArrays(
  * is one of the possible types for that abstract type.
  * When the parent type is concrete (e.g., inside `... on ConcreteType`), only values
  * whose __typename matches the concrete type are expected.
+ *
+ * Special case: Empty objects {} are treated as valid when __typename is not selected.
+ * This handles GraphQL responses where union/interface members that don't match any
+ * selected inline fragments are returned as empty objects.
  */
 function isValueExpectedForType(
   fixtureValue: any,
   parentType: GraphQLCompositeType,
   schema: GraphQLSchema,
+  typeInfo: TypeInfo,
   typenameKey?: string
 ): boolean {
-  // If __typename wasn't selected in the query, we can't discriminate, so expect all values
+  // If __typename wasn't selected in the query, we can't discriminate
   if (!typenameKey) {
-    return true;
+    // Empty objects {} are valid if the parent field returns a union/interface
+    // Check if the grandparent type (one level back in the stack) is abstract
+    const parentStack = (typeInfo as any)._parentTypeStack;
+    const grandparentType = parentStack[parentStack.length - 2];
+    if (grandparentType && isAbstractType(grandparentType) && Object.keys(fixtureValue).length === 0) {
+      return false; // Don't expect any fields on empty objects in union/interface contexts
+    }
+    return true; // Otherwise, expect all values
   }
 
   const valueTypename = fixtureValue[typenameKey];

test/methods/validate-fixture-input.test.ts

@@ -288,6 +288,106 @@ describe("validateFixtureInput", () => {
       expect(result.errors).toHaveLength(0);
     });
 
+    it("handles empty objects in union when inline fragment doesn't match", () => {
+      const queryAST = parse(`
+        query {
+          data {
+            searchResults {
+              ... on Item {
+                id
+                count
+              }
+            }
+          }
+        }
+      `);
+
+      const fixtureInput = {
+        data: {
+          searchResults: [
+            {
+              id: "gid://test/Item/1",
+              count: 5
+            },
+            {}  // Empty object - represents Metadata that didn't match the Item fragment
+          ]
+        }
+      };
+
+      const result = validateFixtureInput(queryAST, schema, fixtureInput);
+
+      // Empty object {} is valid - GraphQL returns this for union members that don't match any fragments
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("handles empty objects in interface fragment inside union", () => {
+      const queryAST = parse(`
+        query {
+          data {
+            products {
+              ... on Purchasable {
+                price
+                currency
+              }
+            }
+          }
+        }
+      `);
+
+      const fixtureInput = {
+        data: {
+          products: [
+            {
+              price: 1000,
+              currency: "USD"
+            },
+            {}  // Empty object - GiftCard that doesn't implement Purchasable
+          ]
+        }
+      };
+
+      const result = validateFixtureInput(queryAST, schema, fixtureInput);
+
+      // Empty object {} is valid - represents a union member that doesn't implement the interface
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("handles objects with only __typename when inline fragment doesn't match", () => {
+      const queryAST = parse(`
+        query {
+          data {
+            searchResults {
+              __typename
+              ... on Item {
+                id
+                count
+              }
+            }
+          }
+        }
+      `);
+
+      const fixtureInput = {
+        data: {
+          searchResults: [
+            {
+              __typename: "Item",
+              id: "gid://test/Item/1",
+              count: 5
+            },
+            {
+              __typename: "Metadata"  // Only typename, no other fields
+            }
+          ]
+        }
+      };
+
+      const result = validateFixtureInput(queryAST, schema, fixtureInput);
+
+      // Object with only __typename is valid - Metadata doesn't match the Item fragment
+      expect(result.errors).toHaveLength(0);
+    });
+
     it("handles nested inline fragments", () => {
       const queryAST = parse(`
         query {
@@ -1053,6 +1153,38 @@ describe("validateFixtureInput", () => {
       expect(result.errors[0]).toBe('Cannot validate nonExistentField: missing type information');
     });
 
+    it("detects empty objects in non-union context", () => {
+      const queryAST = parse(`
+        query {
+          data {
+            items {
+              id
+              count
+            }
+          }
+        }
+      `);
+
+      const fixtureInput = {
+        data: {
+          items: [
+            {
+              id: "gid://test/Item/1",
+              count: 5
+            },
+            {}  // Empty object in non-union context - should error
+          ]
+        }
+      };
+
+      const result = validateFixtureInput(queryAST, schema, fixtureInput);
+
+      // Empty object {} is invalid in non-union context - missing required fields
+      expect(result.errors).toHaveLength(2);
+      expect(result.errors[0]).toBe("Missing expected fixture data for id");
+      expect(result.errors[1]).toBe("Missing expected fixture data for count");
+    });
+
     it("detects missing fields when __typename is not selected in union with inline fragments", () => {
       const queryAST = parse(`
         query {