@tmdb-graphql-api/resolvers 0.0.34 → 0.1.1-unstable.0

package/src/queries/configuration.test.ts

@@ -1,10 +1,10 @@
 import { jest } from '@jest/globals';
-import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CONFIGURATION_PATH } from '@tmdb-graphql-api/rest-client';
 import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
 import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
 import { type Context } from '../types.ts';
 import { resolveConfiguration } from './configuration.ts';
@@ -12,12 +12,14 @@ import { resolveConfiguration } from './configuration.ts';
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveConfiguration >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const info = {} as GraphQLResolveInfo;
 
   beforeEach(() => {
     mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH), {
@@ -27,17 +29,11 @@ describe('resolveConfiguration >', () => {
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the correct configuration base', async () => {
-    await expect(
-      resolveConfiguration(
-        undefined,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
-    ).resolves.toMatchSnapshot();
+    await expect(resolveConfiguration(undefined, undefined, context, info)).resolves.toMatchSnapshot();
   });
 });

package/src/queries/configuration.ts

@@ -1,22 +1,18 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CONFIGURATION } from '../constants.ts';
-import { type Context, type RawConfiguration } from '../types.ts';
+import { buildNoObjArgsResolver } from '../helpers/buildNoObjArgsResolver.ts';
+import { type RawConfiguration } from '../types.ts';
+
+export const resolveConfiguration = buildNoObjArgsResolver<undefined, RawConfiguration>(CONFIGURATION, async ctx => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-export const resolveConfiguration = async (
-  _obj: undefined,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
   const { data, errors, headers } = await restClient.configuration<RawConfiguration>(undefined, {
     requestID,
     tmdbGuestSessionId,
   });
 
-  if (errors?.length) {
-    throw new GraphQLError('Failed to resolve configuration.', { nodes: fieldNodes, originalError: errors[0] });
-  }
-
-  setCacheMetadata(CONFIGURATION, headers);
-  return data;
-};
+  return {
+    data,
+    errors,
+    headers,
+  };
+});

package/src/queries/configurationCountries.test.ts

@@ -1,44 +1,54 @@
 import { jest } from '@jest/globals';
-import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CONFIGURATION_PATH } from '@tmdb-graphql-api/rest-client';
 import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
 import configurationCountries from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/countries.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawConfiguration } from '../types.ts';
+import { CONFIGURATION, COUNTRIES } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveConfigurationCountries } from './configurationCountries.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveConfigurationCountries >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        configuration {
+          countries {
+            name
+          }
+        }
+      }
+    `,
+    [CONFIGURATION, COUNTRIES]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'countries' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: COUNTRIES }), {
       body: configurationCountries,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the configuration countries', async () => {
     await expect(
-      resolveConfigurationCountries(
-        configurationBase as unknown as RawConfiguration,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveConfigurationCountries(configurationBase, undefined, context, resolveInfo)
     ).resolves.toMatchSnapshot();
   });
 });

package/src/queries/configurationCountries.ts

@@ -1,27 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CONFIGURATION, COUNTRIES } from '../constants.ts';
-import { type Context, type RawConfiguration, type RawConfigurationCountries } from '../types.ts';
+import { buildNoObjArgsResolver } from '../helpers/buildNoObjArgsResolver.ts';
+import { type RawConfiguration, type RawConfigurationCountries } from '../types.ts';
 
-export const resolveConfigurationCountries = async (
-  _obj: RawConfiguration,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  const { data, errors, headers } = await restClient.configuration<RawConfigurationCountries>(
-    {
-      pathTemplateData: { type: COUNTRIES },
-    },
-    { requestID, tmdbGuestSessionId }
-  );
+export const resolveConfigurationCountries = buildNoObjArgsResolver<RawConfiguration, RawConfigurationCountries>(
+  CONFIGURATION,
+  async ctx => {
+    const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${COUNTRIES}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+    const { data, errors, headers } = await restClient.configuration<RawConfigurationCountries>(
+      {
+        pathTemplateData: { type: COUNTRIES },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
 
-  setCacheMetadata(`${CONFIGURATION}.${COUNTRIES}`, headers);
-  return data;
-};
+    return {
+      data,
+      errors,
+      headers,
+    };
+  }
+);

package/src/queries/configurationJobs.test.ts

@@ -1,44 +1,54 @@
 import { jest } from '@jest/globals';
-import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CONFIGURATION_PATH } from '@tmdb-graphql-api/rest-client';
 import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
 import configurationJobs from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/jobs.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawConfiguration } from '../types.ts';
+import { CONFIGURATION, JOBS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveConfigurationJobs } from './configurationJobs.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveConfigurationJobs >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        configuration {
+          jobs {
+            department
+          }
+        }
+      }
+    `,
+    [CONFIGURATION, JOBS]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'jobs' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: JOBS }), {
       body: configurationJobs,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the configuration jobs', async () => {
     await expect(
-      resolveConfigurationJobs(
-        configurationBase as unknown as RawConfiguration,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveConfigurationJobs(configurationBase, undefined, context, resolveInfo)
     ).resolves.toMatchSnapshot();
   });
 });

