@postman-cse/onboarding-bootstrap 0.9.1 → 0.11.0

package/tests/cli.test.ts

@@ -14,6 +14,14 @@ describe('parseCliArgs', () => {
         'pmak-test',
         '--workspace-admin-user-ids',
         '101,102',
+        '--sync-examples',
+        'false',
+        '--collection-sync-mode',
+        'version',
+        '--spec-sync-mode',
+        'version',
+        '--release-label',
+        'v1.2.3',
         '--team-id',
         '12345',
         '--repo-url',
@@ -30,6 +38,10 @@ describe('parseCliArgs', () => {
     expect(config.inputEnv.INPUT_SPEC_URL).toBe('https://example.test/openapi.yaml');
     expect(config.inputEnv.INPUT_POSTMAN_API_KEY).toBe('pmak-test');
     expect(config.inputEnv.INPUT_WORKSPACE_ADMIN_USER_IDS).toBe('101,102');
+    expect(config.inputEnv.INPUT_SYNC_EXAMPLES).toBe('false');
+    expect(config.inputEnv.INPUT_COLLECTION_SYNC_MODE).toBe('version');
+    expect(config.inputEnv.INPUT_SPEC_SYNC_MODE).toBe('version');
+    expect(config.inputEnv.INPUT_RELEASE_LABEL).toBe('v1.2.3');
     expect(config.inputEnv.INPUT_TEAM_ID).toBe('12345');
     expect(config.inputEnv.INPUT_REPO_URL).toBe('https://github.com/postman-cs/postman-bootstrap-action');
     expect(config.resultJsonPath).toBe('tmp/result.json');
@@ -49,7 +61,7 @@ describe('toDotenv', () => {
       'contract-collection-id': 'col-contract',
       'collections-json': '{"baseline":"col-baseline"}',
       'lint-summary-json': '{"errors":0}'
-    });
+    } as any);
 
     expect(dotenv).toContain('POSTMAN_BOOTSTRAP_WORKSPACE_ID="ws-123"');
     expect(dotenv).toContain('POSTMAN_BOOTSTRAP_SPEC_ID="spec-123"');
@@ -104,7 +116,7 @@ describe('runCli', () => {
             '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}'
-          };
+          } as any;
         },
         writeStdout: (chunk) => {
           stdoutChunks.push(chunk);
@@ -124,21 +136,18 @@ describe('runCli', () => {
 });
 
 describe('createCliDependencies', () => {
-  it('creates github and internal integration dependencies under token conditions', () => {
+  it('creates internal integration dependencies under token conditions', () => {
     const inputs = resolveInputs({
       INPUT_PROJECT_NAME: 'core-payments',
       INPUT_SPEC_URL: 'https://example.test/openapi.yaml',
       INPUT_POSTMAN_API_KEY: 'pmak-test',
       INPUT_POSTMAN_ACCESS_TOKEN: 'pat-test',
-      INPUT_GITHUB_TOKEN: 'gh-token',
-      INPUT_GH_FALLBACK_TOKEN: 'gh-fallback',
       INPUT_REPO_URL: 'https://github.com/postman-cs/postman-bootstrap-action',
       INPUT_TEAM_ID: '12345'
     });
 
     const dependencies = createCliDependencies(inputs);
 
-    expect(dependencies.github).toBeDefined();
     expect(dependencies.internalIntegration).toBeDefined();
   });
 });

package/tests/contract.test.ts

@@ -41,6 +41,34 @@ describe('open-alpha action contract', () => {
     expect(resolveInputs({}).integrationBackend).toBe('bifrost');
   });
 
+  it('defaults lifecycle controls in contract, manifest, and runtime', () => {
+    expect(openAlphaActionContract.inputs['sync-examples'].default).toBe('true');
+    expect(openAlphaActionContract.inputs['sync-examples'].allowedValues).toEqual([
+      'true',
+      'false'
+    ]);
+    expect(actionManifest.inputs['sync-examples'].default).toBe('true');
+    expect(resolveInputs({}).syncExamples).toBe(true);
+
+    expect(openAlphaActionContract.inputs['collection-sync-mode'].default).toBe('refresh');
+    expect(openAlphaActionContract.inputs['collection-sync-mode'].allowedValues).toEqual([
+      'reuse',
+      'refresh',
+      'version'
+    ]);
+    expect(actionManifest.inputs['collection-sync-mode'].default).toBe('refresh');
+    expect(resolveInputs({}).collectionSyncMode).toBe('refresh');
+
+    expect(openAlphaActionContract.inputs['spec-sync-mode'].default).toBe('update');
+    expect(openAlphaActionContract.inputs['spec-sync-mode'].allowedValues).toEqual([
+      'update',
+      'version'
+    ]);
+    expect(actionManifest.inputs['spec-sync-mode'].default).toBe('update');
+    expect(resolveInputs({}).specSyncMode).toBe('update');
+
+  });
+
   it('rejects unsupported integration backends during input resolution', () => {
     expect(() =>
       resolveInputs({
@@ -63,9 +91,6 @@ describe('open-alpha action contract', () => {
     expect(openAlphaActionContract.retainedBehavior).toContain(
       'governance group assignment'
     );
-    expect(openAlphaActionContract.retainedBehavior).toContain(
-      'GitHub repository variable persistence for downstream sync steps'
-    );
     expect(openAlphaActionContract.removedBehavior).toContain('step mode');
     expect(openAlphaActionContract.removedBehavior).toContain(
       'aws, docker, and infra workflow concerns'

package/tests/internal-integration-adapter.test.ts

@@ -184,6 +184,75 @@ describe('internal integration adapter', () => {
     );
   });
 
+  it('routes specification collection linking through the Bifrost proxy with sync options', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(
+      jsonResponse({ data: { updated: 1 } })
+    );
+
+    const adapter = createInternalIntegrationAdapter({
+      backend: 'bifrost',
+      accessToken: 'token-123',
+      teamId: '11430732',
+      fetchImpl
+    });
+
+    await adapter.linkCollectionsToSpecification('spec-123', [
+      {
+        collectionId: 'col-1',
+        syncOptions: { syncExamples: true }
+      }
+    ]);
+
+    expect(fetchImpl).toHaveBeenCalledWith(
+      'https://bifrost-premium-https-v4.gw.postman.com/ws/proxy',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({
+          'x-access-token': 'token-123',
+          'x-entity-team-id': '11430732'
+        }),
+        body: JSON.stringify({
+          service: 'specification',
+          method: 'put',
+          path: '/specifications/spec-123/collections',
+          body: [
+            {
+              collectionId: 'col-1',
+              syncOptions: { syncExamples: true }
+            }
+          ]
+        })
+      })
+    );
+  });
+
+  it('routes specification collection sync through the Bifrost proxy', async () => {
+    const fetchImpl = vi.fn<typeof fetch>().mockResolvedValue(
+      jsonResponse({ data: { taskId: 'task-1' } })
+    );
+
+    const adapter = createInternalIntegrationAdapter({
+      backend: 'bifrost',
+      accessToken: 'token-123',
+      teamId: '11430732',
+      fetchImpl
+    });
+
+    await adapter.syncCollection('spec-123', 'col-1');
+
+    expect(fetchImpl).toHaveBeenCalledWith(
+      'https://bifrost-premium-https-v4.gw.postman.com/ws/proxy',
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({
+          service: 'specification',
+          method: 'post',
+          path: '/specifications/spec-123/collections/col-1/sync'
+        })
+      })
+    );
+  });
+
   it('treats projectAlreadyConnected as idempotent when the same repo is linked', async () => {
     const fetchImpl = vi.fn<typeof fetch>()
       // First call: connectWorkspaceToRepository POST returns 400 projectAlreadyConnected

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

@@ -112,4 +112,157 @@ describe('PostmanAssetsClient', () => {
 
     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();
+  });
 });