@twentyhq/people-data-labs 1.0.0 → 1.0.2

package/src/logic-functions/utils/__tests__/run-batch-enrichment.spec.ts

@@ -1,524 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { type CoreApiClient } from 'twenty-client-sdk/core';
-import { chargeCredits } from 'twenty-sdk/billing';
-
-import { UPDATE_FIELDS_OPTIONS } from 'src/constants/update-fields-options';
-import { runBatchEnrichment } from 'src/logic-functions/utils/run-batch-enrichment';
-import { type BatchEnrichmentAdapter } from 'src/types/batch-enrichment-adapter';
-import { type PdlEnrichResult } from 'src/types/pdl-enrich-result';
-
-vi.mock('twenty-sdk/billing', () => ({
-  chargeCredits: vi.fn(async () => undefined),
-}));
-
-const FAKE_COST_PER_MATCH_DOLLARS = 0.1;
-const FAKE_CREDITS_PER_MATCH_MICRO = 120_000;
-
-type FakeNode = {
-  id: string;
-  hasIdentifier: boolean;
-};
-type FakeData = { id: string };
-type FakeParams = { id: string };
-
-type BuildMatchedDataArgs = Parameters<
-  BatchEnrichmentAdapter<FakeNode, FakeData, FakeParams>['buildMatchedData']
->[0];
-
-type RecordConfig = {
-  id: string;
-  exists?: boolean;
-  hasIdentifier?: boolean;
-  outcome?: PdlEnrichResult<FakeData>;
-  updateFails?: boolean;
-  buildFails?: boolean;
-};
-
-const CLIENT = {} as CoreApiClient;
-
-const buildHarness = (configs: RecordConfig[]) => {
-  const byId = new Map(configs.map((config) => [config.id, config]));
-
-  const readRecords = vi.fn(
-    async ({
-      recordIds,
-    }: {
-      client: CoreApiClient;
-      recordIds: string[];
-    }): Promise<FakeNode[]> =>
-      recordIds
-        .map((id) => byId.get(id))
-        .filter(
-          (config): config is RecordConfig =>
-            isPresent(config) && config.exists !== false,
-        )
-        .map((config) => ({
-          id: config.id,
-          hasIdentifier: config.hasIdentifier !== false,
-        })),
-  );
-
-  const enrichBatch = vi.fn(
-    async (params: FakeParams[]): Promise<PdlEnrichResult<FakeData>[]> =>
-      params.map(
-        (param) =>
-          byId.get(param.id)?.outcome ?? {
-            outcome: 'matched',
-            httpStatus: 200,
-            data: { id: param.id },
-          },
-      ),
-  );
-
-  const updateOne = vi.fn(
-    async ({
-      recordId,
-    }: {
-      client: CoreApiClient;
-      recordId: string;
-      data: Record<string, unknown>;
-    }) => {
-      if (byId.get(recordId)?.updateFails === true) {
-        throw new Error('update failed');
-      }
-    },
-  );
-
-  const updateManyStatus = vi.fn(async () => undefined);
-
-  const buildMatchedData = vi.fn(
-    async ({
-      node,
-    }: BuildMatchedDataArgs): Promise<{
-      mappedData: Record<string, unknown>;
-      persistData: Record<string, unknown>;
-    }> => {
-      if (byId.get(node.id)?.buildFails === true) {
-        throw new Error('build failed');
-      }
-
-      return { mappedData: { mapped: node.id }, persistData: { value: node.id } };
-    },
-  );
-
-  const adapter: BatchEnrichmentAdapter<FakeNode, FakeData, FakeParams> = {
-    objectNameSingular: 'Test',
-    noIdentifierMessage: 'no identifier',
-    costPerMatchDollars: FAKE_COST_PER_MATCH_DOLLARS,
-    readRecords,
-    getNodeId: (node) => node.id,
-    extractParams: ({ node }) =>
-      node.hasIdentifier ? { id: node.id } : undefined,
-    enrichBatch,
-    buildMatchedData,
-    updateOne,
-    updateManyStatus,
-  };
-
-  return {
-    adapter,
-    readRecords,
-    enrichBatch,
-    updateOne,
-    updateManyStatus,
-    buildMatchedData,
-  };
-};
-
-const isPresent = <TValue>(value: TValue | undefined): value is TValue =>
-  value !== undefined;
-
-const records = (...ids: string[]) => ids.map((id) => ({ id }));
-
-describe('runBatchEnrichment', () => {
-  beforeEach(() => {
-    vi.mocked(chargeCredits).mockClear();
-  });
-
-  it('reads every id in one call and enriches the set in one batch', async () => {
-    const harness = buildHarness([{ id: 'a' }, { id: 'b' }]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b') },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.readRecords).toHaveBeenCalledTimes(1);
-    expect(harness.readRecords).toHaveBeenCalledWith({
-      client: CLIENT,
-      recordIds: ['a', 'b'],
-    });
-    expect(harness.enrichBatch).toHaveBeenCalledTimes(1);
-    expect(harness.enrichBatch).toHaveBeenCalledWith([{ id: 'a' }, { id: 'b' }]);
-    expect(harness.updateOne).toHaveBeenCalledTimes(2);
-    expect(result).toMatchObject({
-      total: 2,
-      matched: 2,
-      errored: 0,
-      success: true,
-    });
-  });
-
-  it('writes NOT_FOUND and ERROR statuses with batched status updates', async () => {
-    const harness = buildHarness([
-      { id: 'a', outcome: { outcome: 'not_found', httpStatus: 404 } },
-      { id: 'b', outcome: { outcome: 'not_found', httpStatus: 404 } },
-      { id: 'c', outcome: { outcome: 'error', httpStatus: 500, message: 'boom' } },
-    ]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b', 'c') },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.updateOne).not.toHaveBeenCalled();
-    expect(harness.updateManyStatus).toHaveBeenCalledWith({
-      client: CLIENT,
-      recordIds: ['c'],
-      data: {
-        pdlEnrichmentStatus: 'ERROR',
-        pdlLastEnrichedAt: expect.any(String),
-      },
-    });
-    expect(harness.updateManyStatus).toHaveBeenCalledWith({
-      client: CLIENT,
-      recordIds: ['a', 'b'],
-      data: {
-        pdlEnrichmentStatus: 'NOT_FOUND',
-        pdlLastEnrichedAt: expect.any(String),
-      },
-    });
-    expect(result).toMatchObject({ notFound: 2, errored: 1, matched: 0 });
-    expect(result.results.find((entry) => entry.recordId === 'c')?.error).toBe(
-      'boom',
-    );
-  });
-
-  it('skips no-identifier records before the PDL call', async () => {
-    const harness = buildHarness([{ id: 'a', hasIdentifier: false }, { id: 'b' }]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b') },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.enrichBatch).toHaveBeenCalledWith([{ id: 'b' }]);
-    expect(result).toMatchObject({ skipped: 1, matched: 1 });
-  });
-
-  it('maps "Yes and overwrite" to overrideExistingValues and persisting', async () => {
-    const harness = buildHarness([{ id: 'a' }]);
-
-    await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a'), updateFields: UPDATE_FIELDS_OPTIONS.overwrite },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.buildMatchedData).toHaveBeenCalledWith(
-      expect.objectContaining({ overrideExistingValues: true, shouldPersist: true }),
-    );
-  });
-
-  it('defaults to fill-empty persisting when updateFields is omitted', async () => {
-    const harness = buildHarness([{ id: 'a' }]);
-
-    await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a') },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.buildMatchedData).toHaveBeenCalledWith(
-      expect.objectContaining({
-        overrideExistingValues: false,
-        shouldPersist: true,
-      }),
-    );
-  });
-
-  it('returns mapped data without writing anything when updateFields is "No"', async () => {
-    const harness = buildHarness([
-      { id: 'a' },
-      { id: 'b', outcome: { outcome: 'not_found', httpStatus: 404 } },
-    ]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b'), updateFields: UPDATE_FIELDS_OPTIONS.no },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.buildMatchedData).toHaveBeenCalledWith(
-      expect.objectContaining({ shouldPersist: false }),
-    );
-    expect(harness.updateOne).not.toHaveBeenCalled();
-    expect(harness.updateManyStatus).not.toHaveBeenCalled();
-
-    const matched = result.results.find((entry) => entry.recordId === 'a');
-    expect(matched?.status).toBe('MATCHED');
-    expect(matched?.updatedFields).toEqual([]);
-    expect(matched?.data).toEqual({ mapped: 'a' });
-    expect(result).toMatchObject({ matched: 1, notFound: 1 });
-  });
-
-  it('marks missing records as ERROR without enriching them', async () => {
-    const harness = buildHarness([{ id: 'a' }, { id: 'b', exists: false }]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b') },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.enrichBatch).toHaveBeenCalledWith([{ id: 'a' }]);
-    expect(result.results.find((entry) => entry.recordId === 'b')).toMatchObject({
-      status: 'ERROR',
-      error: 'Test b not found',
-    });
-    expect(result).toMatchObject({ matched: 1, errored: 1 });
-  });
-
-  it('isolates a per-record matched update failure', async () => {
-    const harness = buildHarness([{ id: 'a' }, { id: 'b', updateFails: true }]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b') },
-      adapter: harness.adapter,
-    });
-
-    expect(
-      result.results.find((entry) => entry.recordId === 'a')?.status,
-    ).toBe('MATCHED');
-    expect(result.results.find((entry) => entry.recordId === 'b')).toMatchObject({
-      status: 'ERROR',
-      error: 'update failed',
-    });
-    expect(harness.updateManyStatus).toHaveBeenCalledWith({
-      client: CLIENT,
-      recordIds: ['b'],
-      data: {
-        pdlEnrichmentStatus: 'ERROR',
-        pdlLastEnrichedAt: expect.any(String),
-      },
-    });
-  });
-
-  it('marks all attempted records as ERROR and writes the status when the batch PDL call rejects', async () => {
-    const harness = buildHarness([{ id: 'a' }, { id: 'b' }]);
-    harness.enrichBatch.mockRejectedValueOnce(new Error('pdl down'));
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b') },
-      adapter: harness.adapter,
-    });
-
-    expect(result).toMatchObject({ errored: 2, matched: 0 });
-    expect(result.results[0].error).toBe('pdl down');
-    expect(harness.updateOne).not.toHaveBeenCalled();
-    expect(harness.updateManyStatus).toHaveBeenCalledWith({
-      client: CLIENT,
-      recordIds: ['a', 'b'],
-      data: {
-        pdlEnrichmentStatus: 'ERROR',
-        pdlLastEnrichedAt: expect.any(String),
-      },
-    });
-  });
-
-  it('isolates a record whose matched-data build throws', async () => {
-    const harness = buildHarness([{ id: 'a' }, { id: 'b', buildFails: true }]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b') },
-      adapter: harness.adapter,
-    });
-
-    expect(
-      result.results.find((entry) => entry.recordId === 'a')?.status,
-    ).toBe('MATCHED');
-    expect(result.results.find((entry) => entry.recordId === 'b')).toMatchObject({
-      status: 'ERROR',
-      error: 'build failed',
-    });
-    expect(harness.updateOne).toHaveBeenCalledTimes(1);
-    expect(harness.updateManyStatus).toHaveBeenCalledWith({
-      client: CLIENT,
-      recordIds: ['b'],
-      data: {
-        pdlEnrichmentStatus: 'ERROR',
-        pdlLastEnrichedAt: expect.any(String),
-      },
-    });
-  });
-
-  it('produces exactly one result per record with counts summing to the total', async () => {
-    const harness = buildHarness([
-      { id: 'matched' },
-      { id: 'notfound', outcome: { outcome: 'not_found', httpStatus: 404 } },
-      { id: 'errored', outcome: { outcome: 'error', httpStatus: 500, message: 'x' } },
-      { id: 'skipped', hasIdentifier: false },
-      { id: 'missing', exists: false },
-    ]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: {
-        records: records('matched', 'notfound', 'errored', 'skipped', 'missing'),
-      },
-      adapter: harness.adapter,
-    });
-
-    const recordIds = result.results.map((entry) => entry.recordId);
-    expect(new Set(recordIds).size).toBe(recordIds.length);
-    expect(result.results).toHaveLength(result.total);
-    expect(
-      result.matched + result.notFound + result.skipped + result.errored,
-    ).toBe(result.total);
-    expect(result).toMatchObject({
-      total: 5,
-      matched: 1,
-      notFound: 1,
-      errored: 2,
-      skipped: 1,
-      success: false,
-    });
-  });
-
-  it('deduplicates record ids', async () => {
-    const harness = buildHarness([{ id: 'a' }]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'a') },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.enrichBatch).toHaveBeenCalledWith([{ id: 'a' }]);
-    expect(result.total).toBe(1);
-  });
-
-  it('chunks large id sets into separate read and PDL calls', async () => {
-    const ids = Array.from({ length: 150 }, (_unused, index) => `r${index}`);
-    const harness = buildHarness(ids.map((id) => ({ id })));
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: ids.map((id) => ({ id })) },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.readRecords).toHaveBeenCalledTimes(2);
-    expect(harness.enrichBatch).toHaveBeenCalledTimes(2);
-    expect(result.matched).toBe(150);
-  });
-
-  it('bills only matched outcomes after the PDL call', async () => {
-    const harness = buildHarness([
-      { id: 'a' },
-      { id: 'b' },
-      { id: 'c', outcome: { outcome: 'not_found', httpStatus: 404 } },
-      { id: 'd', outcome: { outcome: 'error', httpStatus: 500, message: 'x' } },
-      { id: 'e', hasIdentifier: false },
-    ]);
-
-    await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b', 'c', 'd', 'e') },
-      adapter: harness.adapter,
-    });
-
-    expect(chargeCredits).toHaveBeenCalledExactlyOnceWith({
-      creditsUsedMicro: 2 * FAKE_CREDITS_PER_MATCH_MICRO,
-      operationType: 'CODE_EXECUTION',
-      quantity: 2,
-      resourceContext: 'pdl/test',
-    });
-  });
-
-  it('does not bill when no record matches', async () => {
-    const harness = buildHarness([
-      { id: 'a', outcome: { outcome: 'not_found', httpStatus: 404 } },
-      { id: 'b', hasIdentifier: false },
-    ]);
-
-    await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a', 'b') },
-      adapter: harness.adapter,
-    });
-
-    expect(chargeCredits).not.toHaveBeenCalled();
-  });
-
-  it('still bills a match whose record write fails', async () => {
-    const harness = buildHarness([{ id: 'a', updateFails: true }]);
-
-    await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: records('a') },
-      adapter: harness.adapter,
-    });
-
-    expect(chargeCredits).toHaveBeenCalledExactlyOnceWith(
-      expect.objectContaining({
-        creditsUsedMicro: FAKE_CREDITS_PER_MATCH_MICRO,
-        quantity: 1,
-      }),
-    );
-  });
-
-  it('bills each chunk separately', async () => {
-    const ids = Array.from({ length: 150 }, (_unused, index) => `r${index}`);
-    const harness = buildHarness(ids.map((id) => ({ id })));
-
-    await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: ids.map((id) => ({ id })) },
-      adapter: harness.adapter,
-    });
-
-    expect(chargeCredits).toHaveBeenCalledTimes(2);
-    expect(chargeCredits).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        creditsUsedMicro: 100 * FAKE_CREDITS_PER_MATCH_MICRO,
-        quantity: 100,
-      }),
-    );
-    expect(chargeCredits).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        creditsUsedMicro: 50 * FAKE_CREDITS_PER_MATCH_MICRO,
-        quantity: 50,
-      }),
-    );
-  });
-
-  it('returns an empty summary when there are no records', async () => {
-    const harness = buildHarness([]);
-
-    const result = await runBatchEnrichment({
-      client: CLIENT,
-      input: { records: [] },
-      adapter: harness.adapter,
-    });
-
-    expect(harness.readRecords).not.toHaveBeenCalled();
-    expect(result).toEqual({
-      success: true,
-      total: 0,
-      matched: 0,
-      notFound: 0,
-      skipped: 0,
-      errored: 0,
-      results: [],
-    });
-  });
-});