package/src/queries/configurationJobs.ts

@@ -1,27 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CONFIGURATION, JOBS } from '../constants.ts';
-import { type Context, type RawConfiguration, type RawConfigurationJobs } from '../types.ts';
+import { buildNoObjArgsResolver } from '../helpers/buildNoObjArgsResolver.ts';
+import { type RawConfiguration, type RawConfigurationJobs } from '../types.ts';
 
-export const resolveConfigurationJobs = async (
-  _obj: RawConfiguration,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  const { data, errors, headers } = await restClient.configuration<RawConfigurationJobs>(
-    {
-      pathTemplateData: { type: JOBS },
-    },
-    { requestID, tmdbGuestSessionId }
-  );
+export const resolveConfigurationJobs = buildNoObjArgsResolver<RawConfiguration, RawConfigurationJobs>(
+  CONFIGURATION,
+  async ctx => {
+    const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${JOBS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+    const { data, errors, headers } = await restClient.configuration<RawConfigurationJobs>(
+      {
+        pathTemplateData: { type: JOBS },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
 
-  setCacheMetadata(`${CONFIGURATION}.${JOBS}`, headers);
-  return data;
-};
+    return {
+      data,
+      errors,
+      headers,
+    };
+  }
+);

package/src/queries/configurationLanguages.test.ts

@@ -1,44 +1,54 @@
 import { jest } from '@jest/globals';
-import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CONFIGURATION_PATH } from '@tmdb-graphql-api/rest-client';
 import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
 import configurationLanguages from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/languages.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawConfiguration } from '../types.ts';
+import { CONFIGURATION, LANGUAGES } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveConfigurationLanguages } from './configurationLanguages.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveConfigurationLanguages >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        configuration {
+          languages {
+            name
+          }
+        }
+      }
+    `,
+    [CONFIGURATION, LANGUAGES]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'languages' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: LANGUAGES }), {
       body: configurationLanguages,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the configuration languages', async () => {
     await expect(
-      resolveConfigurationLanguages(
-        configurationBase as unknown as RawConfiguration,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveConfigurationLanguages(configurationBase, undefined, context, resolveInfo)
     ).resolves.toMatchSnapshot();
   });
 });

package/src/queries/configurationLanguages.ts

@@ -1,27 +1,23 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { CONFIGURATION, LANGUAGES } from '../constants.ts';
-import { type Context, type RawConfiguration, type RawConfigurationLanguages } from '../types.ts';
+import { buildNoObjArgsResolver } from '../helpers/buildNoObjArgsResolver.ts';
+import { type RawConfiguration, type RawConfigurationLanguages } from '../types.ts';
 
-export const resolveConfigurationLanguages = async (
-  _obj: RawConfiguration,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
-  const { data, errors, headers } = await restClient.configuration<RawConfigurationLanguages>(
-    {
-      pathTemplateData: { type: LANGUAGES },
-    },
-    { requestID, tmdbGuestSessionId }
-  );
+export const resolveConfigurationLanguages = buildNoObjArgsResolver<RawConfiguration, RawConfigurationLanguages>(
+  CONFIGURATION,
+  async ctx => {
+    const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${LANGUAGES}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
+    const { data, errors, headers } = await restClient.configuration<RawConfigurationLanguages>(
+      {
+        pathTemplateData: { type: LANGUAGES },
+      },
+      { requestID, tmdbGuestSessionId }
+    );
 
-  setCacheMetadata(`${CONFIGURATION}.${LANGUAGES}`, headers);
-  return data;
-};
+    return {
+      data,
+      errors,
+      headers,
+    };
+  }
+);

package/src/queries/configurationPrimaryTranslations.test.ts

@@ -1,44 +1,53 @@
 import { jest } from '@jest/globals';
-import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CONFIGURATION_PATH } from '@tmdb-graphql-api/rest-client';
 import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
 import configurationPrimaryTranslations from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/primaryTranslations.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
+import { snakeCase } from 'lodash-es';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawConfiguration } from '../types.ts';
+import { CONFIGURATION, PRIMARY_TRANSLATIONS } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveConfigurationPrimaryTranslations } from './configurationPrimaryTranslations.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveConfigurationPrimaryTranslations >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        configuration {
+          primaryTranslations
+        }
+      }
+    `,
+    [CONFIGURATION, PRIMARY_TRANSLATIONS]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'primary_translations' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: snakeCase(PRIMARY_TRANSLATIONS) }), {
       body: configurationPrimaryTranslations,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the configuration primary translations', async () => {
     await expect(
-      resolveConfigurationPrimaryTranslations(
-        configurationBase as unknown as RawConfiguration,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveConfigurationPrimaryTranslations(configurationBase, undefined, context, resolveInfo)
     ).resolves.toMatchSnapshot();
   });
 });

package/src/queries/configurationPrimaryTranslations.ts

