@datadog/datadog-ci 2.40.3 → 2.41.0

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

@@ -1,1386 +0,0 @@
-"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