package/src/logic-functions/utils/__tests__/salary-transform.spec.ts

@@ -1,15 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { salaryTransform } from 'src/logic-functions/utils/salary-transform';
-
-describe('salaryTransform', () => {
-  it('maps PDL salary ranges to option values', () => {
-    expect(salaryTransform('<20,000')).toBe('UNDER_20000');
-    expect(salaryTransform('45,000-55,000')).toBe('FROM_45000_TO_55000');
-    expect(salaryTransform('>250,000')).toBe('OVER_250000');
-  });
-
-  it('returns undefined for an unknown range', () => {
-    expect(salaryTransform('weird')).toBeUndefined();
-  });
-});

package/src/logic-functions/utils/__tests__/seed-enrichment-workflow.spec.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { createCoreApiClientMock } from 'src/logic-functions/__mocks__/create-core-api-client-mock';
-import { seedEnrichmentWorkflow } from 'src/logic-functions/utils/seed-enrichment-workflow';
-import { type EnrichmentWorkflowSeed } from 'src/types/enrichment-workflow-seed';
-
-const SEED: EnrichmentWorkflowSeed = {
-  objectNameSingular: 'company',
-  workflowName: 'Enrich companies with People Data Labs',
-  triggerName: 'When companies are selected',
-  icon: 'IconSparkles',
-  stepName: 'Enrich with People Data Labs',
-  logicFunctionUniversalIdentifier: 'lf-universal-id',
-  logicFunctionInput: { records: '{{trigger.companies}}' },
-};
-
-type AnyRequest = Record<string, any>;
-
-describe('seedEnrichmentWorkflow', () => {
-  it('creates, configures and activates a new workflow', async () => {
-    const mutations: AnyRequest[] = [];
-
-    const client = createCoreApiClientMock({
-      queryResult: (request: unknown) => {
-        const req = request as AnyRequest;
-        if ('workflows' in req) {
-          return { workflows: { edges: [] } };
-        }
-        if ('workflowVersions' in req) {
-          return {
-            workflowVersions: {
-              edges: [{ node: { id: 'version-1', status: 'DRAFT' } }],
-            },
-          };
-        }
-        return {};
-      },
-      mutationResult: (request: unknown) =>
-        'createWorkflow' in (request as AnyRequest)
-          ? { createWorkflow: { id: 'workflow-1' } }
-          : {},
-      onMutation: (request) => mutations.push(request as AnyRequest),
-    });
-
-    const result = await seedEnrichmentWorkflow({
-      client,
-      logicFunctionId: 'logic-function-1',
-      seed: SEED,
-    });
-
-    expect(result).toEqual({
-      objectNameSingular: 'company',
-      workflowName: SEED.workflowName,
-      status: 'created',
-      workflowId: 'workflow-1',
-    });
-
-    const createRequest = mutations.find(
-      (request) => 'createWorkflow' in request,
-    );
-    expect(createRequest?.createWorkflow.__args.data).toEqual({
-      name: SEED.workflowName,
-    });
-
-    const updateRequest = mutations.find(
-      (request) => 'updateWorkflowVersion' in request,
-    );
-    const { id, data } = updateRequest?.updateWorkflowVersion.__args ?? {};
-    expect(id).toBe('version-1');
-
-    expect(data.trigger.type).toBe('MANUAL');
-    expect(data.trigger.settings.availability).toEqual({
-      type: 'BULK_RECORDS',
-      objectNameSingular: 'company',
-    });
-    expect(data.trigger.settings.objectType).toBe('company');
-    expect(data.trigger.nextStepIds).toEqual([]);
-    expect(data.steps).toBeUndefined();
-
-    const createStepRequest = mutations.find(
-      (request) => 'createWorkflowVersionStep' in request,
-    );
-    const createStepInput =
-      createStepRequest?.createWorkflowVersionStep.__args.input;
-    expect(createStepInput.workflowVersionId).toBe('version-1');
-    expect(createStepInput.stepType).toBe('LOGIC_FUNCTION');
-    expect(createStepInput.parentStepId).toBe('trigger');
-    expect(createStepInput.defaultSettings.input.logicFunctionId).toBe(
-      'logic-function-1',
-    );
-
-    const updateStepRequest = mutations.find(
-      (request) => 'updateWorkflowVersionStep' in request,
-    );
-    const updateStepInput =
-      updateStepRequest?.updateWorkflowVersionStep.__args.input;
-    expect(updateStepInput.workflowVersionId).toBe('version-1');
-    expect(updateStepInput.step.id).toBe(createStepInput.id);
-    expect(updateStepInput.step.type).toBe('LOGIC_FUNCTION');
-    expect(updateStepInput.step.settings.input.logicFunctionId).toBe(
-      'logic-function-1',
-    );
-    expect(updateStepInput.step.settings.input.logicFunctionInput).toEqual({
-      records: '{{trigger.companies}}',
-    });
-
-    const activateRequest = mutations.find(
-      (request) => 'activateWorkflowVersion' in request,
-    );
-    expect(
-      activateRequest?.activateWorkflowVersion.__args.workflowVersionId,
-    ).toBe('version-1');
-  });
-
-  it('skips creation when a workflow with the same name already exists', async () => {
-    const mutations: AnyRequest[] = [];
-
-    const client = createCoreApiClientMock({
-      queryResult: (request: unknown) =>
-        'workflows' in (request as AnyRequest)
-          ? { workflows: { edges: [{ node: { id: 'existing-1' } }] } }
-          : {},
-      onMutation: (request) => mutations.push(request as AnyRequest),
-    });
-
-    const result = await seedEnrichmentWorkflow({
-      client,
-      logicFunctionId: 'logic-function-1',
-      seed: SEED,
-    });
-
-    expect(result.status).toBe('skipped');
-    expect(result.workflowId).toBe('existing-1');
-    expect(mutations).toHaveLength(0);
-  });
-});

package/src/logic-functions/utils/__tests__/size-transform.spec.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { sizeTransform } from 'src/logic-functions/utils/size-transform';
-
-describe('sizeTransform', () => {
-  it('maps PDL size ranges to option values', () => {
-    expect(sizeTransform('1-10')).toBe('ONE_TO_TEN');
-    expect(sizeTransform('10001+')).toBe('TEN_THOUSAND_ONE_PLUS');
-  });
-
-  it('tolerates spacing variants', () => {
-    expect(sizeTransform('51 - 200')).toBe('FIFTY_ONE_TO_TWO_HUNDRED');
-  });
-
-  it('returns undefined for an unknown range', () => {
-    expect(sizeTransform('weird')).toBeUndefined();
-  });
-});