@dk/jolly 0.1.8 → 0.1.9

package/src/test/e2e-flows.test.ts

@@ -1,231 +0,0 @@
-import { describe, expect, mock, beforeEach, afterEach } from 'bun:test';
-import { Given, When, Then, And } from './helpers';
-import {
-  fixtures, captureConsole, mockFetch, mockFetchError,
-  mockProcessExit, withToken, withoutToken,
-} from './mocks';
-
-const tuiCalls: { fn: string; msg: string }[] = [];
-mock.module('../tui/components', () => ({
-  info: (msg: string) => { tuiCalls.push({ fn: 'info', msg }); return msg; },
-  success: (msg: string) => { tuiCalls.push({ fn: 'success', msg }); return msg; },
-  error: (msg: string) => { tuiCalls.push({ fn: 'error', msg }); return msg; },
-  warning: (msg: string) => { tuiCalls.push({ fn: 'warning', msg }); return msg; },
-  spinner: () => ({ stop: () => {} }),
-}));
-
-describe('End-to-End Flows', () => {
-  let console_: ReturnType<typeof captureConsole>;
-  let exitSpy: ReturnType<typeof mockProcessExit>;
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    console_ = captureConsole();
-    exitSpy = mockProcessExit();
-    tuiCalls.length = 0;
-    withToken();
-  });
-
-  afterEach(() => {
-    console_.restore();
-    exitSpy.mockRestore();
-    globalThis.fetch = originalFetch;
-    withoutToken();
-  });
-
-  describe('Store Creation Flow', () => {
-    Given('a valid token and working API', () => {
-      When('creating a store end-to-end', () => {
-        Then('it should call API and display project slug and dashboard URL', async () => {
-          const fetchMock = mockFetch({
-            '/organizations': { organizations: [fixtures.organization] },
-            '/organizations/my-org/projects': { project: fixtures.project },
-          });
-
-          const { createStore } = await import('../commands/store');
-          await createStore('my-store', 'us-east-1');
-
-          expect(fetchMock).toHaveBeenCalled();
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('my-store');
-          expect(allTui).toContain('cloud.saleor.io');
-        });
-      });
-    });
-  });
-
-  describe('Store List Flow', () => {
-    Given('a valid token and multiple organizations', () => {
-      When('listing stores end-to-end', () => {
-        Then('it should display all organizations with emails and dates', async () => {
-          mockFetch({
-            '/organizations': { organizations: [fixtures.organization, fixtures.organization2] },
-          });
-
-          const { listStores } = await import('../commands/store');
-          await listStores();
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          const allConsole = console_.logs.join('\n');
-          expect(allTui).toContain('2 organization(s)');
-          expect(allConsole).toContain('My Organization');
-          expect(allConsole).toContain('owner@example.com');
-          expect(allConsole).toContain('Other Organization');
-          expect(allConsole).toContain('other@example.com');
-        });
-      });
-    });
-  });
-
-  describe('Environment Creation Flow', () => {
-    Given('a valid token and existing organization', () => {
-      When('creating an environment end-to-end', () => {
-        Then('it should call API and display environment key and domain', async () => {
-          const fetchMock = mockFetch({
-            '/organizations/my-org/projects/default/environments': { environment: fixtures.environment },
-          });
-
-          const { createEnvironment } = await import('../commands/store');
-          await createEnvironment('my-org', 'staging');
-
-          expect(fetchMock).toHaveBeenCalled();
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('staging');
-          expect(allTui).toContain('saleor.cloud');
-        });
-      });
-    });
-  });
-
-  describe('Payment App Registration Flow', () => {
-    Given('a valid token and environment', () => {
-      When('creating a payment app with environment', () => {
-        Then('it should register via API and display app ID', async () => {
-          const fetchMock = mockFetch({
-            '/environments/staging/apps': { app: fixtures.app },
-          });
-
-          const { createApp } = await import('../commands/app');
-          await createApp('my-payment', 'payment', 'staging', 'stripe');
-
-          expect(fetchMock).toHaveBeenCalledTimes(1);
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('app-1');
-          expect(allTui).toContain('stripe');
-        });
-      });
-    });
-
-    Given('a valid token but no environment', () => {
-      When('creating a payment app without environment', () => {
-        Then('it should display manual setup instructions', async () => {
-          const { createApp } = await import('../commands/app');
-          await createApp('my-payment', 'payment', undefined, 'stripe');
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('stripe');
-          expect(allTui).toContain('cloud.saleor.io');
-          expect(allTui).toContain('Third party apps');
-        });
-      });
-    });
-  });
-
-  describe('Full Error Recovery Flow', () => {
-    Given('no token set', () => {
-      When('attempting any store operation', () => {
-        Then('it should fail fast with auth error before API call', async () => {
-          withoutToken();
-          const fetchMock = mockFetch({ '/organizations': { organizations: [] } });
-
-          const { listStores } = await import('../commands/store');
-
-          try {
-            await listStores();
-          } catch {}
-
-          expect(exitSpy).toHaveBeenCalledWith(1);
-          expect(fetchMock).not.toHaveBeenCalled();
-        });
-      });
-    });
-
-    Given('a valid token but network failure', () => {
-      And('the API returns 500', () => {
-        When('creating a store', () => {
-          Then('it should display the error and exit 1', async () => {
-            mockFetchError(500, 'Internal Server Error');
-
-            const { createStore } = await import('../commands/store');
-
-            try {
-              await createStore('fail-store', 'us-east-1');
-            } catch {}
-
-            expect(exitSpy).toHaveBeenCalledWith(1);
-          });
-        });
-      });
-    });
-  });
-
-  describe('API Client Request Construction', () => {
-    Given('a SaleorCloudClient', () => {
-      When('listing organizations', () => {
-        Then('it should send correct URL, method, and headers', async () => {
-          const fetchMock = mockFetch({
-            '/organizations': { organizations: [fixtures.organization] },
-          });
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-          await client.getOrganizations();
-
-          expect(fetchMock).toHaveBeenCalledTimes(1);
-          const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toBe('https://cloud.saleor.io/api/v1/organizations');
-          expect(opts.method).toBe('GET');
-          expect(opts.headers.Authorization).toBe(`Token ${fixtures.token}`);
-        });
-      });
-
-      When('creating a project', () => {
-        Then('it should send correct URL, method, headers, and body', async () => {
-          const fetchMock = mockFetch({
-            '/organizations/default/projects': { project: fixtures.project },
-          });
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-          await client.createProject('default', 'test-store', 'eu-west-1');
-
-          expect(fetchMock).toHaveBeenCalledTimes(1);
-          const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toBe('https://cloud.saleor.io/api/v1/organizations/default/projects');
-          expect(opts.method).toBe('POST');
-          expect(opts.headers.Authorization).toBe(`Token ${fixtures.token}`);
-          expect(JSON.parse(opts.body)).toEqual({ name: 'test-store', region: 'eu-west-1' });
-        });
-      });
-
-      When('registering an app', () => {
-        Then('it should send correct URL with environment key', async () => {
-          const fetchMock = mockFetch({
-            '/environments/staging/apps': { app: fixtures.app },
-          });
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-          await client.registerApp('staging', 'payment', 'my-app');
-
-          const [url, opts] = fetchMock.mock.calls[0];
-          expect(url).toBe('https://cloud.saleor.io/api/v1/environments/staging/apps');
-          expect(JSON.parse(opts.body)).toEqual({ type: 'payment', name: 'my-app' });
-        });
-      });
-    });
-  });
-});

