feat(core): add history logic

packages/core/package.json

@@ -6,7 +6,8 @@
     "@code-pushup/models": "*",
     "@code-pushup/utils": "*",
     "@code-pushup/portal-client": "^0.6.1",
-    "chalk": "^5.3.0"
+    "chalk": "^5.3.0",
+    "simple-git": "^3.20.0"
   },
   "type": "commonjs",
   "main": "./index.cjs"

packages/core/src/lib/history.integration.test.ts

@@ -0,0 +1,94 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { type SimpleGit, simpleGit } from 'simple-git';
+import { afterAll, beforeAll, describe, expect } from 'vitest';
+import { getHashes } from './history';
+
+// we need a separate folder that is not cleaned in `global-setup.ts`, otherwise the tests can't execute in parallel
+const gitTestFolder = 'core-history-git-test';
+describe('git utils in a git repo', () => {
+  const baseDir = join(process.cwd(), gitTestFolder);
+  let emptyGit: SimpleGit;
+
+  beforeAll(async () => {
+    await mkdir(baseDir, { recursive: true });
+    emptyGit = simpleGit(baseDir);
+    await emptyGit.init();
+    await emptyGit.addConfig('user.name', 'John Doe');
+    await emptyGit.addConfig('user.email', '[email protected]');
+  });
+
+  afterAll(async () => {
+    await rm(baseDir, { recursive: true, force: true });
+  });
+
+  describe('without a branch and commits', () => {
+    it('getHashes should throw', async () => {
+      await expect(getHashes({}, emptyGit)).rejects.toThrow(
+        "your current branch 'master' does not have any commits yet",
+      );
+    });
+  });
+
+  describe('with a branch and commits clean', () => {
+    const commits: string[] = [];
+    beforeAll(async () => {
+      await writeFile(join(baseDir, 'README.md'), '# hello-world\n');
+      await emptyGit.add('README.md');
+      await emptyGit.commit('Create README');
+      // eslint-disable-next-line functional/immutable-data
+      commits.push((await emptyGit.log()).latest?.hash);
+
+      await writeFile(join(baseDir, 'README.md'), '# hello-world-1\n');
+      await emptyGit.add('README.md');
+      await emptyGit.commit('Update README 1');
+      // eslint-disable-next-line functional/immutable-data
+      commits.push((await emptyGit.log()).latest?.hash);
+
+      await writeFile(join(baseDir, 'README.md'), '# hello-world-2\n');
+      await emptyGit.add('README.md');
+      await emptyGit.commit('Update README 2');
+      // eslint-disable-next-line functional/immutable-data
+      commits.push((await emptyGit.log()).latest?.hash);
+
+      await emptyGit.branch(['feature-branch']);
+      await emptyGit.checkout(['master']);
+    });
+
+    afterAll(async () => {
+      await emptyGit.checkout(['master']);
+      await emptyGit.deleteLocalBranch('feature-branch');
+    });
+
+    it('getHashes should get all commits from log if no option is passed', async () => {
+      await expect(getHashes({}, emptyGit)).resolves.toStrictEqual(commits);
+    });
+
+    it('getHashes should get last 2 commits from log if maxCount is set to 2', async () => {
+      await expect(getHashes({ maxCount: 2 }, emptyGit)).resolves.toStrictEqual(
+        [commits[1], commits[2]],
+      );
+    });
+
+    it('getHashes should get commits from log based on "from" and "to"', async () => {
+      await expect(
+        getHashes({ from: commits[2], to: commits[0] }, emptyGit),
+      ).resolves.toEqual([commits[1], commits[2]]);
+    });
+
+    it('getHashes should get commits from log based on "from" and "to" and "maxCount"', async () => {
+      await expect(
+        getHashes({ from: commits[2], to: commits[0], maxCount: 1 }, emptyGit),
+      ).resolves.toEqual([commits[2]]);
+    });
+
+    it('getHashes should throw if "from" or "to" are invalid', async () => {
+      await expect(
+        getHashes({ from: undefined, to: 'a' }, emptyGit),
+      ).rejects.toThrow('from has to be defined');
+      await expect(
+        getHashes({ from: 'a', to: undefined }, emptyGit),
+      ).rejects.toThrow('to has to be defined');
+    });
+  });
+});

