@auto-it/core/dist/__tests__/git.test.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var _this = this;
Object.defineProperty(exports, "__esModule", { value: true });
var git_1 = __importDefault(require("../git"));
var authenticate = jest.fn();
var listLabelsOnIssue = jest.fn();
var createRelease = jest.fn();
var getLatestRelease = jest.fn();
var getUser = jest.fn();
var getByUsername = jest.fn();
var getPr = jest.fn();
var createStatus = jest.fn();
var createComment = jest.fn();
var listComments = jest.fn();
var deleteComment = jest.fn();
var listCommits = jest.fn();
var getProject = jest.fn();
var listLabelsForRepo = jest.fn();
var issuesAndPullRequests = jest.fn();
var createLabel = jest.fn();
var updateLabel = jest.fn();
var addLabels = jest.fn();
var list = jest.fn();
var lock = jest.fn();
var errorHook = jest.fn();
var get = jest.fn();
var update = jest.fn();
var paginate = jest.fn();
jest.mock('@octokit/rest', function () {
    var instance = function () { return ({
        authenticate: authenticate,
        paginate: paginate,
        pulls: {
            get: getPr,
            listCommits: { endpoint: listCommits },
            list: list
        },
        issues: {
            listLabelsOnIssue: listLabelsOnIssue,
            createComment: createComment,
            listComments: listComments,
            deleteComment: deleteComment,
            listLabelsForRepo: listLabelsForRepo,
            createLabel: createLabel,
            updateLabel: updateLabel,
            addLabels: addLabels,
            lock: lock,
            get: get,
            update: update
        },
        repos: {
            createStatus: createStatus,
            createRelease: createRelease,
            getLatestRelease: getLatestRelease,
            get: getProject
        },
        search: {
            users: getUser,
            issuesAndPullRequests: issuesAndPullRequests
        },
        users: {
            getByUsername: getByUsername
        },
        hook: {
            error: errorHook
        }
    }); };
    instance.plugin = function () { return instance; };
    return instance;
});
jest.mock('@octokit/graphql', function () { return function () { return ({
    status: 'success'
}); }; });
var options = {
    owner: 'Adam Dierkens',
    repo: 'test',
    token: 'MyToken'
};
describe('github', function () {
    beforeEach(function () {
        authenticate.mockClear();
        listLabelsOnIssue.mockClear();
        createRelease.mockClear();
        getLatestRelease.mockClear();
        getUser.mockClear();
        getPr.mockClear();
        createStatus.mockClear();
        createComment.mockClear();
        listComments.mockClear();
        deleteComment.mockClear();
        listLabelsForRepo.mockClear();
        addLabels.mockClear();
    });
    describe('getLabels', function () {
        test('successful', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        listLabelsOnIssue.mockReturnValueOnce({
                            data: [
                                { name: 'minor' },
                                { name: 'documentation' },
                                { name: 'major' },
                                { name: 'internal' }
                            ]
                        });
                        _a = expect;
                        return [4 /*yield*/, gh.getLabels(123)];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toEqual([
                            'minor',
                            'documentation',
                            'major',
                            'internal'
                        ]);
                        return [2 /*return*/];
                }
            });
        }); });
        test('handles errors', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                gh = new git_1.default(options);
                expect(gh.getLabels(123)).rejects.toBeTruthy();
                return [2 /*return*/];
            });
        }); });
    });
    test('publish', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    return [4 /*yield*/, gh.publish('releaseNotes', 'tag')];
                case 1:
                    _a.sent();
                    expect(createRelease).toHaveBeenCalled();
                    return [2 /*return*/];
            }
        });
    }); });
    test('graphql', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    return [4 /*yield*/, gh.graphql('{ someQuery }')];
                case 1:
                    result = _a.sent();
                    expect(result.status).toBe('success');
                    return [2 /*return*/];
            }
        });
    }); });
    test('getFirstCommit ', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    _a = expect;
                    return [4 /*yield*/, gh.getFirstCommit()];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toBe('0b2af75d8b55c8869cda93d0e5589ad9f2677e18');
                    return [2 /*return*/];
            }
        });
    }); });
    test('addLabelToPr ', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    return [4 /*yield*/, gh.addLabelToPr(123, 'foo bar')];
                case 1:
                    _a.sent();
                    expect(addLabels).toHaveBeenCalled();
                    return [2 /*return*/];
            }
        });
    }); });
    test('lockIssue ', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    return [4 /*yield*/, gh.lockIssue(123)];
                case 1:
                    _a.sent();
                    expect(lock).toHaveBeenCalled();
                    return [2 /*return*/];
            }
        });
    }); });
    test('getCommitDate ', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    _a = expect;
                    return [4 /*yield*/, gh.getCommitDate('0b2af75d8b55c8869cda93d0e5589ad9f2677e18')];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toBe('2018-12-03T15:19:38-0800');
                    return [2 /*return*/];
            }
        });
    }); });
    test('getSha', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    _a = expect;
                    return [4 /*yield*/, gh.getSha()];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toBeDefined();
                    return [2 /*return*/];
            }
        });
    }); });
    test('getLatestTagInBranch', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    _a = expect;
                    return [4 /*yield*/, gh.getLatestTagInBranch()];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toBeDefined();
                    return [2 /*return*/];
            }
        });
    }); });
    test('getGitLog ', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    _a = expect;
                    return [4 /*yield*/, gh.getGitLog('0b2af75d8b55c8869cda93d0e5589ad9f2677e18', 'a7f6634429731055a5a44bae24ac88c5f9822e58')];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toMatchSnapshot();
                    return [2 /*return*/];
            }
        });
    }); });
    test('getUser', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    getPr.mockReturnValueOnce('asdfasdf');
                    _a = expect;
                    return [4 /*yield*/, gh.getPullRequest(22)];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toBe('asdfasdf');
                    return [2 /*return*/];
            }
        });
    }); });
    test('createStatus', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    createStatus.mockReturnValueOnce(true);
                    _a = expect;
                    return [4 /*yield*/, gh.createStatus({
                            state: 'pending',
                            sha: '',
                            context: 'foo',
                            target_url: 'google.com',
                            description: 'testing'
                        })];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toBeTruthy();
                    return [2 /*return*/];
            }
        });
    }); });
    test('search', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    issuesAndPullRequests.mockReturnValueOnce({ data: true });
                    return [4 /*yield*/, gh.searchRepo({
                            q: 'is:pr is:open',
                            order: 'desc'
                        })];
                case 1:
                    _a.sent();
                    expect(issuesAndPullRequests).toHaveBeenCalledWith({
                        q: 'repo:Adam Dierkens/test is:pr is:open',
                        order: 'desc'
                    });
                    return [2 /*return*/];
            }
        });
    }); });
    test('getProject', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    gh = new git_1.default(options);
                    getProject.mockReturnValueOnce({ data: true });
                    _a = expect;
                    return [4 /*yield*/, gh.getProject()];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toBeTruthy();
                    return [2 /*return*/];
            }
        });
    }); });
    describe('createComment', function () {
        test('should post comment if none exists', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        listComments.mockReturnValueOnce({ data: [] });
                        return [4 /*yield*/, gh.createComment('Some long thing', 22, 'default')];
                    case 1:
                        _a.sent();
                        expect(createComment).toHaveBeenCalled();
                        return [2 /*return*/];
                }
            });
        }); });
        test('should delete old comment', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        listComments.mockReturnValueOnce({
                            data: [
                                {
                                    body: '<!-- GITHUB_RELEASE COMMENT: default -->\nSome cool message',
                                    id: 1337
                                }
                            ]
                        });
                        return [4 /*yield*/, gh.createComment('Some long thing', 22, 'default')];
                    case 1:
                        _a.sent();
                        expect(deleteComment).toHaveBeenCalled();
                        expect(deleteComment.mock.calls[0][0].comment_id).toBe(1337);
                        expect(createComment).toHaveBeenCalled();
                        return [2 /*return*/];
                }
            });
        }); });
        test('should be able to comment in different contexts', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        listComments.mockReturnValueOnce({
                            data: [
                                {
                                    body: '<!-- GITHUB_RELEASE COMMENT: default -->\nSome cool message',
                                    id: 1337
                                }
                            ]
                        });
                        return [4 /*yield*/, gh.createComment('Some long thing', 22, 'PERF')];
                    case 1:
                        _a.sent();
                        expect(deleteComment).not.toHaveBeenCalled();
                        expect(createComment).toHaveBeenCalled();
                        listComments.mockReturnValueOnce({
                            data: [
                                {
                                    body: '<!-- GITHUB_RELEASE COMMENT: default -->\nSome cool message',
                                    id: 1337
                                },
                                {
                                    body: '<!-- GITHUB_RELEASE COMMENT: PERF -->\nSome cool message',
                                    id: 1000
                                }
                            ]
                        });
                        return [4 /*yield*/, gh.createComment('Some new thing', 22, 'PERF')];
                    case 2:
                        _a.sent();
                        expect(deleteComment).toHaveBeenCalled();
                        expect(deleteComment.mock.calls[0][0].comment_id).toBe(1000);
                        return [2 /*return*/];
                }
            });
        }); });
    });
    describe('addToPrBody', function () {
        test('should add to PR body if none exists', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        get.mockReturnValueOnce({ data: { body: '# My Content' } });
                        return [4 /*yield*/, gh.addToPrBody('Some long thing', 22)];
                    case 1:
                        _a.sent();
                        expect(update).toHaveBeenCalledWith(expect.objectContaining({
                            body: '# My Content\n<!-- GITHUB_RELEASE PR BODY: default -->\nSome long thing\n<!-- GITHUB_RELEASE PR BODY: default -->\n'
                        }));
                        return [2 /*return*/];
                }
            });
        }); });
        test('should add to PR body if none exists', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        get.mockReturnValueOnce({ data: { body: '# My Content' } });
                        return [4 /*yield*/, gh.addToPrBody('', 22)];
                    case 1:
                        _a.sent();
                        expect(update).toHaveBeenCalledWith(expect.objectContaining({
                            body: '# My Content'
                        }));
                        return [2 /*return*/];
                }
            });
        }); });
        test('should overwrite old context', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        get.mockReturnValueOnce({
                            data: {
                                body: '# My Content\n<!-- GITHUB_RELEASE PR BODY: default -->\n\n\nSome long thing\nand more\n<!-- GITHUB_RELEASE PR BODY: default -->\n'
                            }
                        });
                        return [4 /*yield*/, gh.addToPrBody('Something else', 22)];
                    case 1:
                        _a.sent();
                        expect(update).toHaveBeenCalledWith(expect.objectContaining({
                            body: '# My Content\n<!-- GITHUB_RELEASE PR BODY: default -->\nSomething else\n<!-- GITHUB_RELEASE PR BODY: default -->\n'
                        }));
                        return [2 /*return*/];
                }
            });
        }); });
        test('should be able to add to body in different contexts', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        get.mockReturnValueOnce({
                            data: {
                                body: '# My Content\n<!-- GITHUB_RELEASE PR BODY: default -->\nSomething else\n<!-- GITHUB_RELEASE PR BODY: default -->\n'
                            }
                        });
                        return [4 /*yield*/, gh.addToPrBody('Some long thing', 22, 'PERF')];
                    case 1:
                        _a.sent();
                        expect(update).toHaveBeenCalledWith(expect.objectContaining({
                            body: '# My Content\n<!-- GITHUB_RELEASE PR BODY: default -->\nSomething else\n<!-- GITHUB_RELEASE PR BODY: default -->\n\n<!-- GITHUB_RELEASE PR BODY: PERF -->\nSome long thing\n<!-- GITHUB_RELEASE PR BODY: PERF -->\n'
                        }));
                        return [2 /*return*/];
                }
            });
        }); });
        test('should clear pr body section if message blank', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        get.mockReturnValueOnce({ data: { body: '# My Content' } });
                        get.mockReturnValueOnce({
                            data: {
                                body: '# My Content\n<!-- GITHUB_RELEASE PR BODY: default -->\nSomething else\n<!-- GITHUB_RELEASE PR BODY: default -->'
                            }
                        });
                        return [4 /*yield*/, gh.addToPrBody('Some long thing', 22)];
                    case 1:
                        _a.sent();
                        update.mockClear();
                        return [4 /*yield*/, gh.addToPrBody('', 22)];
                    case 2:
                        _a.sent();
                        expect(update).toHaveBeenCalledWith(expect.objectContaining({
                            body: '# My Content\n'
                        }));
                        return [2 /*return*/];
                }
            });
        }); });
    });
    test('getCommitsForPR', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    listCommits.mockReturnValueOnce({
                        data: undefined
                    });
                    return [4 /*yield*/, gh.getCommitsForPR(22)];
                case 1:
                    _a.sent();
                    expect(listCommits).toHaveBeenCalled();
                    return [2 /*return*/];
            }
        });
    }); });
    test('getCommitsForPR', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    list.mockReturnValueOnce({
                        data: undefined
                    });
                    return [4 /*yield*/, gh.getPullRequests()];
                case 1:
                    _a.sent();
                    expect(listCommits).toHaveBeenCalled();
                    return [2 /*return*/];
            }
        });
    }); });
    describe('getUserByUsername', function () {
        test('exists', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        getByUsername.mockReturnValueOnce({
                            data: { name: 'Andrew Lisowski' }
                        });
                        _a = expect;
                        return [4 /*yield*/, gh.getUserByUsername('andrew')];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toEqual({
                            name: 'Andrew Lisowski'
                        });
                        return [2 /*return*/];
                }
            });
        }); });
        test('not found', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        getByUsername.mockRejectedValueOnce(Error);
                        _a = expect;
                        return [4 /*yield*/, gh.getUserByUsername('andrew')];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toBeUndefined();
                        return [2 /*return*/];
                }
            });
        }); });
    });
    describe('getUserByEmail', function () {
        test('exists', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        getUser.mockReturnValueOnce({
                            data: { items: [{ login: 'hipstersmoothie' }] }
                        });
                        _a = expect;
                        return [4 /*yield*/, gh.getUserByEmail('lisowski54@gmail.com')];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toEqual({
                            login: 'hipstersmoothie'
                        });
                        return [2 /*return*/];
                }
            });
        }); });
        test('doesnt exist', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        getUser.mockReturnValueOnce({
                            data: undefined
                        });
                        _a = expect;
                        return [4 /*yield*/, gh.getUserByEmail('lisowski54@gmail.com')];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toEqual({});
                        return [2 /*return*/];
                }
            });
        }); });
        test('errors', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        getByUsername.mockRejectedValueOnce(Error);
                        _a = expect;
                        return [4 /*yield*/, gh.getUserByEmail('lisowski54@gmail.com')];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toBeUndefined();
                        return [2 /*return*/];
                }
            });
        }); });
    });
    describe('getLatestRelease', function () {
        test('has tag ', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        getLatestRelease.mockReturnValueOnce({ data: { tag_name: '1.0.0' } });
                        _a = expect;
                        return [4 /*yield*/, gh.getLatestRelease()];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toBe('1.0.0');
                        return [2 /*return*/];
                }
            });
        }); });
        test('no tags', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        getLatestRelease.mockRejectedValueOnce({ status: 404 });
                        _a = expect;
                        return [4 /*yield*/, gh.getLatestRelease()];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toBe('0b2af75d8b55c8869cda93d0e5589ad9f2677e18');
                        return [2 /*return*/];
                }
            });
        }); });
        test('handles errors', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                gh = new git_1.default(options);
                expect(gh.getLatestRelease()).rejects.toBeTruthy();
                return [2 /*return*/];
            });
        }); });
    });
    describe('getProjectLabels ', function () {
        test('return labels', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        listLabelsForRepo.mockReturnValueOnce({
                            data: [{ name: 'first label' }, { name: 'second label' }]
                        });
                        _a = expect;
                        return [4 /*yield*/, gh.getProjectLabels()];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toEqual([
                            'first label',
                            'second label'
                        ]);
                        return [2 /*return*/];
                }
            });
        }); });
        test('throw for errors', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                gh = new git_1.default(options);
                expect(gh.getProjectLabels()).rejects.toBeTruthy();
                return [2 /*return*/];
            });
        }); });
    });
    describe('getPr ', function () {
        test('return pr', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh, _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        gh = new git_1.default(options);
                        get.mockReturnValueOnce({ success: true });
                        _a = expect;
                        return [4 /*yield*/, gh.getPr(123)];
                    case 1:
                        _a.apply(void 0, [_b.sent()]).toEqual({ success: true });
                        return [2 /*return*/];
                }
            });
        }); });
        test('throw for errors', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        get.mockRejectedValueOnce(Error);
                        return [4 /*yield*/, expect(gh.getPr(120)).rejects.toBeTruthy()];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        }); });
    });
    test('updateLabel', function () { return __awaiter(_this, void 0, void 0, function () {
        var gh;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    gh = new git_1.default(options);
                    return [4 /*yield*/, gh.updateLabel('release', { name: 'Foo bar', description: 'test' })];
                case 1:
                    _a.sent();
                    expect(updateLabel).toHaveBeenCalledWith(expect.objectContaining({
                        owner: 'Adam Dierkens',
                        repo: 'test',
                        current_name: 'Foo bar',
                        description: 'test'
                    }));
                    return [2 /*return*/];
            }
        });
    }); });
    describe('createLabel', function () {
        test('should create a label', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        gh = new git_1.default(options);
                        return [4 /*yield*/, gh.createLabel('release', { name: 'Foo bar', description: 'test' })];
                    case 1:
                        _a.sent();
                        expect(createLabel).toHaveBeenCalledWith(expect.objectContaining({
                            owner: 'Adam Dierkens',
                            repo: 'test',
                            name: 'Foo bar'
                        }));
                        return [2 /*return*/];
                }
            });
        }); });
        test('throw for errors', function () { return __awaiter(_this, void 0, void 0, function () {
            var gh;
            return __generator(this, function (_a) {
                gh = new git_1.default(options);
                expect(gh.getProjectLabels()).rejects.toBeTruthy();
                return [2 /*return*/];
            });
        }); });
    });
    describe('error hook', function () {
        test('strip authorization headers from error', function () {
            var error = function (headers) {
                if (headers === void 0) { headers = {}; }
                return ({
                    name: 'Request failed',
                    message: 'The request has failed',
                    status: 404,
                    headers: headers
                });
            };
            // tslint:disable-next-line:no-unused
            var gh = new git_1.default(options);
            expect(errorHook).toBeCalled();
            var errorHandler = errorHook.mock.calls[0][1];
            expect(errorHandler.bind(undefined, error({ authorization: 'token abc' }))).toThrow(error());
        });
    });
});
//# sourceMappingURL=git.test.js.map