package/src/test/entry-points.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, mock, beforeEach, afterEach } from 'bun:test';
-import { Given, When, Then } from './helpers';
-import {
-  fixtures, captureConsole, mockFetch, mockProcessExit, withToken, withoutToken,
-} from './mocks';
-
-const tuiCalls: { fn: string; msg: string }[] = [];
-mock.module('../tui/components', () => ({
-  info: (msg: string) => { tuiCalls.push({ fn: 'info', msg }); return msg; },
-  success: (msg: string) => { tuiCalls.push({ fn: 'success', msg }); return msg; },
-  error: (msg: string) => { tuiCalls.push({ fn: 'error', msg }); return msg; },
-  warning: (msg: string) => { tuiCalls.push({ fn: 'warning', msg }); return msg; },
-  spinner: () => ({ stop: () => {} }),
-}));
-
-describe('Entry Points', () => {
-  let console_: ReturnType<typeof captureConsole>;
-  let exitSpy: ReturnType<typeof mockProcessExit>;
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    console_ = captureConsole();
-    exitSpy = mockProcessExit();
-    tuiCalls.length = 0;
-  });
-
-  afterEach(() => {
-    console_.restore();
-    exitSpy.mockRestore();
-    globalThis.fetch = originalFetch;
-    withoutToken();
-  });
-
-  describe('Bootstrap Logic', () => {
-    Given('no project name argument', () => {
-      When('bootstrap runs without args', () => {
-        Then('it should print usage instructions to console', () => {
-          console.log('Saleor Store Bootstrapper');
-          console.log('------------------------\n');
-          console.log('Usage: npm create @saleor/jolly <project-name>');
-
-          const allOutput = console_.logs.join('\n');
-          expect(allOutput).toContain('Usage:');
-          expect(allOutput).toContain('npm create @saleor/jolly');
-        });
-      });
-    });
-
-    Given('a project name is provided', () => {
-      When('bootstrap calls createStore', () => {
-        Then('it should pass project name and default region', async () => {
-          withToken();
-          mockFetch({
-            '/organizations': { organizations: [fixtures.organization] },
-            '/organizations/my-org/projects': { project: fixtures.project },
-          });
-
-          const { createStore } = await import('../commands/store');
-          await createStore('my-project', 'us-east-1');
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('my-project');
-          expect(allTui).toContain('us-east-1');
-        });
-      });
-    });
-
-    Given('bootstrap encounters an auth error', () => {
-      When('createStore is called without a token', () => {
-        Then('it should exit with code 1', async () => {
-          withoutToken();
-
-          const { createStore } = await import('../commands/store');
-
-          try {
-            await createStore('fail-project', 'us-east-1');
-          } catch {}
-
-          expect(exitSpy).toHaveBeenCalledWith(1);
-        });
-      });
-    });
-  });
-
-  describe('Agent Entry Logic', () => {
-    Given('the default setup action', () => {
-      When('setupAgent is called with current directory', () => {
-        Then('it should detect agents and begin installation', async () => {
-          const { setupAgent } = await import('../agents/setup');
-
-          try {
-            await setupAgent('.');
-          } catch {}
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('Detecting AI agents');
-        });
-      });
-    });
-
-    Given('the skills action', () => {
-      When('installSkillsCommand is called', () => {
-        Then('it should install skills for detected agents', async () => {
-          const { installSkillsCommand } = await import('../agents/setup');
-
-          try {
-            await installSkillsCommand('.');
-          } catch {}
-
-          const allTui = tuiCalls.map(c => c.msg).join('\n');
-          expect(allTui).toContain('skill');
-        });
-      });
-    });
-
-    Given('an unknown action string', () => {
-      When('checking action routing logic', () => {
-        Then('it should not match any known action', () => {
-          const action = 'unknown-action';
-          const isKnown = action === 'setup' || action === 'install' || action === 'skills';
-          expect(isKnown).toBe(false);
-        });
-      });
-    });
-  });
-});

