@postman-cse/onboarding-bootstrap 0.11.0 → 0.13.0

package/tests/postman-assets-client.test.ts

@@ -1,268 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { PostmanAssetsClient } from '../src/lib/postman/postman-assets-client.js';
-
-function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
-  return new Response(JSON.stringify(body), {
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    ...init
-  });
-}
-
-describe('PostmanAssetsClient', () => {
-  it('uses the public Postman API base URL by default', () => {
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test'
-    });
-
-    expect(client.getBaseUrl()).toBe('https://api.getpostman.com');
-  });
-
-  it('creates a workspace and enforces team visibility', async () => {
-    const fetchImpl = vi
-      .fn<typeof fetch>()
-      .mockResolvedValueOnce(
-        jsonResponse({
-          workspace: {
-            id: 'ws-123'
-          }
-        })
-      )
-      .mockResolvedValueOnce(
-        jsonResponse({
-          workspace: {
-            id: 'ws-123',
-            visibility: 'private'
-          }
-        })
-      )
-      .mockResolvedValueOnce(
-        jsonResponse({
-          workspace: {
-            id: 'ws-123',
-            visibility: 'team'
-          }
-        })
-      );
-
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.createWorkspace('Core Banking', 'desc')).resolves.toEqual({
-      id: 'ws-123'
-    });
-    expect(fetchImpl).toHaveBeenCalledTimes(3);
-    expect(fetchImpl).toHaveBeenNthCalledWith(
-      3,
-      'https://api.getpostman.com/workspaces/ws-123',
-      expect.objectContaining({
-        method: 'PUT'
-      })
-    );
-  });
-
-  it('normalizes collection tags to valid Postman slugs', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response(null, {
-        status: 204
-      })
-    );
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await client.tagCollection('col-123', ['Generated Smoke', 'core banking']);
-
-    expect(fetchImpl).toHaveBeenCalledWith(
-      'https://api.getpostman.com/collections/col-123/tags',
-      expect.objectContaining({
-        method: 'PUT',
-        body: JSON.stringify({
-          tags: [{ slug: 'generated-smoke' }, { slug: 'core-banking' }]
-        })
-      })
-    );
-  });
-
-  it('returns existing spec content when available', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(
-      jsonResponse({ content: 'openapi: 3.1.0' })
-    );
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.getSpecContent('spec-123')).resolves.toBe('openapi: 3.1.0');
-  });
-
-  it('returns undefined when fetching existing spec content fails', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(
-      new Response('not found', { status: 404 })
-    );
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.getSpecContent('spec-123')).resolves.toBeUndefined();
-  });
-
-  it('creates a workspace with targetTeamId in the payload for org-mode', async () => {
-    const fetchImpl = vi
-      .fn<typeof fetch>()
-      .mockResolvedValueOnce(
-        jsonResponse({
-          workspace: {
-            id: 'ws-org-123'
-          }
-        })
-      )
-      .mockResolvedValueOnce(
-        jsonResponse({
-          workspace: {
-            id: 'ws-org-123',
-            visibility: 'team'
-          }
-        })
-      );
-
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.createWorkspace('Org WS', 'desc', 132319)).resolves.toEqual({
-      id: 'ws-org-123'
-    });
-    expect(fetchImpl).toHaveBeenCalledTimes(2);
-    expect(fetchImpl).toHaveBeenNthCalledWith(
-      1,
-      'https://api.getpostman.com/workspaces',
-      expect.objectContaining({
-        method: 'POST',
-        body: JSON.stringify({
-          workspace: {
-            about: 'desc',
-            name: 'Org WS',
-            type: 'team',
-            teamId: 132319
-          }
-        })
-      })
-    );
-  });
-
-  it('creates a workspace without teamId when targetTeamId is not provided', async () => {
-    const fetchImpl = vi
-      .fn<typeof fetch>()
-      .mockResolvedValueOnce(
-        jsonResponse({
-          workspace: { id: 'ws-no-team' }
-        })
-      )
-      .mockResolvedValueOnce(
-        jsonResponse({
-          workspace: { id: 'ws-no-team', visibility: 'team' }
-        })
-      );
-
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.createWorkspace('Regular WS', 'desc')).resolves.toEqual({
-      id: 'ws-no-team'
-    });
-    expect(fetchImpl).toHaveBeenNthCalledWith(
-      1,
-      'https://api.getpostman.com/workspaces',
-      expect.objectContaining({
-        body: JSON.stringify({
-          workspace: {
-            about: 'desc',
-            name: 'Regular WS',
-            type: 'team'
-          }
-        })
-      })
-    );
-  });
-
-  it('throws actionable error for org-mode workspace creation failure', async () => {
-    const errorBody = JSON.stringify({
-      error: {
-        name: 'invalidParamError',
-        message: 'Only personal workspaces (internal) can be created outside team'
-      }
-    });
-    const fetchImpl = vi.fn<typeof fetch>().mockImplementation(
-      async () => new Response(errorBody, { status: 400 })
-    );
-
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.createWorkspace('Org WS', 'desc')).rejects.toThrow(
-      'workspace-team-id'
-    );
-  });
-
-  it('returns parsed sub-teams from getTeams', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(
-      jsonResponse({
-        data: [
-          { id: 132109, name: 'Field Services', handle: 'fs', organizationId: 13347347 },
-          { id: 132118, name: 'Customer Education', handle: 'ce', organizationId: 13347347 },
-          { id: 132272, name: 'RonCorp', handle: 'rc', organizationId: 13347347 }
-        ]
-      })
-    );
-
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    const teams = await client.getTeams();
-    expect(teams).toEqual([
-      { id: 132109, name: 'Field Services', handle: 'fs', organizationId: 13347347 },
-      { id: 132118, name: 'Customer Education', handle: 'ce', organizationId: 13347347 },
-      { id: 132272, name: 'RonCorp', handle: 'rc', organizationId: 13347347 }
-    ]);
-  });
-
-  it('returns empty array from getTeams when no teams exist', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(
-      jsonResponse({ data: [] })
-    );
-
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.getTeams()).resolves.toEqual([]);
-  });
-
-  it('propagates errors from getTeams without swallowing', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValueOnce(
-      new Response('Forbidden', { status: 403 })
-    );
-
-    const client = new PostmanAssetsClient({
-      apiKey: 'pmak-test',
-      fetchImpl
-    });
-
-    await expect(client.getTeams()).rejects.toThrow();
-  });
-});