@@ -1,14 +1,14 @@
-import { GraphQLError, type GraphQLResolveInfo } from 'graphql';
 import { snakeCase } from 'lodash-es';
 import { CONFIGURATION, PRIMARY_TRANSLATIONS } from '../constants.ts';
-import { type Context, type RawConfiguration, type RawConfigurationPrimaryTranslations } from '../types.ts';
+import { buildNoObjArgsResolver } from '../helpers/buildNoObjArgsResolver.ts';
+import { type RawConfiguration, type RawConfigurationPrimaryTranslations } from '../types.ts';
+
+export const resolveConfigurationPrimaryTranslations = buildNoObjArgsResolver<
+  RawConfiguration,
+  RawConfigurationPrimaryTranslations
+>(CONFIGURATION, async ctx => {
+  const { requestID, restClient, tmdbGuestSessionId } = ctx;
 
-export const resolveConfigurationPrimaryTranslations = async (
-  _obj: RawConfiguration,
-  _args: undefined,
-  { requestID, restClient, setCacheMetadata, tmdbGuestSessionId }: Context,
-  { fieldNodes }: GraphQLResolveInfo
-) => {
   const { data, errors, headers } = await restClient.configuration<RawConfigurationPrimaryTranslations>(
     {
       pathTemplateData: { type: snakeCase(PRIMARY_TRANSLATIONS) },
@@ -16,13 +16,9 @@ export const resolveConfigurationPrimaryTranslations = async (
     { requestID, tmdbGuestSessionId }
   );
 
-  if (errors?.length) {
-    throw new GraphQLError(`Failed to resolve ${CONFIGURATION} ${PRIMARY_TRANSLATIONS}.`, {
-      nodes: fieldNodes,
-      originalError: errors[0],
-    });
-  }
-
-  setCacheMetadata(`${CONFIGURATION}.${PRIMARY_TRANSLATIONS}`, headers);
-  return data;
-};
+  return {
+    data,
+    errors,
+    headers,
+  };
+});

package/src/queries/configurationTimezones.test.ts

@@ -1,44 +1,54 @@
 import { jest } from '@jest/globals';
-import { CONFIGURATION_PATH, type ShortcutMethodNames } from '@tmdb-graphql-api/rest-client';
+import { CONFIGURATION_PATH } from '@tmdb-graphql-api/rest-client';
 import configurationBase from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/base.json';
 import configurationTimezones from '@tmdb-graphql-api/test-utils/responses/themoviedb/configuration/timezones.json';
 import { mockFetch } from 'fetch-mocked';
-import { type Getta, type ShortcutProperties } from 'getta';
-import { type GraphQLResolveInfo } from 'graphql';
 import { buildEndpoint } from '../__testUtils__/helpers/buildEndpoint.ts';
+import { buildResolveInfoArgument } from '../__testUtils__/helpers/buildResolveInfoArg.ts';
+import { createMockLogger } from '../__testUtils__/helpers/createMockLogger.ts';
 import { createRestClient } from '../__testUtils__/helpers/createRestClient.ts';
-import { type Context, type RawConfiguration } from '../types.ts';
+import { CONFIGURATION, TIMEZONES } from '../constants.ts';
+import { type Context } from '../types.ts';
 import { resolveConfigurationTimezones } from './configurationTimezones.ts';
 
 const mockedFetch = mockFetch(jest.fn);
 
 describe('resolveConfigurationTimezones >', () => {
-  let restClient: Getta & ShortcutProperties<ShortcutMethodNames>;
-  const setCacheMetadata = jest.fn();
+  const context = {
+    logger: createMockLogger(jest.fn),
+    restClient: createRestClient(),
+    setCacheMetadata: jest.fn(),
+    tmdbGuestSessionId: 'mock-tmdbGuestSessionId',
+  } as unknown as Context;
 
-  beforeAll(() => {
-    restClient = createRestClient();
-  });
+  const resolveInfo = buildResolveInfoArgument(
+    `
+      {
+        configuration {
+          timezones {
+            zones
+          }
+        }
+      }
+    `,
+    [CONFIGURATION, TIMEZONES]
+  );
 
   beforeEach(() => {
-    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: 'timezones' }), {
+    mockedFetch.mockGetOnce(buildEndpoint(CONFIGURATION_PATH, { type: TIMEZONES }), {
       body: configurationTimezones,
     });
   });
 
   afterEach(async () => {
     mockedFetch.mockReset();
-    await restClient.cache?.clear();
+    await context.restClient.cache?.clear();
+    jest.clearAllMocks();
   });
 
   it('should return the configuration timezones', async () => {
     await expect(
-      resolveConfigurationTimezones(
-        configurationBase as unknown as RawConfiguration,
-        undefined,
-        { restClient, setCacheMetadata, tmdbGuestSessionId: 'mock-tmdbGuestSessionId' } as unknown as Context,
-        {} as GraphQLResolveInfo
-      )
+      resolveConfigurationTimezones(configurationBase, undefined, context, resolveInfo)
     ).resolves.toMatchSnapshot();
   });
 });