// ❌ The test boundary problem — this test proves nothing about the full execution
// The parent resolver may return a different shape than { id: string }
import { resolvers } from './resolvers';

describe('User.orders resolver (unit)', () => {
  it('loads orders for a user', async () => {
    const mockContext = {
      ordersLoader: { load: jest.fn().mockResolvedValue([{ id: 'o1', total: 99 }]) },
    };
    const result = await resolvers.User.orders({ id: 'u1' }, {}, mockContext, {} as any);
    expect(result).toHaveLength(1);
    // ✅ This test passes. But what if the actual parent resolver returns { userId: 'u1' }
    // instead of { id: 'u1' }? The DataLoader gets 'undefined' as the key — silent failure.
  });
});

// ✅ Correct resolver unit test — verify the exact shape contract with the parent
import { resolvers } from './resolvers';
import { GraphQLResolveInfo } from 'graphql';

describe('User.orders resolver (unit)', () => {
  const mockInfo = {} as GraphQLResolveInfo;

  it('calls ordersLoader with user.id (string, not number)', async () => {
    const mockLoad = jest.fn().mockResolvedValue([{ id: 'o1', total: 99.00 }]);
    const ctx = { ordersLoader: { load: mockLoad } };

    // The 'parent' object is exactly what the parent resolver returns
    // Test the exact shape your schema produces, not a generic object
    await resolvers.User.orders({ id: 'u1', name: 'Alice', email: 'alice@example.com' }, {}, ctx, mockInfo);

    // Verify the key type is string, not number — DataLoader is type-sensitive
    expect(mockLoad).toHaveBeenCalledWith('u1');
    expect(typeof mockLoad.mock.calls[0][0]).toBe('string');
  });

  it('returns empty array (not null) when user has no orders', async () => {
    const ctx = { ordersLoader: { load: jest.fn().mockResolvedValue([]) } };
    const result = await resolvers.User.orders({ id: 'u2', name: 'Bob', email: '' }, {}, ctx, mockInfo);

    // ✅ Verify [] not null — the client schema says [Order!]!, null propagation
    expect(result).toEqual([]);
    expect(result).not.toBeNull();
  });
});

// ✅ Integration test using graphql() execute — no HTTP, full resolver chain
import { graphql, buildSchema } from 'graphql';
import { makeExecutableSchema } from '@graphql-tools/schema';
import { resolvers } from './resolvers';
import { typeDefs } from './schema';

// Build the schema once for the test suite
const schema = makeExecutableSchema({ typeDefs, resolvers });

describe('GetUserWithOrders (integration)', () => {
  // Create fresh DataLoader mocks per test — same as per-request context
  function createTestContext() {
    return {
      user: { id: 'u1', canViewOrder: () => true },
      ordersLoader: {
        load: jest.fn().mockResolvedValue([
          { id: 'o1', total: 99.00, status: 'SHIPPED', items: [] },
        ]),
      },
      db: {
        users: {
          findById: jest.fn().mockResolvedValue({ id: 'u1', name: 'Alice', email: 'alice@example.com' }),
        },
      },
    };
  }

  it('returns user name and orders in a single execution', async () => {
    const ctx = createTestContext();

    // graphql() executes the full resolver chain:
    // Query.user → User.name → User.orders → Order.total
    // No HTTP, no network — but the complete execution graph is exercised
    const result = await graphql({
      schema,
      source: `
        query GetUserWithOrders($id: ID!) {
          user(id: $id) {
            name
            orders {
              total
              status
            }
          }
        }
      `,
      contextValue: ctx,
      variableValues: { id: 'u1' },
    });

    // Verify no errors in the execution
    expect(result.errors).toBeUndefined();
    expect(result.data?.user).toEqual({
      name: 'Alice',
      orders: [{ total: 99.00, status: 'SHIPPED' }],
    });

    // Verify DataLoader was called with the correct key type
    expect(ctx.ordersLoader.load).toHaveBeenCalledWith('u1');
  });

  it('returns null for user field when user does not exist', async () => {
    const ctx = createTestContext();
    ctx.db.users.findById = jest.fn().mockResolvedValue(null);

    const result = await graphql({
      schema,
      source: `query { user(id: "nonexistent") { name } }`,
      contextValue: ctx,
    });

    // Null user → null propagation, no errors array entry
    expect(result.errors).toBeUndefined();
    expect(result.data?.user).toBeNull();
  });

  it('returns errors array when authentication fails', async () => {
    const ctx = { ...createTestContext(), user: null }; // unauthenticated

    const result = await graphql({
      schema,
      source: `query GetUser($id: ID!) { user(id: $id) { name } }`,
      contextValue: ctx,
      variableValues: { id: 'u1' },
    });

    expect(result.errors).toHaveLength(1);
    expect(result.errors?.[0].extensions?.code).toBe('UNAUTHENTICATED');
  });
});