package/src/test/error-handling.test.ts

@@ -1,137 +0,0 @@
-import { describe, expect, beforeEach, afterEach } from 'bun:test';
-import { Given, When, Then } from './helpers';
-import {
-  fixtures, captureConsole, mockFetch, mockFetchError,
-  mockProcessExit, withToken, withoutToken,
-} from './mocks';
-
-describe('Error Handling', () => {
-  let console_: ReturnType<typeof captureConsole>;
-  let exitSpy: ReturnType<typeof mockProcessExit>;
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    console_ = captureConsole();
-    exitSpy = mockProcessExit();
-  });
-
-  afterEach(() => {
-    console_.restore();
-    exitSpy.mockRestore();
-    globalThis.fetch = originalFetch;
-    withoutToken();
-  });
-
-  describe('Auth Token Validation', () => {
-    Given('no SALEOR_CLOUD_TOKEN in environment', () => {
-      When('calling requireToken', () => {
-        Then('it should print error message with token URL', async () => {
-          withoutToken();
-
-          const { requireToken } = await import('../api/auth');
-
-          try {
-            requireToken();
-          } catch {}
-
-          const allErrors = console_.errors.join('\n');
-          expect(allErrors).toContain('SALEOR_CLOUD_TOKEN');
-          expect(allErrors).toContain('cloud.saleor.io');
-          expect(exitSpy).toHaveBeenCalledWith(1);
-        });
-      });
-
-      When('calling getToken', () => {
-        Then('it should throw with descriptive message', async () => {
-          withoutToken();
-
-          const { getToken } = await import('../api/auth');
-          expect(() => getToken()).toThrow('SALEOR_CLOUD_TOKEN');
-        });
-      });
-    });
-
-    Given('an empty string SALEOR_CLOUD_TOKEN', () => {
-      When('creating a SaleorCloudClient', () => {
-        Then('it should throw', async () => {
-          process.env.SALEOR_CLOUD_TOKEN = '';
-
-          const { SaleorCloudClient } = await import('../api/client');
-          expect(() => new SaleorCloudClient()).toThrow('SALEOR_CLOUD_TOKEN');
-        });
-      });
-    });
-  });
-
-  describe('API Error Responses', () => {
-    Given('a valid token', () => {
-      beforeEach(() => {
-        withToken();
-      });
-
-      When('API returns 401 Unauthorized', () => {
-        Then('the client should throw with status info', async () => {
-          mockFetchError(401, 'Unauthorized');
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-
-          await expect(client.getOrganizations()).rejects.toThrow('401');
-        });
-      });
-
-      When('API returns 403 Forbidden', () => {
-        Then('the client should throw with status info', async () => {
-          mockFetchError(403, 'Forbidden');
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-
-          await expect(client.createProject('test-org', 'test', 'us-east-1')).rejects.toThrow('403');
-        });
-      });
-
-      When('API returns 500 Internal Server Error', () => {
-        Then('the client should throw with status info', async () => {
-          mockFetchError(500, 'Internal Server Error');
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-
-          await expect(client.getEnvironments('test-org', 'test-project')).rejects.toThrow('500');
-        });
-      });
-
-      When('API returns 404 for non-existent resource', () => {
-        Then('the client should throw with status info', async () => {
-          mockFetchError(404, 'Not Found');
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-
-          await expect(client.createEnvironment('bad-org', 'bad-project', 'staging', 'us-east-1')).rejects.toThrow('404');
-        });
-      });
-    });
-  });
-
-  describe('API Request Headers', () => {
-    Given('a SaleorCloudClient with a token', () => {
-      When('making any request', () => {
-        Then('it should include Authorization Token header', async () => {
-          const fetchMock = mockFetch({
-            '/organizations': { organizations: [] },
-          });
-
-          const { SaleorCloudClient } = await import('../api/client');
-          const client = new SaleorCloudClient(fixtures.token);
-          await client.getOrganizations();
-
-          const [, opts] = fetchMock.mock.calls[0];
-          expect(opts.headers.Authorization).toBe(`Token ${fixtures.token}`);
-          expect(opts.headers['Content-Type']).toBe('application/json');
-        });
-      });
-    });
-  });
-});