package/tests/retry.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it, vi, afterEach } from 'vitest';
-
-import { retry } from '../src/lib/retry.js';
-
-describe('retry', () => {
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('retries failed operations and resolves on a later success', async () => {
-    vi.useFakeTimers();
-
-    const operation = vi
-      .fn<() => Promise<string>>()
-      .mockRejectedValueOnce(new Error('first failure'))
-      .mockResolvedValueOnce('ok');
-
-    const onRetry = vi.fn();
-    const promise = retry(operation, {
-      maxAttempts: 3,
-      delayMs: 250,
-      onRetry
-    });
-
-    await vi.advanceTimersByTimeAsync(250);
-
-    await expect(promise).resolves.toBe('ok');
-    expect(operation).toHaveBeenCalledTimes(2);
-    expect(onRetry).toHaveBeenCalledTimes(1);
-    expect(onRetry).toHaveBeenCalledWith(
-      expect.objectContaining({
-        attempt: 1,
-        delayMs: 250
-      })
-    );
-  });
-
-  it('stops retrying when shouldRetry rejects the error', async () => {
-    vi.useFakeTimers();
-
-    const operation = vi
-      .fn<() => Promise<string>>()
-      .mockRejectedValue(new Error('fatal'));
-
-    const promise = retry(operation, {
-      maxAttempts: 4,
-      delayMs: 500,
-      shouldRetry: () => false
-    });
-
-    await expect(promise).rejects.toThrow('fatal');
-    expect(operation).toHaveBeenCalledTimes(1);
-  });
-});