// ✅ Schema snapshot test — fails if the SDL changes unexpectedly
import { printSchema, buildSchema } from 'graphql';
import { schema } from './schema';

describe('Schema Contract (snapshot)', () => {
  it('schema SDL has not changed unexpectedly', () => {
    // Any change to the schema — adding, removing, or modifying a type or field —
    // will cause this test to fail, forcing a conscious review and snapshot update
    expect(printSchema(schema)).toMatchSnapshot();
  });
});

// ✅ Operation document validation — client operation documents must be valid against schema
import { parse, validate } from 'graphql';
import { schema } from './schema';
import { readFileSync, readdirSync } from 'fs';
import { join } from 'path';

describe('Client Operation Contracts', () => {
  const operationsDir = join(__dirname, '../operations');

  it('all client operation documents are valid against the current schema', () => {
    const files = readdirSync(operationsDir).filter(f => f.endsWith('.graphql'));

    for (const file of files) {
      const source = readFileSync(join(operationsDir, file), 'utf8');
      const document = parse(source);
      const errors = validate(schema, document);

      // Each file is expected to have zero validation errors
      expect(errors).toHaveLength(0);
      // If this fails: a schema change broke a client operation document —
      // the same class of error that rover graph check catches in CI
    }
  });
});

// ✅ Subscription resolver testing with mocked AsyncIterator
import { createAsyncIterator } from 'iterall';

describe('orderStatusChanged subscription', () => {
  it('delivers the resolved order when the PubSub emits', async () => {
    const mockOrder = { id: 'o1', status: 'SHIPPED', total: 99 };

    // Create a mock AsyncIterator that yields one event and then completes
    const mockPubSub = {
      subscribe: jest.fn().mockReturnValue(
        createAsyncIterator([{ orderStatusChanged: mockOrder }])
      ),
    };

    const ctx = { pubsub: mockPubSub, user: { canViewOrder: () => true } };

    // Test the subscribe function returns the expected iterator
    const iterator = await resolvers.Subscription.orderStatusChanged.subscribe(
      undefined,
      { orderId: 'o1' },
      ctx,
      {} as any
    );

    // Consume one value from the iterator
    const { value, done } = await iterator.next();
    expect(value).toEqual({ orderStatusChanged: mockOrder });

    // Test the resolve function transforms the payload
    const resolved = resolvers.Subscription.orderStatusChanged.resolve(value, {}, ctx, {} as any);
    expect(resolved).toEqual(mockOrder);
  });
});

// ✅ graphql-yoga v5 buildHTTPExecutor — full HTTP stack without a running server
import { createYoga } from 'graphql-yoga';
import { buildHTTPExecutor } from '@graphql-tools/executor-http';
import { schema } from './schema';

describe('HTTP integration (graphql-yoga)', () => {
  const yoga = createYoga({ schema });
  const executor = buildHTTPExecutor({ fetch: yoga.fetch });

  it('returns user data via HTTP executor', async () => {
    const result = await executor({
      document: parse(`query GetUser($id: ID!) { user(id: $id) { name } }`),
      variables: { id: 'u1' },
    });

    // The executor handles the full yoga request/response cycle
    // including content-type negotiation and error serialization
    expect(result.data?.user?.name).toBe('Alice');
  });
});