@twentyhq/people-data-labs 1.0.0

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

@@ -0,0 +1,524 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,18 @@
+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();
+  });
+});