package/tests/secrets.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { HttpError } from '../src/lib/http-error.js';
-import {
-  REDACTED,
-  redactSecrets,
-  sanitizeHeaders
-} from '../src/lib/secrets.js';
-
-describe('secret safety rails', () => {
-  it('redacts configured secret values from freeform text', () => {
-    const sanitized = redactSecrets(
-      'Authorization: Bearer token-123 and key pmak-secret',
-      ['token-123', 'pmak-secret']
-    );
-
-    expect(sanitized).toBe(`Authorization: Bearer ${REDACTED} and key ${REDACTED}`);
-  });
-
-  it('sanitizes headers before surfacing them', () => {
-    const headers = sanitizeHeaders(
-      {
-        Authorization: 'Bearer token-123',
-        'x-api-key': 'pmak-secret',
-        'x-trace-id': 'trace-token-123'
-      },
-      ['token-123', 'pmak-secret']
-    );
-
-    expect(headers).toEqual({
-      authorization: REDACTED,
-      'x-api-key': REDACTED,
-      'x-trace-id': `trace-${REDACTED}`
-    });
-  });
-
-  it('builds sanitized HTTP diagnostics without leaking token material', () => {
-    const error = new HttpError({
-      method: 'POST',
-      url: 'https://example.test/resource?token=token-123',
-      status: 401,
-      statusText: 'Unauthorized',
-      requestHeaders: {
-        Authorization: 'Bearer token-123',
-        'x-api-key': 'pmak-secret'
-      },
-      responseBody: 'token-123 rejected with api key pmak-secret',
-      secretValues: ['token-123', 'pmak-secret']
-    });
-
-    expect(error.message).not.toContain('token-123');
-    expect(error.message).not.toContain('pmak-secret');
-    expect(error.toJSON()).toEqual({
-      method: 'POST',
-      name: 'HttpError',
-      requestHeaders: {
-        authorization: REDACTED,
-        'x-api-key': REDACTED
-      },
-      responseBody: `${REDACTED} rejected with api key ${REDACTED}`,
-      status: 401,
-      statusText: 'Unauthorized',
-      url: `https://example.test/resource?token=${REDACTED}`
-    });
-  });
-});

package/tests/workspace-selection.test.ts

