submodule-version 2.3.2 → 3.0.0

package/src/__tests__/printError.test.ts

@@ -0,0 +1,148 @@
+import { printError } from '../printError';
+import { SVError } from '../errors';
+import { GitError, GithubError } from '../git';
+import { readFileSync } from 'fs';
+
+jest.mock('fs', () => ({
+  readFileSync: jest.fn(() => {
+    throw new Error('ENOENT');
+  }),
+}));
+
+const readFileSyncMock = readFileSync as jest.Mock;
+
+beforeEach(() => {
+  readFileSyncMock.mockImplementation(() => {
+    throw new Error('ENOENT');
+  });
+});
+
+describe('printError', () => {
+  it('reports a requested version that does not exist', () => {
+    const error = new SVError('VERSION_CONFLICT', {
+      name: 'Medusa',
+      parents: { '<root>': '^0.5.4' },
+      constraints: [{ range: '^0.5.4', positive: true, requiredBy: '<root>' }],
+      versions: ['0.5.2', '0.5.1'],
+      chain: ['<root>', 'Medusa'],
+    });
+
+    expect(printError(error)).toBe(
+      'Package Medusa does not contain a version matching ^0.5.4'
+      + ' required by the project root. Use one of [0.5.2, 0.5.1]',
+    );
+  });
+  it('formats a version conflict with parents, chain and versions', () => {
+    const error = new SVError('VERSION_CONFLICT', {
+      name: 'C',
+      parents: { '<root>': '^1.3.2', 'B@1.2.0': 'not ^1.4.2' },
+      chain: ['A', 'B', 'C'],
+      versions: ['1.4.2', '1.3.2'],
+    });
+
+    expect(printError(error)).toBe([
+      'Version conflict for C:',
+      '  - ^1.3.2 required by the project root',
+      '  - not ^1.4.2 required by B@1.2.0',
+      '  chain: A -> B -> C',
+      '  available versions: 1.4.2, 1.3.2',
+    ].join('\n'));
+  });
+
+  it('shows the project name from package.json instead of <root>', () => {
+    readFileSyncMock.mockReturnValue(JSON.stringify({ name: 'ewa' }));
+
+    const error = new SVError('VERSION_CONFLICT', {
+      name: 'Medusa',
+      parents: { '<root>': '0.2.8' },
+      chain: ['<root>', 'Medusa'],
+    });
+
+    expect(printError(error)).toBe([
+      'Version conflict for Medusa:',
+      '  - 0.2.8 required by ewa',
+      '  chain: ewa -> Medusa',
+    ].join('\n'));
+  });
+
+  it('formats a circular dependency chain', () => {
+    const error = new SVError('CIRCULAR_DEPENDENCY', {
+      name: 'A',
+      chain: ['A', 'B', 'A'],
+    });
+
+    expect(printError(error)).toBe('Circular dependency: A -> B -> A');
+  });
+
+  it('formats an unknown version with module and parent', () => {
+    const error = new SVError('UNKNOWN_VERSION', {
+      name: 'B',
+      parent: 'A@1.0.0',
+      version: '^2.x',
+    });
+
+    expect(printError(error)).toBe('Unknown version ^2.x for B in A@1.0.0');
+  });
+
+  it('formats conflicting urls of a missing addon', () => {
+    const error = new SVError('ADDON_NOT_FOUND', {
+      name: 'B',
+      urls: ['git@git:one/B.git', 'git@git:two/B.git'],
+    });
+
+    expect(printError(error)).toBe(
+      'Module B is not found'
+      + ' (conflicting urls: git@git:one/B.git, git@git:two/B.git)',
+    );
+  });
+
+  it('formats a missing requested version with available versions', () => {
+    const error = new SVError('REQUESTED_VERSION_NOT_EXISTS', {
+      name: 'A',
+      requestedVersion: '2.0.0',
+      versions: ['1.2.0', '1.0.0'],
+    });
+
+    expect(printError(error)).toBe(
+      'Package A does not contain version 2.0.0. Use one of [1.2.0, 1.0.0]',
+    );
+  });
+
+  it('formats git layer errors', () => {
+    expect(printError(new GitError('GIT_SYNC_CONFLICT'))).toBe(
+      'Sync with remote failed - resolve conflicts manually',
+    );
+    expect(printError(new GitError('GIT_REPO_URL_REQUIRED'))).toBe(
+      'Module is not published yet - pass --repo-url for the first publish',
+    );
+  });
+
+  it('includes the real git stderr of a failed submodule add', () => {
+    const error = new GitError('GIT_SUBMODULE_ADD_FAILED', {
+      url: 'git@git:repo/B.git',
+      reason: 'fatal: repository not found',
+    });
+
+    expect(printError(error)).toBe(
+      'Failed to add submodule git@git:repo/B.git'
+      + ': fatal: repository not found',
+    );
+  });
+
+  it('formats GitHub API errors with a status hint', () => {
+    const error = new GithubError('GITHUB_API_FAILED', {
+      status: 404,
+      url: 'org/repo',
+      errors: ['NOT_FOUND'],
+    });
+
+    expect(printError(error)).toBe(
+      'GitHub API failed (404) for org/repo: NOT_FOUND'
+      + ': repo not found or private (set GITHUB_TOKEN)',
+    );
+  });
+
+  it('falls back to the message of unhandled errors', () => {
+    expect(printError(new Error('boom'))).toBe('Unhandled error: boom');
+  });
+});

