@datadog/datadog-ci 2.40.0 → 2.40.2

package/dist/commands/git-metadata/__tests__/gitdb.test.js

@@ -0,0 +1,1386 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = __importDefault(require("child_process"));
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../../helpers/logger");
+const utils_1 = require("../../../helpers/utils");
+const gitdb_1 = require("../gitdb");
+describe('gitdb', () => {
+    const tmpdir = path_1.default.join(os_1.default.tmpdir(), 'random');
+    const temporaryPackFile = `${tmpdir}/1000-87ce64f636853fbebc05edfcefe9cccc28a7968b.pack`;
+    const secondTemporaryPackFile = `${tmpdir}/1000-cc424c261da5e261b76d982d5d361a023556e2aa.pack`;
+    beforeAll(() => {
+        process.env.DD_API_KEY = 'api-key';
+        jest.spyOn(global.Math, 'random').mockReturnValue(0.1);
+    });
+    beforeEach(() => {
+        fs_1.default.mkdirSync(tmpdir, {
+            recursive: true,
+        });
+        jest.spyOn(promises_1.default, 'mkdtemp').mockResolvedValue(tmpdir);
+        fs_1.default.writeFileSync(temporaryPackFile, '');
+        fs_1.default.writeFileSync(secondTemporaryPackFile, '');
+    });
+    afterEach(() => {
+        jest.spyOn(promises_1.default, 'mkdtemp').mockRestore();
+    });
+    afterAll(() => {
+        delete process.env.DD_API_KEY;
+        jest.spyOn(global.Math, 'random').mockRestore();
+    });
+    const logger = new logger_1.Logger((_) => { }, logger_1.LogLevel.INFO);
+    const request = (0, utils_1.getRequestBuilder)({
+        apiKey: 'api-key',
+        baseUrl: 'https://api.datadoghq.com',
+    });
+    const testError = new Error('call failed');
+    // This is a bit hacky but the documentation of simpleGit asks you to depend on
+    // a behavior of VersionResult which is not defined in its typings: it has an
+    // override on toString. Here I am replicating this toString behavior so that
+    // the tests pass. See https://github.com/steveukx/git-js/blob/d184c13273abca4b6572c260f9625c19f944d4f7/simple-git/src/lib/tasks/version.ts#L15-L39
+    const newGitVersion = Object.defineProperty({
+        major: 2,
+        minor: 41,
+        patch: 0,
+        agent: '',
+        installed: true,
+    }, 'toString', {
+        value() {
+            return `${this.major}.${this.minor}.${this.patch}`;
+        },
+        configurable: false,
+        enumerable: false,
+    });
+    const oldGitVersion = Object.defineProperty({
+        major: 2,
+        minor: 20,
+        patch: 3,
+        agent: '',
+        installed: true,
+    }, 'toString', {
+        value() {
+            return `${this.major}.${this.minor}.${this.patch}`;
+        },
+        configurable: false,
+        enumerable: false,
+    });
+    const defaultRemoteNameNotConfigured = {
+        key: 'clone.defaultRemoteName',
+        paths: [],
+        scopes: new Map(),
+        // eslint-disable-next-line no-null/no-null
+        value: null,
+        values: [],
+    };
+    class MockAll {
+        constructor(mockParams) {
+            this.simpleGit = {
+                getConfig: jest.fn(),
+                fetch: jest.fn(),
+                getRemotes: jest.fn(),
+                log: jest.fn(),
+                raw: jest.fn(),
+                revparse: jest.fn(),
+                version: jest.fn(),
+            };
+            // call spyOn on these two mocks to make sure the underlying implementation is never called
+            // as the default behavior of spyOn is to actually call the initial implem if not overridden
+            this.execSync = jest.spyOn(child_process_1.default, 'execSync').mockImplementation(() => '');
+            this.axios = jest.spyOn(axios_1.default, 'create').mockImplementation(() => ((_) => { }));
+            const initMockWithParams = (mock, params, promise, name = '') => {
+                params.forEach((param) => {
+                    if (param.output instanceof Error) {
+                        mock = mock.mockImplementationOnce((..._) => {
+                            throw param.output;
+                        });
+                    }
+                    else {
+                        if (promise) {
+                            mock = mock.mockResolvedValueOnce(param.output);
+                        }
+                        else {
+                            mock = mock.mockReturnValueOnce(param.output);
+                        }
+                    }
+                });
+                return () => {
+                    try {
+                        expect(mock.mock.calls).toHaveLength(params.length);
+                        params.forEach((param, i) => {
+                            if (param.input !== undefined) {
+                                expect(mock.mock.calls[i][0]).toStrictEqual(param.input);
+                            }
+                        });
+                    }
+                    catch (e) {
+                        // To make it easier to debug the tests
+                        // eslint-disable-next-line
+                        console.log('Error in', name, 'mock');
+                        throw e;
+                    }
+                };
+            };
+            this.getConfigMetExpectations = initMockWithParams(this.simpleGit.getConfig, mockParams.getConfig, true, 'getConfig');
+            this.fetchMetExpectations = initMockWithParams(this.simpleGit.fetch, mockParams.fetch, true, 'fetch');
+            this.getRemotesMetExpectations = initMockWithParams(this.simpleGit.getRemotes, mockParams.getRemotes, true, 'getRemotes');
+            this.logMetExpectations = initMockWithParams(this.simpleGit.log, mockParams.log, true, 'log');
+            this.rawMetExpectations = initMockWithParams(this.simpleGit.raw, mockParams.raw, true, 'raw');
+            this.revparseMetExpectations = initMockWithParams(this.simpleGit.revparse, mockParams.revparse, true, 'revparse');
+            this.versionMetExpectations = initMockWithParams(this.simpleGit.version, mockParams.version, true, 'version');
+            this.execSyncMetExpectations = initMockWithParams(this.execSync, mockParams.execSync, false, 'execSync');
+            this.axiosCalls = [];
+            // custom way of handling axios
+            mockParams.axios.forEach((param) => {
+                this.axios = this.axios.mockImplementationOnce(() => (req) => {
+                    this.axiosCalls.push({ url: req.url, data: req.data });
+                    if (param.output instanceof Error) {
+                        throw param.output;
+                    }
+                    return param.output;
+                });
+            });
+            this.axiosMetExpectations = () => {
+                expect(this.axios.mock.calls).toHaveLength(mockParams.axios.length);
+                mockParams.axios.forEach((param, i) => {
+                    if (param.input !== undefined) {
+                        expect(this.axiosCalls[i].url).toBe(param.input.url);
+                        if (param.input.data !== undefined) {
+                            const data = this.axiosCalls[i].data;
+                            expect(JSON.parse(data)).toStrictEqual(param.input.data);
+                        }
+                    }
+                });
+            };
+        }
+        expectCalls() {
+            this.getConfigMetExpectations();
+            this.fetchMetExpectations();
+            this.getRemotesMetExpectations();
+            this.logMetExpectations();
+            this.rawMetExpectations();
+            this.revparseMetExpectations();
+            this.versionMetExpectations();
+            this.execSyncMetExpectations();
+            this.axiosMetExpectations();
+        }
+    }
+    test('should not work when remote is not present', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [],
+            fetch: [],
+            getRemotes: [{ input: undefined, output: testError }],
+            log: [],
+            raw: [],
+            revparse: [],
+            version: [],
+            execSync: [],
+            axios: [],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow(testError);
+        mocks.expectCalls();
+    }));
+    test('should unshallow repository if git version is recent and backend does not have all commits already', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [
+                {
+                    input: [
+                        '--shallow-since="1 month ago"',
+                        '--update-shallow',
+                        '--filter=blob:none',
+                        '--recurse-submodules=no',
+                        'origin',
+                        'COMMIT',
+                    ],
+                    output: '',
+                },
+            ],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+                // throw an exception after the update shallow to shortcut the rest of the test as we only
+                // care about updating the shallow clone, not about the rest of the process for this test
+                { input: undefined, output: testError },
+            ],
+            raw: [],
+            revparse: [
+                { input: '--is-shallow-repository', output: 'true' },
+                { input: 'HEAD', output: 'COMMIT' },
+            ],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: { data: { data: [] } },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow(testError);
+        mocks.expectCalls();
+    }));
+    test('should unshallow repository with custom origin value', () => __awaiter(void 0, void 0, void 0, function* () {
+        // MockParam<string, simpleGit.ConfigGetResult>[]
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: {
+                        key: 'clone.defaultRemoteName',
+                        paths: [],
+                        scopes: new Map(),
+                        value: 'myorigin',
+                        values: [],
+                    },
+                },
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: {
+                        key: 'clone.defaultRemoteName',
+                        paths: [],
+                        scopes: new Map(),
+                        value: 'myorigin',
+                        values: [],
+                    },
+                },
+            ],
+            fetch: [
+                {
+                    input: [
+                        '--shallow-since="1 month ago"',
+                        '--update-shallow',
+                        '--filter=blob:none',
+                        '--recurse-submodules=no',
+                        'myorigin',
+                        'COMMIT',
+                    ],
+                    output: '',
+                },
+            ],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+                // throw an exception after the update shallow to shortcut the rest of the test as we only
+                // care about updating the shallow clone, not about the rest of the process for this test
+                { input: undefined, output: testError },
+            ],
+            raw: [],
+            revparse: [
+                { input: '--is-shallow-repository', output: 'true' },
+                { input: 'HEAD', output: 'COMMIT' },
+            ],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: { data: { data: [] } },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow(testError);
+        mocks.expectCalls();
+    }));
+    test('should not unshallow repository if git version is old', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            // throw an exception after the failed unshallow to shortcut the rest of the test
+            raw: [{ input: undefined, output: testError }],
+            revparse: [],
+            version: [{ input: undefined, output: oldGitVersion }],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: { data: { data: [] } },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow(testError);
+        mocks.expectCalls();
+    }));
+    test('should not unshallow repository if backend has all commits already', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [],
+            revparse: [],
+            version: [],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: {
+                        data: {
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).resolves.toBe(undefined);
+        mocks.expectCalls();
+    }));
+    test('should unshallow repository if the local HEAD is a commit not pushed to the remote', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: {
+                        key: 'clone.defaultRemoteName',
+                        paths: [],
+                        scopes: new Map(),
+                        value: 'origin',
+                        values: [],
+                    },
+                },
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: {
+                        key: 'clone.defaultRemoteName',
+                        paths: [],
+                        scopes: new Map(),
+                        value: 'origin',
+                        values: [],
+                    },
+                },
+            ],
+            fetch: [
+                {
+                    input: [
+                        '--shallow-since="1 month ago"',
+                        '--update-shallow',
+                        '--filter=blob:none',
+                        '--recurse-submodules=no',
+                        'origin',
+                        'commit',
+                    ],
+                    output: new Error('commit not found'),
+                },
+                {
+                    input: [
+                        '--shallow-since="1 month ago"',
+                        '--update-shallow',
+                        '--filter=blob:none',
+                        '--recurse-submodules=no',
+                        'origin',
+                        'origin/branch',
+                    ],
+                    output: '',
+                },
+            ],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+                // we short circuit the test after the unshallow
+                { input: undefined, output: testError },
+            ],
+            raw: [],
+            revparse: [
+                { input: '--is-shallow-repository', output: 'true' },
+                { input: 'HEAD', output: 'commit' },
+                { input: '--abbrev-ref --symbolic-full-name @{upstream}', output: 'origin/branch' },
+            ],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: { data: { data: [] } },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow(testError);
+        mocks.expectCalls();
+    }));
+    test("should unshallow repository if the CI is working on a detached HEAD or branch tracking hasn't been set up", () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: {
+                        key: 'clone.defaultRemoteName',
+                        paths: [],
+                        scopes: new Map(),
+                        value: 'origin',
+                        values: [],
+                    },
+                },
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: {
+                        key: 'clone.defaultRemoteName',
+                        paths: [],
+                        scopes: new Map(),
+                        value: 'origin',
+                        values: [],
+                    },
+                },
+            ],
+            fetch: [
+                {
+                    input: [
+                        '--shallow-since="1 month ago"',
+                        '--update-shallow',
+                        '--filter=blob:none',
+                        '--recurse-submodules=no',
+                        'origin',
+                        'commit',
+                    ],
+                    output: new Error('commit not found'),
+                },
+                {
+                    input: [
+                        '--shallow-since="1 month ago"',
+                        '--update-shallow',
+                        '--filter=blob:none',
+                        '--recurse-submodules=no',
+                        'origin',
+                        'origin/branch',
+                    ],
+                    output: new Error('working in detached mode'),
+                },
+                {
+                    input: [
+                        '--shallow-since="1 month ago"',
+                        '--update-shallow',
+                        '--filter=blob:none',
+                        '--recurse-submodules=no',
+                        'origin',
+                    ],
+                    output: '',
+                },
+            ],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+                // we short circuit the test after the unshallow
+                { input: undefined, output: testError },
+            ],
+            raw: [],
+            revparse: [
+                { input: '--is-shallow-repository', output: 'true' },
+                { input: 'HEAD', output: 'commit' },
+                { input: '--abbrev-ref --symbolic-full-name @{upstream}', output: 'origin/branch' },
+            ],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: { data: { data: [] } },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow(testError);
+        mocks.expectCalls();
+    }));
+    test('should send packfiles', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [
+                {
+                    input: [
+                        'rev-list',
+                        '--objects',
+                        '--no-object-names',
+                        '--filter=blob:none',
+                        '--since="1 month ago"',
+                        '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                        'cc424c261da5e261b76d982d5d361a023556e2aa',
+                    ],
+                    output: '87ce64f636853fbebc05edfcefe9cccc28a7968b\ncc424c261da5e261b76d982d5d361a023556e2aa\n',
+                },
+            ],
+            revparse: [{ input: '--is-shallow-repository', output: 'false' }],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [
+                {
+                    input: `git pack-objects --compression=9 --max-pack-size=3m ${tmpdir}/1000`,
+                    output: Buffer.from('87ce64f636853fbebc05edfcefe9cccc28a7968b\ncc424c261da5e261b76d982d5d361a023556e2aa\n'),
+                },
+            ],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: { data: { data: [] } },
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/packfile',
+                        data: undefined,
+                    },
+                    output: {},
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/packfile',
+                        data: undefined,
+                    },
+                    output: {},
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).resolves.toBe(undefined);
+        mocks.expectCalls();
+    }));
+    test('should override repository URL when specified', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [],
+            fetch: [],
+            getRemotes: [],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [
+                {
+                    input: [
+                        'rev-list',
+                        '--objects',
+                        '--no-object-names',
+                        '--filter=blob:none',
+                        '--since="1 month ago"',
+                        '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                        'cc424c261da5e261b76d982d5d361a023556e2aa',
+                    ],
+                    output: '87ce64f636853fbebc05edfcefe9cccc28a7968b\ncc424c261da5e261b76d982d5d361a023556e2aa\n',
+                },
+            ],
+            revparse: [{ input: '--is-shallow-repository', output: 'false' }],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [
+                {
+                    input: `git pack-objects --compression=9 --max-pack-size=3m ${tmpdir}/1000`,
+                    output: Buffer.from('87ce64f636853fbebc05edfcefe9cccc28a7968b\ncc424c261da5e261b76d982d5d361a023556e2aa\n'),
+                },
+            ],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/mycustomrepo',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: { data: { data: [] } },
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/packfile',
+                        data: undefined,
+                    },
+                    output: {},
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/packfile',
+                        data: undefined,
+                    },
+                    output: {},
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false, 'https://github.com/DataDog/mycustomrepo');
+        yield expect(upload).resolves.toBe(undefined);
+        mocks.expectCalls();
+    }));
+    test('should omit known commits', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [
+                {
+                    input: [
+                        'rev-list',
+                        '--objects',
+                        '--no-object-names',
+                        '--filter=blob:none',
+                        '--since="1 month ago"',
+                        '^87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                        'cc424c261da5e261b76d982d5d361a023556e2aa',
+                    ],
+                    output: 'cc424c261da5e261b76d982d5d361a023556e2aa\n',
+                },
+            ],
+            revparse: [{ input: '--is-shallow-repository', output: 'false' }],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [
+                {
+                    input: `git pack-objects --compression=9 --max-pack-size=3m ${tmpdir}/1000`,
+                    output: Buffer.from('cc424c261da5e261b76d982d5d361a023556e2aa\n'),
+                },
+            ],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: {
+                        data: {
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/packfile',
+                        data: undefined,
+                    },
+                    output: {},
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).resolves.toBe(undefined);
+        mocks.expectCalls();
+    }));
+    test('retries http requests', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [
+                {
+                    input: [
+                        'rev-list',
+                        '--objects',
+                        '--no-object-names',
+                        '--filter=blob:none',
+                        '--since="1 month ago"',
+                        '^87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                        'cc424c261da5e261b76d982d5d361a023556e2aa',
+                    ],
+                    output: 'cc424c261da5e261b76d982d5d361a023556e2aa\n',
+                },
+            ],
+            revparse: [{ input: '--is-shallow-repository', output: 'false' }],
+            version: [{ input: undefined, output: newGitVersion }],
+            execSync: [
+                {
+                    input: `git pack-objects --compression=9 --max-pack-size=3m ${tmpdir}/1000`,
+                    output: Buffer.from('cc424c261da5e261b76d982d5d361a023556e2aa\n'),
+                },
+            ],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: new Error('http error'),
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: {
+                        data: {
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/packfile',
+                        data: undefined,
+                    },
+                    output: {},
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).resolves.toBe(undefined);
+        mocks.expectCalls();
+    }));
+    test('fails after 3 http requests', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [],
+            revparse: [],
+            version: [],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: new Error('http error'),
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: new Error('http error'),
+                },
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: new Error('http error'),
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow('http error');
+        mocks.expectCalls();
+    }));
+    test('fail immediately if returned format is incorrect', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [],
+            revparse: [],
+            version: [],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: {
+                        data: {
+                            data: [
+                                {
+                                    type: 'commit',
+                                },
+                                {
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).rejects.toThrow('Invalid commit type response');
+        mocks.expectCalls();
+    }));
+    test('all commits are known, no packfile upload', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mocks = new MockAll({
+            getConfig: [
+                {
+                    input: 'clone.defaultRemoteName',
+                    output: defaultRemoteNameNotConfigured,
+                },
+            ],
+            fetch: [],
+            getRemotes: [
+                {
+                    input: undefined,
+                    output: [{ name: 'origin', refs: { push: 'https://github.com/DataDog/datadog-ci' } }],
+                },
+            ],
+            log: [
+                {
+                    input: ['-n 1000', '--since="1 month ago"'],
+                    output: {
+                        all: [
+                            {
+                                hash: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                            },
+                            {
+                                hash: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                            },
+                        ],
+                    },
+                },
+            ],
+            raw: [],
+            revparse: [],
+            version: [],
+            execSync: [],
+            axios: [
+                {
+                    input: {
+                        url: '/api/v2/git/repository/search_commits',
+                        data: {
+                            meta: {
+                                repository_url: 'https://github.com/DataDog/datadog-ci',
+                            },
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                    output: {
+                        data: {
+                            data: [
+                                {
+                                    id: '87ce64f636853fbebc05edfcefe9cccc28a7968b',
+                                    type: 'commit',
+                                },
+                                {
+                                    id: 'cc424c261da5e261b76d982d5d361a023556e2aa',
+                                    type: 'commit',
+                                },
+                            ],
+                        },
+                    },
+                },
+            ],
+        });
+        const upload = (0, gitdb_1.uploadToGitDB)(logger, request, mocks.simpleGit, false);
+        yield expect(upload).resolves.toBe(undefined);
+        mocks.expectCalls();
+    }));
+});
+//# sourceMappingURL=gitdb.test.js.map