package/src/test/helpers.ts

@@ -1,49 +0,0 @@
-export {};
-
-declare global {
-  namespace jest {
-    interface Each {
-      given: (name: string, fn: () => void) => void;
-      when: (name: string, fn: () => void) => void;
-      then: (name: string, fn: () => void) => void;
-    }
-  }
-}
-
-export function Given(name: string, fn: () => void): void {
-  describe(`Given ${name}`, fn);
-}
-
-export function When(name: string, fn: () => void): void {
-  describe(`When ${name}`, fn);
-}
-
-export function Then(name: string, fn: () => void): void {
-  it(`Then ${name}`, fn);
-}
-
-export function And(name: string, fn: () => void): void {
-  describe(`And ${name}`, fn);
-}
-
-export function But(name: string, fn: () => void): void {
-  describe(`But ${name}`, fn);
-}
-
-export async function GivenAsync(name: string, fn: () => Promise<void>): Promise<void> {
-  describe(`Given ${name}`, async () => {
-    await fn();
-  });
-}
-
-export async function WhenAsync(name: string, fn: () => Promise<void>): Promise<void> {
-  describe(`When ${name}`, async () => {
-    await fn();
-  });
-}
-
-export async function ThenAsync(name: string, fn: () => Promise<void>): Promise<void> {
-  it(`Then ${name}`, async () => {
-    await fn();
-  });
-}

package/src/test/index.ts

@@ -1 +0,0 @@
-export {};