package/src/__tests__/sv.test.ts

@@ -0,0 +1,441 @@
+import { SV } from '../sv';
+import { PubGrub } from '../PubGrub';
+import { git } from '../git';
+import { pkgJSONManager } from '../pkgJSONManager';
+import { readFile } from 'fs/promises';
+
+jest.mock('../PubGrub', () => ({
+  PubGrub: jest.fn(),
+}));
+
+jest.mock('fs/promises', () => ({
+  readFile: jest.fn(),
+}));
+
+jest.mock('../git', () => {
+  const actual = jest.requireActual('../git');
+
+  return {
+    GitError: class GitError extends Error {},
+    git: {
+      parseUrl: actual.git.parseUrl,
+      local: {
+        isGitRepo: jest.fn(async () => true),
+        addSubmodule: jest.fn(async () => undefined),
+        checkout: jest.fn(async () => undefined),
+        rm: jest.fn(async () => undefined),
+        currentVersion: jest.fn(async () => null),
+      },
+      api: {
+        setToken: jest.fn(),
+      },
+    },
+  };
+});
+
+jest.mock('../pkgJSONManager', () => ({
+  pkgJSONManager: {
+    read: jest.fn(async () => null),
+    write: jest.fn(async () => undefined),
+  },
+}));
+
+const PubGrubMock = PubGrub as unknown as jest.Mock;
+const resolveMock = jest.fn();
+const readMock = pkgJSONManager.read as jest.Mock;
+const writeMock = pkgJSONManager.write as jest.Mock;
+const readFileMock = readFile as jest.Mock;
+const localMock = git.local as unknown as Record<string, jest.Mock>;
+const url = (name: string) => `git@git:repo/${name}.git`;
+
+const entry = (
+  name: string,
+  versions: Record<string, Record<string, string>>,
+  version: string,
+) => ({
+  name,
+  url: url(name),
+  versions,
+  version,
+  dependencies: versions[version] || {},
+});
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  jest.spyOn(console, 'log').mockImplementation(() => {});
+  PubGrubMock.mockImplementation(() => ({ resolve: resolveMock }));
+  resolveMock.mockResolvedValue({});
+  readFileMock.mockRejectedValue(new Error('ENOENT'));
+  localMock.isGitRepo.mockResolvedValue(true);
+  localMock.currentVersion.mockResolvedValue(null);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe('SV.init', () => {
+  it('fails before resolving when package.json is missing', async () => {
+    readMock.mockResolvedValue(null);
+    const sv = new SV('/project');
+
+    await expect(sv.init()).rejects.toMatchObject({ error: 'NOT_A_NPM' });
+    expect(resolveMock).not.toHaveBeenCalled();
+  });
+
+  it('fails before resolving outside a git repository', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    localMock.isGitRepo.mockResolvedValue(false);
+    const sv = new SV('/project');
+
+    await expect(sv.init()).rejects.toMatchObject({
+      error: 'NOT_A_GIT_REPO',
+    });
+    expect(resolveMock).not.toHaveBeenCalled();
+  });
+
+  it('passes rootDeps to PubGrub and stores its result', async () => {
+    const rootDeps = { 'git@git:repo/A.git': '^1.0.0' };
+
+    const result = {
+      A: entry('A', { '1.2.0': {} }, '1.2.0'),
+    };
+
+    readMock.mockResolvedValue({ sv: rootDeps });
+    resolveMock.mockResolvedValue(result);
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    expect(resolveMock).toHaveBeenCalledWith(rootDeps);
+    expect(sv.getResolution()).toBe(result);
+    expect(sv.listVersions()).toEqual({ A: ['1.2.0'] });
+  });
+
+  it('guards result before init', () => {
+    expect(() => new SV('/project').getResolution()).toThrow(
+      expect.objectContaining({ error: 'NOT_INITIALIZED' }),
+    );
+  });
+
+  it('adds the modules dir to package.json workspaces', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    expect(writeMock).toHaveBeenCalledWith({
+      sv: {},
+      workspaces: ['modules/*'],
+      'sv-dir': 'modules',
+    });
+  });
+
+  it('keeps workspaces and respects a custom modules dir', async () => {
+    readMock.mockResolvedValue({ sv: {}, workspaces: ['packages/*'] });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project', 'libs');
+
+    await sv.init();
+
+    expect(writeMock).toHaveBeenCalledWith({
+      sv: {},
+      workspaces: ['packages/*', 'libs/*'],
+      'sv-dir': 'libs',
+    });
+  });
+
+  it('skips the write when the workspace entry exists', async () => {
+    readMock.mockResolvedValue({
+      sv: {},
+      workspaces: ['modules/*'],
+      'sv-dir': 'modules',
+    });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    expect(writeMock).not.toHaveBeenCalled();
+  });
+
+  it('uses the recorded sv-dir when no dir is passed', async () => {
+    readMock.mockResolvedValue({
+      sv: { [url('A')]: '*' },
+      workspaces: ['libs/*'],
+      'sv-dir': 'libs',
+    });
+    resolveMock.mockResolvedValue({
+      A: entry('A', { '1.0.0': {} }, '1.0.0'),
+    });
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    expect(writeMock).not.toHaveBeenCalled();
+    expect(localMock.isGitRepo).toHaveBeenCalledWith('libs/A');
+  });
+
+  it('derives the modules dir from existing .gitmodules', async () => {
+    readFileMock.mockResolvedValue([
+      '[submodule "addons/A"]',
+      '\tpath = addons/A',
+      '[submodule "addons/B"]',
+      '\tpath = addons/B',
+    ].join('\n'));
+    readMock.mockResolvedValue({ sv: {} });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    expect(writeMock).toHaveBeenCalledWith({
+      sv: {},
+      workspaces: ['addons/*'],
+      'sv-dir': 'addons',
+    });
+  });
+});
+
+describe('SV.put', () => {
+  it('installs a root module and writes the range', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    localMock.isGitRepo.mockResolvedValue(false);
+    resolveMock.mockResolvedValue({
+      B: entry('B', { '1.2.0': {} }, '1.2.0'),
+    });
+
+    const sv = new SV('/project');
+
+    await sv.put(url('B'), '^1.2.0');
+
+    expect(resolveMock).toHaveBeenCalledWith({ [url('B')]: '^1.2.0' });
+    expect(writeMock).toHaveBeenCalledWith({
+      sv: { [url('B')]: '^1.2.0' },
+      'sv-dir': 'modules',
+    });
+    expect(localMock.addSubmodule).toHaveBeenCalledWith(url('B'));
+    expect(localMock.checkout).toHaveBeenCalledWith('B', '1.2.0');
+  });
+
+  it('falls back to * when version is omitted', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.put(url('B'));
+
+    expect(resolveMock).toHaveBeenCalledWith({ [url('B')]: '*' });
+    expect(writeMock).toHaveBeenCalledWith({
+      sv: { [url('B')]: '*' },
+      'sv-dir': 'modules',
+    });
+  });
+
+  it('treats a non-version second argument as parent name', async () => {
+    readMock.mockResolvedValue({
+      sv: { [url('A')]: '*' },
+      workspaces: ['modules/*'],
+      'sv-dir': 'modules',
+    });
+    resolveMock.mockResolvedValue({
+      A: entry('A', { '1.0.0': {} }, '1.0.0'),
+    });
+
+    const sv = new SV('/project');
+
+    await sv.init();
+    await sv.put(url('B'), 'A');
+
+    /* rootDeps не меняются, диапазон пишется в package.json родителя */
+    expect(resolveMock).toHaveBeenLastCalledWith({ [url('A')]: '*' });
+    expect(writeMock).toHaveBeenCalledWith(
+      {
+        sv: { [url('A')]: '*', [url('B')]: '*' },
+        workspaces: ['modules/*'],
+        'sv-dir': 'modules',
+      },
+      'A',
+    );
+  });
+
+  it('accepts an installed module name instead of url', async () => {
+    readMock.mockResolvedValue({
+      sv: { [url('B')]: '*' },
+      workspaces: ['modules/*'],
+      'sv-dir': 'modules',
+    });
+    resolveMock.mockResolvedValue({
+      B: entry('B', { '1.2.0': {} }, '1.2.0'),
+    });
+
+    const sv = new SV('/project');
+
+    await sv.init();
+    await sv.put('B', '^1.1.0');
+
+    expect(resolveMock).toHaveBeenLastCalledWith({ [url('B')]: '^1.1.0' });
+    expect(writeMock).toHaveBeenCalledWith({
+      sv: { [url('B')]: '^1.1.0' },
+      workspaces: ['modules/*'],
+      'sv-dir': 'modules',
+    });
+  });
+
+  it('rejects a name that is not an installed module', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    await expect(sv.put('Ghost')).rejects.toMatchObject({
+      error: 'NOT_A_GIT_URL',
+      details: { url: 'Ghost' },
+    });
+  });
+
+  it('rejects put into a parent that is not installed', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.init();
+    writeMock.mockClear(); /* init пишет workspaces — интересует только put */
+
+    await expect(sv.put(url('B'), 'Nope')).rejects.toMatchObject({
+      error: 'ADDON_NOT_FOUND',
+      details: { name: 'Nope' },
+    });
+    expect(writeMock).not.toHaveBeenCalled();
+  });
+
+  it('applies nothing when the check resolve fails', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    resolveMock.mockRejectedValue(new Error('version conflict'));
+
+    const sv = new SV('/project');
+
+    await expect(sv.put(url('B'), '^1.0.0')).rejects.toThrow(
+      'version conflict',
+    );
+    expect(writeMock).not.toHaveBeenCalled();
+    expect(localMock.addSubmodule).not.toHaveBeenCalled();
+  });
+});
+
+describe('SV.delete', () => {
+  it('removes a root dependency and uninstalls its module', async () => {
+    readMock.mockResolvedValue({
+      sv: { [url('A')]: '*' },
+      workspaces: ['modules/*'],
+      'sv-dir': 'modules',
+    });
+    resolveMock.mockResolvedValueOnce({
+      A: entry('A', { '1.0.0': {} }, '1.0.0'),
+    });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.init();
+    await sv.delete('A');
+
+    expect(resolveMock).toHaveBeenLastCalledWith({});
+    expect(writeMock).toHaveBeenCalledWith({
+      sv: {},
+      workspaces: ['modules/*'],
+      'sv-dir': 'modules',
+    });
+    expect(localMock.rm).toHaveBeenCalledWith('A');
+  });
+
+  it('rejects deleting a module missing from rootDeps', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+
+    const sv = new SV('/project');
+
+    await expect(sv.delete('Ghost')).rejects.toMatchObject({
+      error: 'ADDON_NOT_FOUND',
+      details: { name: 'Ghost' },
+    });
+    expect(resolveMock).not.toHaveBeenCalled();
+  });
+
+  it('removes a dependency from the parent package.json', async () => {
+    readMock.mockImplementation(async (module?: string) => (
+      module === 'A'
+        ? { sv: { [url('B')]: '^1.0.0' } }
+        : { sv: { [url('A')]: '*' } }
+    ));
+    resolveMock.mockResolvedValue({
+      A: entry('A', { '1.0.0': { B: '^1.0.0' } }, '1.0.0'),
+    });
+
+    const sv = new SV('/project');
+
+    await sv.init();
+    await sv.delete('B', 'A');
+
+    expect(writeMock).toHaveBeenCalledWith({ sv: {} }, 'A');
+  });
+
+  it('rejects deleting a module the parent does not depend on', async () => {
+    readMock.mockResolvedValue({ sv: { [url('A')]: '*' } });
+    resolveMock.mockResolvedValue({
+      A: entry('A', { '1.0.0': {} }, '1.0.0'),
+    });
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    await expect(sv.delete('B', 'A')).rejects.toMatchObject({
+      error: 'ADDON_NOT_FOUND',
+      details: { name: 'B' },
+    });
+    /* resolve не вызывался повторно — только внутри init */
+    expect(resolveMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('SV.listVersions', () => {
+  it('returns versions of one package by name', async () => {
+    readMock.mockResolvedValue({ sv: { [url('A')]: '*' } });
+    resolveMock.mockResolvedValue({
+      A: entry('A', { '1.0.0': {}, '1.2.0': {} }, '1.2.0'),
+    });
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    expect(sv.listVersions('A')).toEqual(['1.2.0', '1.0.0']);
+  });
+
+  it('rejects an unknown package name', async () => {
+    readMock.mockResolvedValue({ sv: {} });
+    resolveMock.mockResolvedValue({});
+
+    const sv = new SV('/project');
+
+    await sv.init();
+
+    expect(() => sv.listVersions('Nope')).toThrow(
+      expect.objectContaining({
+        error: 'ADDON_NOT_FOUND',
+        details: { name: 'Nope' },
+      }),
+    );
+  });
+});