packages/core/src/lib/history.ts

@@ -0,0 +1,110 @@
+import { LogResult, simpleGit } from 'simple-git';
+import {
+  CoreConfig,
+  Format,
+  PersistConfig,
+  UploadConfig,
+  uploadConfigSchema,
+} from '@code-pushup/models';
+import { getCurrentBranchOrTag, safeCheckout } from '@code-pushup/utils';
+import { collectAndPersistReports } from './collect-and-persist';
+import { GlobalOptions } from './types';
+import { upload as uploadCommandLogic } from './upload';
+
+export type HistoryOnlyOptions = {
+  targetBranch?: string;
+  uploadReports?: boolean;
+  forceCleanStatus?: true;
+};
+export type HistoryOptions = Required<
+  Pick<CoreConfig, 'plugins' | 'categories'> & {
+    persist: Required<PersistConfig>;
+  } & { upload: Required<UploadConfig> }
+> &
+  GlobalOptions &
+  HistoryOnlyOptions;
+
+export async function history(
+  config: HistoryOptions,
+  commits: string[],
+): Promise<string[]> {
+  const initialBranch: string = await getCurrentBranchOrTag();
+
+  const { uploadReports = true } = config as unknown as HistoryOptions;
+  if (!uploadReports) {
+    console.warn('Upload is skipped because uploadReports is set to false');
+  }
+
+  const reports: string[] = [];
+  // eslint-disable-next-line functional/no-loop-statements
+  for (const commit of commits) {
+    console.info(`Collect ${commit}`);
+    await safeCheckout(commit, { forceCleanStatus: config.forceCleanStatus });
+
+    const currentConfig: HistoryOptions = {
+      ...config,
+      persist: {
+        ...config.persist,
+        format: ['json' as Format],
+        filename: `${commit}-report`,
+      },
+    };
+
+    await collectAndPersistReports(currentConfig);
+
+    if (uploadReports) {
+      const result = uploadConfigSchema.safeParse(currentConfig.upload);
+      if (result.success) {
+        await uploadCommandLogic({ ...currentConfig, upload: result.data });
+      } else {
+        console.error(`Collecting ${commit} failed.`);
+        console.error(result.error);
+      }
+    }
+
+    // eslint-disable-next-line functional/immutable-data
+    reports.push(currentConfig.persist.filename);
+  }
+
+  await safeCheckout(initialBranch, {
+    forceCleanStatus: config.forceCleanStatus,
+  });
+
+  return reports;
+}
+
+export async function getHashes(
+  options: {
+    from?: string;
+    to?: string;
+    maxCount?: number;
+  } = {},
+  git = simpleGit(),
+): Promise<string[]> {
+  const { from, to, maxCount } = options;
+
+  if (from || to) {
+    // validate from & to
+    if (from === undefined || from === '') {
+      throw new Error('from has to be defined');
+    }
+    if (to === undefined || to === '') {
+      throw new Error('to has to be defined');
+    }
+
+    const logsFromTo = await git.log({ from, to, maxCount });
+    return prepareHashes(logsFromTo);
+  }
+
+  const logs = await git.log(maxCount ? { maxCount } : {});
+  return prepareHashes(logs);
+}
+
+export function prepareHashes(logs: LogResult): string[] {
+  return (
+    logs.all
+      .map(({ hash }) => hash)
+      // sort from oldest to newest
+      .reverse()
+  );
+}