@@ -1,301 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import {
-  chooseCanonicalWorkspace,
-  resolveCanonicalWorkspaceSelection
-} from '../src/lib/postman/workspace-selection.js';
-import { normalizeGitRepoUrl } from '../src/lib/postman/postman-assets-client.js';
-
-describe('normalizeGitRepoUrl', () => {
-  it('returns empty string for empty input', () => {
-    expect(normalizeGitRepoUrl('')).toBe('');
-    expect(normalizeGitRepoUrl(null)).toBe('');
-    expect(normalizeGitRepoUrl(undefined)).toBe('');
-  });
-
-  it('normalizes GitHub HTTPS URLs', () => {
-    expect(normalizeGitRepoUrl('https://github.com/Postman-CS/my-repo')).toBe(
-      'https://github.com/postman-cs/my-repo'
-    );
-  });
-
-  it('normalizes GitLab HTTPS URLs', () => {
-    expect(normalizeGitRepoUrl('https://gitlab.com/Org-Name/My-Repo')).toBe(
-      'https://gitlab.com/org-name/my-repo'
-    );
-  });
-
-  it('strips .git from GitLab URLs', () => {
-    expect(normalizeGitRepoUrl('https://gitlab.com/org/repo.git')).toBe(
-      'https://gitlab.com/org/repo'
-    );
-  });
-
-  it('converts GitLab SSH URLs to HTTPS', () => {
-    expect(normalizeGitRepoUrl('git@gitlab.com:org/repo.git')).toBe(
-      'https://gitlab.com/org/repo'
-    );
-  });
-
-  it('handles self-hosted GitLab instances', () => {
-    expect(normalizeGitRepoUrl('https://git.example.com/team/project.git')).toBe(
-      'https://git.example.com/team/project'
-    );
-    expect(normalizeGitRepoUrl('git@git.example.com:team/project.git')).toBe(
-      'https://git.example.com/team/project'
-    );
-  });
-
-  it('strips trailing .git from GitHub URLs', () => {
-    expect(normalizeGitRepoUrl('https://github.com/postman-cs/my-repo.git')).toBe(
-      'https://github.com/postman-cs/my-repo'
-    );
-  });
-
-  it('converts GitHub SSH URLs to HTTPS', () => {
-    expect(normalizeGitRepoUrl('git@github.com:postman-cs/my-repo.git')).toBe(
-      'https://github.com/postman-cs/my-repo'
-    );
-  });
-});
-
-describe('chooseCanonicalWorkspace', () => {
-  const repoUrl = 'https://github.com/postman-cs/core-payments';
-
-  it('returns create when no matching workspaces exist', () => {
-    const result = chooseCanonicalWorkspace({
-      repoUrl,
-      matchingWorkspaces: []
-    });
-    expect(result).toEqual({ type: 'create' });
-  });
-
-  it('returns existing with linked_match when exactly one workspace is linked to the repo', () => {
-    const result = chooseCanonicalWorkspace({
-      repoUrl,
-      matchingWorkspaces: [
-        { id: 'ws-abc', linkedRepoUrl: repoUrl }
-      ]
-    });
-    expect(result).toEqual({
-      type: 'existing',
-      workspaceId: 'ws-abc',
-      source: 'linked_match',
-      warning: undefined
-    });
-  });
-
-  it('emits a warning when linked workspace differs from repo var workspace', () => {
-    const result = chooseCanonicalWorkspace({
-      repoUrl,
-      repoWorkspaceId: 'ws-old',
-      matchingWorkspaces: [
-        { id: 'ws-new', linkedRepoUrl: repoUrl }
-      ]
-    });
-    expect(result.type).toBe('existing');
-    if (result.type === 'existing') {
-      expect(result.workspaceId).toBe('ws-new');
-      expect(result.source).toBe('linked_match');
-      expect(result.warning).toContain('ws-old');
-      expect(result.warning).toContain('ws-new');
-    }
-  });
-
-  it('returns manual_review when multiple workspaces are linked to the same repo', () => {
-    const result = chooseCanonicalWorkspace({
-      repoUrl,
-      matchingWorkspaces: [
-        { id: 'ws-1', linkedRepoUrl: repoUrl },
-        { id: 'ws-2', linkedRepoUrl: repoUrl }
-      ]
-    });
-    expect(result.type).toBe('manual_review');
-    if (result.type === 'manual_review') {
-      expect(result.reason).toContain('ws-1');
-      expect(result.reason).toContain('ws-2');
-    }
-  });
-
-  it('keeps repo var workspace when multiple linked workspaces exist and one matches', () => {
-    const result = chooseCanonicalWorkspace({
-      repoUrl,
-      repoWorkspaceId: 'ws-1',
-      matchingWorkspaces: [
-        { id: 'ws-1', linkedRepoUrl: repoUrl },
-        { id: 'ws-2', linkedRepoUrl: repoUrl }
-      ]
-    });
-    expect(result.type).toBe('existing');
-    if (result.type === 'existing') {
-      expect(result.workspaceId).toBe('ws-1');
-      expect(result.source).toBe('linked_match');
-    }
-  });
-
-  it('returns existing with repo_var when no linked match but repo var is set', () => {
-    const result = chooseCanonicalWorkspace({
-      repoWorkspaceId: 'ws-3',
-      repoUrl,
-      matchingWorkspaces: []
-    });
-
-    expect(result).toEqual({
-      type: 'existing',
-      workspaceId: 'ws-3',
-      source: 'repo_var'
-    });
-  });
-
-  it('returns create when repo var workspace matches by name but is linked to a different repository', () => {
-    const result = chooseCanonicalWorkspace({
-      repoWorkspaceId: 'ws-stale',
-      repoUrl,
-      matchingWorkspaces: [
-        {
-          id: 'ws-stale',
-          linkedRepoUrl: 'https://github.com/postman-cs/different-repo'
-        }
-      ]
-    });
-
-    expect(result).toEqual({ type: 'create' });
-  });
-
-  it('returns existing with name_match when no linked match and no repo var', () => {
-    const result = chooseCanonicalWorkspace({
-      repoUrl,
-      matchingWorkspaces: [{ id: 'ws-7' }]
-    });
-    expect(result).toEqual({
-      type: 'existing',
-      workspaceId: 'ws-7',
-      source: 'name_match'
-    });
-  });
-
-  it('picks the lexicographically first workspace on name_match when multiple exist', () => {
-    const result = chooseCanonicalWorkspace({
-      repoUrl,
-      matchingWorkspaces: [
-        { id: 'ws-zzz', linkedRepoUrl: null },
-        { id: 'ws-aaa', linkedRepoUrl: null }
-      ]
-    });
-    expect(result.type).toBe('existing');
-    if (result.type === 'existing') {
-      expect(result.workspaceId).toBe('ws-aaa');
-    }
-  });
-});
-
-describe('resolveCanonicalWorkspaceSelection', () => {
-  const repoUrl = 'https://github.com/postman-cs/core-payments';
-  const workspaceName = '[AF] core-payments';
-
-  it('returns create when no workspaces match by name', async () => {
-    const postman = {
-      findWorkspacesByName: vi.fn().mockResolvedValue([]),
-      getWorkspaceGitRepoUrl: vi.fn()
-    };
-
-    const result = await resolveCanonicalWorkspaceSelection({
-      postman,
-      workspaceName,
-      repoUrl,
-      teamId: 'team-123',
-      accessToken: 'token-abc'
-    });
-
-    expect(result).toEqual({ type: 'create' });
-    expect(postman.getWorkspaceGitRepoUrl).not.toHaveBeenCalled();
-  });
-
-  it('fetches git repo URL even when only one workspace matches by name', async () => {
-    const postman = {
-      findWorkspacesByName: vi.fn().mockResolvedValue([{ id: 'ws-single', name: workspaceName }]),
-      getWorkspaceGitRepoUrl: vi.fn().mockResolvedValue(repoUrl)
-    };
-
-    const result = await resolveCanonicalWorkspaceSelection({
-      postman,
-      workspaceName,
-      repoUrl,
-      teamId: 'team-123',
-      accessToken: 'token-abc'
-    });
-
-    expect(result.type).toBe('existing');
-    expect(postman.getWorkspaceGitRepoUrl).toHaveBeenCalled();
-  });
-
-  it('fetches git repo URLs when multiple workspaces match by name', async () => {
-    const postman = {
-      findWorkspacesByName: vi.fn().mockResolvedValue([
-        { id: 'ws-1', name: workspaceName },
-        { id: 'ws-2', name: workspaceName }
-      ]),
-      getWorkspaceGitRepoUrl: vi.fn().mockImplementation(async (id: string) => {
-        if (id === 'ws-1') return repoUrl;
-        return null;
-      })
-    };
-
-    const result = await resolveCanonicalWorkspaceSelection({
-      postman,
-      workspaceName,
-      repoUrl,
-      teamId: 'team-123',
-      accessToken: 'token-abc'
-    });
-
-    expect(result.type).toBe('existing');
-    if (result.type === 'existing') {
-      expect(result.workspaceId).toBe('ws-1');
-      expect(result.source).toBe('linked_match');
-    }
-    expect(postman.getWorkspaceGitRepoUrl).toHaveBeenCalledTimes(2);
-  });
-
-  it('falls back to repoWorkspaceId when workspace lookup fails', async () => {
-    const warn = vi.fn();
-    const postman = {
-      findWorkspacesByName: vi.fn().mockRejectedValue(new Error('network error')),
-      getWorkspaceGitRepoUrl: vi.fn()
-    };
-
-    const result = await resolveCanonicalWorkspaceSelection({
-      postman,
-      workspaceName,
-      repoWorkspaceId: 'ws-fallback',
-      repoUrl,
-      teamId: 'team-123',
-      accessToken: 'token-abc',
-      warn
-    });
-
-    expect(result.type).toBe('existing');
-    if (result.type === 'existing') {
-      expect(result.workspaceId).toBe('ws-fallback');
-      expect(result.source).toBe('repo_var');
-    }
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('ws-fallback'));
-  });
-
-  it('rethrows workspace lookup error when no repoWorkspaceId fallback exists', async () => {
-    const postman = {
-      findWorkspacesByName: vi.fn().mockRejectedValue(new Error('network error')),
-      getWorkspaceGitRepoUrl: vi.fn()
-    };
-
-    await expect(
-      resolveCanonicalWorkspaceSelection({
-        postman,
-        workspaceName,
-        repoUrl,
-        teamId: 'team-123',
-        accessToken: 'token-abc'
-      })
-    ).rejects.toThrow('network error');
-  });
-});

package/tmp/cli-run-result.json

@@ -1,11 +0,0 @@
-{
-  "workspace-id": "ws-123",
-  "workspace-url": "https://go.postman.co/workspace/ws-123",
-  "workspace-name": "[AF] core-payments",
-  "spec-id": "spec-123",
-  "baseline-collection-id": "col-baseline",
-  "smoke-collection-id": "col-smoke",
-  "contract-collection-id": "col-contract",
-  "collections-json": "{\"baseline\":\"col-baseline\",\"smoke\":\"col-smoke\",\"contract\":\"col-contract\"}",
-  "lint-summary-json": "{\"errors\":0,\"total\":0,\"violations\":[],\"warnings\":0}"
-}