import { mockCustomTaskCreateInput } from '@/__mocks__/generated/graphql';
import { CREATE_TASK } from '@/services/customTasks';
import { PactTestServerConfig } from '@/utils/pact-constants';
import { ApolloClient, HttpLink, InMemoryCache } from '@apollo/client';
import { GraphQLInteraction, Pact } from '@pact-foundation/pact';
import fetch from 'cross-fetch';
import * as path from 'path';

const mockVariables = { input: mockCustomTaskCreateInput() };
const EXPECTED_RESPONSE = mockVariables.input;

let client: ApolloClient<unknown>;

// Create a 'pact' between the two applications in the integration we are testing
const provider = new Pact({
  log: path.resolve(process.cwd(), 'logs', 'mockserver-integration.log'),
  dir: path.resolve(process.cwd(), './../pacts'),
  consumer: 'company-app',
  provider: 'custom-tasks',
  port: PactTestServerConfig.Port,
});

beforeAll(async () => {
  await provider.setup();
});

describe('custom task', () => {
  beforeAll(() => {
    client = new ApolloClient({
      cache: new InMemoryCache({ addTypename: false }),
      uri: `<http://127.0.0.1>:${PactTestServerConfig.Port}/graphql`,
      link: new HttpLink({
        uri: `<http://127.0.0.1>:${PactTestServerConfig.Port}/graphql`,
        fetch,
      }),
    });

    // Arrange: Setup our expected interactions
    const graphqlMutation = new GraphQLInteraction()
      .uponReceiving('a request to create a custom task')
      .withOperation('CreateCustomTask')
      //@ts-expect-error gql can be undefined
      .withMutation(CREATE_TASK.loc.source.body)
      .withRequest({
        method: 'POST',
        path: '/graphql',
        headers: {
          'Content-Type': 'application/json',
        },
      })
      .withVariables(mockVariables)
      .willRespondWith({
        status: 200,
        headers: { 'Content-Type': 'application/json' },
        body: {
          data: {
            createCustomTask: EXPECTED_RESPONSE,
          },
        },
      });

    return provider.addInteraction(graphqlMutation);
  });

  afterAll(async () => {
    await provider.verify();
    await provider.finalize();
  });

  it('should retrieve a created task', async () => {
    try {
      const results = await client.mutate({
        mutation: CREATE_TASK,
        variables: mockVariables,
      });
      expect(results.data.createCustomTask).toEqual(EXPECTED_RESPONSE);
      console.log('results', EXPECTED_RESPONSE);
    } catch (error) {
      console.log('error inside catch', error);
    }
  });
});

.withMutation(
        `
      mutation CreateCustomTask($input: CustomTaskCreateInput!) {
        createCustomTask(input: $input) {
          entityId
          enabled
          description
          required
          name
          link
          title
          instructions
          requireUpload
          uploads {
            id
            filename
            mimetype
            encoding
            url
          }
        }
      }
    `
      )