packages/core/src/lib/history.unit.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, vi } from 'vitest';
+import { MINIMAL_CONFIG_MOCK } from '@code-pushup/test-utils';
+import { getCurrentBranchOrTag, safeCheckout } from '@code-pushup/utils';
+import { collectAndPersistReports } from './collect-and-persist';
+import { HistoryOptions, history, prepareHashes } from './history';
+import { upload } from './upload';
+
+vi.mock('@code-pushup/utils', async () => {
+  const utils: object = await vi.importActual('@code-pushup/utils');
+  let currentBranchOrTag = 'main';
+  return {
+    ...utils,
+    safeCheckout: vi.fn().mockImplementation((branch: string) => {
+      currentBranchOrTag = branch;
+    }),
+    getCurrentBranchOrTag: vi.fn().mockImplementation(() => currentBranchOrTag),
+  };
+});
+
+vi.mock('./collect-and-persist', () => ({
+  collectAndPersistReports: vi.fn(),
+}));
+
+vi.mock('./upload', () => ({
+  upload: vi.fn(),
+}));
+
+describe('history', () => {
+  it('should check out all passed commits and reset to initial branch or tag', async () => {
+    const historyOptions: HistoryOptions = {
+      ...(MINIMAL_CONFIG_MOCK as HistoryOptions),
+    };
+
+    await history(historyOptions, ['abc', 'def']);
+
+    expect(getCurrentBranchOrTag).toHaveBeenCalledTimes(1);
+    expect(getCurrentBranchOrTag).toHaveReturnedWith('main');
+
+    expect(safeCheckout).toHaveBeenCalledTimes(3);
+    // walk commit history
+    expect(safeCheckout).toHaveBeenNthCalledWith(1, 'abc', {
+      forceCleanStatus: undefined,
+    });
+    expect(safeCheckout).toHaveBeenNthCalledWith(2, 'def', {
+      forceCleanStatus: undefined,
+    });
+    // reset
+    expect(safeCheckout).toHaveBeenNthCalledWith(3, 'main', {
+      forceCleanStatus: undefined,
+    });
+  });
+
+  it('should return correct number of results', async () => {
+    const historyOptions: HistoryOptions = {
+      ...(MINIMAL_CONFIG_MOCK as HistoryOptions),
+    };
+
+    const results = await history(historyOptions, ['abc', 'def']);
+
+    expect(results).toHaveLength(2);
+    expect(results).toStrictEqual(['abc-report', 'def-report']);
+  });
+
+  it('should call collect with correct filename and format', async () => {
+    const historyOptions: HistoryOptions = {
+      ...(MINIMAL_CONFIG_MOCK as HistoryOptions),
+    };
+
+    await history(historyOptions, ['abc']);
+    expect(collectAndPersistReports).toHaveBeenCalledTimes(1);
+    expect(collectAndPersistReports).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        persist: expect.objectContaining({
+          filename: 'abc-report',
+          format: ['json'],
+        }),
+      }),
+    );
+  });
+
+  it('should call upload by default', async () => {
+    const historyOptions: HistoryOptions = {
+      ...(MINIMAL_CONFIG_MOCK as HistoryOptions),
+      upload: {
+        server: 'https://server.com/api',
+        project: 'cli',
+        apiKey: '1234',
+        organization: 'code-pushup',
+        timeout: 4000,
+      },
+    };
+    await history(historyOptions, ['abc']);
+
+    expect(upload).toHaveBeenCalledTimes(1);
+    expect(upload).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        persist: expect.objectContaining({ filename: 'abc-report' }),
+      }),
+    );
+  });
+
+  it('should not call upload if uploadReports is set to false', async () => {
+    const historyOptions: HistoryOptions = {
+      ...(MINIMAL_CONFIG_MOCK as HistoryOptions),
+      upload: {
+        server: 'https://server.com/api',
+        project: 'cli',
+        apiKey: '1234',
+        organization: 'code-pushup',
+        timeout: 4000,
+      },
+      uploadReports: false,
+    };
+    await history(historyOptions, ['abc']);
+
+    expect(upload).not.toHaveBeenCalled();
+  });
+
+  it('should not call upload if upload config is not given', async () => {
+    const historyOptions: HistoryOptions = {
+      ...(MINIMAL_CONFIG_MOCK as HistoryOptions),
+    };
+    await history(historyOptions, ['abc']);
+
+    expect(upload).not.toHaveBeenCalled();
+  });
+});
+
+describe('prepareHashes', () => {
+  it('should get all commits from log if no option is passed', () => {
+    expect(
+      prepareHashes({ all: [{ hash: '1' }, { hash: '5' }] }),
+    ).toStrictEqual(['5', '1']);
+  });
+});

packages/utils/src/index.ts

@@ -40,6 +40,8 @@ export {
   getLatestCommit,
   toGitPath,
   validateCommitData,
+  getCurrentBranchOrTag,
+  safeCheckout,
 } from './lib/git';
 export { groupByStatus } from './lib/group-by-status';
 export {