index.spec.ts

import fs from 'fs-extra';
import * as httpMock from '../../../test/httpMock';
import { mocked } from '../../../test/util';
import {
  REPOSITORY_DISABLED,
  REPOSITORY_NOT_FOUND,
  REPOSITORY_RENAMED,
} from '../../constants/error-messages';
import { BranchStatus } from '../../types';
import { Platform } from '../common';

const githubApiHost = 'https://api.github.com';

describe('platform/github', () => {
  let github: Platform;
  let hostRules: jest.Mocked<typeof import('../../util/host-rules')>;
  let GitStorage: jest.Mock<typeof import('../git')>;
  beforeEach(async () => {
    // reset module
    jest.resetModules();
    jest.unmock('.');
    jest.mock('delay');
    jest.mock('../../util/host-rules');
    github = await import('.');
    hostRules = mocked(await import('../../util/host-rules'));
    jest.mock('../git');
    GitStorage = (await import('../git')).Storage as any;
    GitStorage.mockImplementation(
      () =>
        ({
          initRepo: jest.fn(),
          cleanRepo: jest.fn(),
          getFileList: jest.fn(),
          branchExists: jest.fn(() => true),
          isBranchStale: jest.fn(() => false),
          setBaseBranch: jest.fn(),
          getBranchLastCommitTime: jest.fn(),
          getAllRenovateBranches: jest.fn(),
          getCommitMessages: jest.fn(),
          getFile: jest.fn(),
          commitFiles: jest.fn(),
          mergeBranch: jest.fn(),
          deleteBranch: jest.fn(),
          getRepoStatus: jest.fn(),
          getBranchCommit: jest.fn(
            () => '0d9c7726c3d628b7e28af234595cfd20febdbf8e'
          ),
        } as any)
    );
    delete global.gitAuthor;
    hostRules.find.mockReturnValue({
      token: 'abc123',
    });
    httpMock.setup();
  });

  afterEach(() => {
    httpMock.reset();
  });

  const graphqlOpenPullRequests = fs.readFileSync(
    'lib/platform/github/__fixtures__/graphql/pullrequest-1.json',
    'utf8'
  );
  const graphqlClosedPullRequests = fs.readFileSync(
    'lib/platform/github/__fixtures__/graphql/pullrequests-closed.json',
    'utf8'
  );

  describe('initPlatform()', () => {
    it('should throw if no token', async () => {
      await expect(github.initPlatform({} as any)).rejects.toThrow(
        'Init: You must configure a GitHub personal access token'
      );
    });
    it('should throw if user failure', async () => {
      httpMock.scope(githubApiHost).get('/user').reply(404);
      await expect(
        github.initPlatform({ token: 'abc123' } as any)
      ).rejects.toThrow();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should support default endpoint no email access', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/user')
        .reply(200, {
          login: 'renovate-bot',
        })
        .get('/user/emails')
        .reply(400);
      expect(
        await github.initPlatform({ token: 'abc123' } as any)
      ).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should support default endpoint no email result', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/user')
        .reply(200, {
          login: 'renovate-bot',
        })
        .get('/user/emails')
        .reply(200, [{}]);
      expect(
        await github.initPlatform({ token: 'abc123' } as any)
      ).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should support default endpoint with email', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/user')
        .reply(200, {
          login: 'renovate-bot',
        })
        .get('/user/emails')
        .reply(200, [
          {
            email: 'user@domain.com',
          },
        ]);
      expect(
        await github.initPlatform({ token: 'abc123' } as any)
      ).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should support custom endpoint', async () => {
      httpMock
        .scope('https://ghe.renovatebot.com')
        .get('/user')
        .reply(200, {
          login: 'renovate-bot',
        })
        .get('/user/emails')
        .reply(200, [
          {
            email: 'user@domain.com',
          },
        ]);
      expect(
        await github.initPlatform({
          endpoint: 'https://ghe.renovatebot.com',
          token: 'abc123',
        })
      ).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });

  describe('getRepos', () => {
    it('should return an array of repos', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/user/repos?per_page=100')
        .reply(200, [
          {
            full_name: 'a/b',
          },
          {
            full_name: 'c/d',
          },
        ]);
      const repos = await github.getRepos();
      expect(repos).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });

  function initRepoMock(scope: httpMock.Scope, repository: string): void {
    scope.get(`/repos/${repository}`).reply(200, {
      owner: {
        login: 'theowner',
      },
      default_branch: 'master',
      allow_rebase_merge: true,
      allow_squash_merge: true,
      allow_merge_commit: true,
    });
  }

  function forkInitRepoMock(
    scope: httpMock.Scope,
    repository: string,
    forkedRepo?: string
  ): void {
    scope
      // repo info
      .get(`/repos/${repository}`)
      .reply(200, {
        owner: {
          login: 'theowner',
        },
        default_branch: 'master',
        allow_rebase_merge: true,
        allow_squash_merge: true,
        allow_merge_commit: true,
      })
      // getBranchCommit
      .get(`/repos/${repository}/git/refs/heads/master`)
      .reply(200, {
        object: {
          sha: '1234',
        },
      })
      // getRepos
      .get('/user/repos?per_page=100')
      .reply(200, forkedRepo ? [{ full_name: forkedRepo }] : [])
      // getBranchCommit
      .post(`/repos/${repository}/forks`)
      .reply(200, forkedRepo ? { full_name: forkedRepo } : {});
  }

  describe('initRepo', () => {
    it('should throw err if disabled in renovate.json', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.get('/repos/some/repo/contents/renovate.json').reply(200, {
        content: Buffer.from('{"enabled": false}').toString('base64'),
      });

      await expect(
        github.initRepo({
          repository: 'some/repo',
          optimizeForDisabled: true,
        } as any)
      ).rejects.toThrow(REPOSITORY_DISABLED);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should rebase', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      const config = await github.initRepo({
        repository: 'some/repo',
      } as any);
      expect(config).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should fork when forkMode', async () => {
      const scope = httpMock.scope(githubApiHost);
      forkInitRepoMock(scope, 'some/repo');
      const config = await github.initRepo({
        repository: 'some/repo',
        forkMode: true,
      } as any);
      expect(config).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should update fork when forkMode', async () => {
      const scope = httpMock.scope(githubApiHost);
      forkInitRepoMock(scope, 'some/repo', 'forked_repo');
      scope.patch('/repos/forked_repo/git/refs/heads/master').reply(200);
      const config = await github.initRepo({
        repository: 'some/repo',
        forkMode: true,
      } as any);
      expect(config).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should squash', async () => {
      httpMock
        .scope(githubApiHost)
        .get(`/repos/some/repo`)
        .reply(200, {
          owner: {
            login: 'theowner',
          },
          default_branch: 'master',
          allow_rebase_merge: false,
          allow_squash_merge: true,
          allow_merge_commit: true,
        });
      const config = await github.initRepo({
        repository: 'some/repo',
      } as any);
      expect(config).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should merge', async () => {
      httpMock
        .scope(githubApiHost)
        .get(`/repos/some/repo`)
        .reply(200, {
          owner: {
            login: 'theowner',
          },
          default_branch: 'master',
          allow_rebase_merge: false,
          allow_squash_merge: false,
          allow_merge_commit: true,
        });
      const config = await github.initRepo({
        repository: 'some/repo',
      } as any);
      expect(config).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should not guess at merge', async () => {
      httpMock
        .scope(githubApiHost)
        .get(`/repos/some/repo`)
        .reply(200, {
          owner: {
            login: 'theowner',
          },
          default_branch: 'master',
        });
      const config = await github.initRepo({
        repository: 'some/repo',
      } as any);
      expect(config).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should throw error if archived', async () => {
      httpMock.scope(githubApiHost).get(`/repos/some/repo`).reply(200, {
        archived: true,
        owner: {},
      });
      await expect(
        github.initRepo({
          repository: 'some/repo',
        } as any)
      ).rejects.toThrow();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('throws not-found', async () => {
      httpMock.scope(githubApiHost).get(`/repos/some/repo`).reply(404);
      await expect(
        github.initRepo({
          repository: 'some/repo',
        } as any)
      ).rejects.toThrow(REPOSITORY_NOT_FOUND);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should throw error if renamed', async () => {
      httpMock.scope(githubApiHost).get(`/repos/some/repo`).reply(200, {
        fork: true,
        full_name: 'some/other',
        owner: {},
      });
      await expect(
        github.initRepo({
          includeForks: true,
          repository: 'some/repo',
        } as any)
      ).rejects.toThrow(REPOSITORY_RENAMED);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('getRepoForceRebase', () => {
    it('should detect repoForceRebase', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/repos/undefined/branches/undefined/protection')
        .reply(200, {
          required_pull_request_reviews: {
            dismiss_stale_reviews: false,
            require_code_owner_reviews: false,
          },
          required_status_checks: {
            strict: true,
            contexts: [],
          },
          restrictions: {
            users: [
              {
                login: 'rarkins',
                id: 6311784,
                type: 'User',
                site_admin: false,
              },
            ],
            teams: [],
          },
        });
      const res = await github.getRepoForceRebase();
      expect(res).toBe(true);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should handle 404', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/repos/undefined/branches/undefined/protection')
        .reply(404);
      const res = await github.getRepoForceRebase();
      expect(res).toBe(false);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should handle 403', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/repos/undefined/branches/undefined/protection')
        .reply(403);
      const res = await github.getRepoForceRebase();
      expect(res).toBe(false);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should throw 401', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/repos/undefined/branches/undefined/protection')
        .reply(401);
      await expect(github.getRepoForceRebase()).rejects.toMatchObject({
        statusCode: 401,
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('getBranchPr(branchName)', () => {
    it('should return null if no PR exists', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.get('/repos/some/repo/pulls?per_page=100&state=all').reply(200, []);

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const pr = await github.getBranchPr('somebranch');
      expect(pr).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return the PR object', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .twice()
        .reply(200, {})
        .get('/repos/some/repo/pulls?per_page=100&state=all')
        .reply(200, [
          {
            number: 90,
            head: { ref: 'somebranch', repo: { full_name: 'other/repo' } },
            state: 'open',
          },
          {
            number: 91,
            head: { ref: 'somebranch', repo: { full_name: 'some/repo' } },
            state: 'open',
          },
        ])
        .get('/repos/some/repo/pulls/91')
        .reply(200, {
          number: 91,
          additions: 1,
          deletions: 1,
          commits: 1,
          base: {
            sha: '1234',
          },
          head: { ref: 'somebranch', repo: { full_name: 'some/repo' } },
          state: 'open',
        })
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, { object: { sha: '12345' } });

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const pr = await github.getBranchPr('somebranch');
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return the PR object in fork mode', async () => {
      const scope = httpMock.scope(githubApiHost);
      forkInitRepoMock(scope, 'some/repo', 'forked/repo');
      scope
        .post('/graphql')
        .twice()
        .reply(200, {})
        .get('/repos/some/repo/pulls?per_page=100&state=all')
        .reply(200, [
          {
            number: 90,
            head: { ref: 'somebranch', repo: { full_name: 'other/repo' } },
            state: 'open',
          },
          {
            number: 91,
            head: { ref: 'somebranch', repo: { full_name: 'some/repo' } },
            state: 'open',
          },
        ])
        .get('/repos/some/repo/pulls/90')
        .reply(200, {
          number: 90,
          additions: 1,
          deletions: 1,
          commits: 1,
          base: {
            sha: '1234',
          },
          head: { ref: 'somebranch', repo: { full_name: 'other/repo' } },
          state: 'open',
        })
        .get('/repos/forked/repo/git/refs/heads/master')
        .reply(200, { object: { sha: '12345' } })
        .patch('/repos/forked/repo/git/refs/heads/master')
        .reply(200);
      await github.initRepo({
        repository: 'some/repo',
        forkMode: true,
      } as any);
      const pr = await github.getBranchPr('somebranch');
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('getBranchStatus()', () => {
    it('returns success if requiredStatusChecks null', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', null);
      expect(res).toEqual(BranchStatus.green);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('return failed if unsupported requiredStatusChecks', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', ['foo']);
      expect(res).toEqual(BranchStatus.red);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should pass through success', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/commits/somebranch/status')
        .reply(200, {
          state: 'success',
        })
        .get('/repos/some/repo/commits/somebranch/check-runs')
        .reply(200, []);

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', []);
      expect(res).toEqual(BranchStatus.green);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should pass through failed', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/commits/somebranch/status')
        .reply(200, {
          state: 'failure',
        })
        .get('/repos/some/repo/commits/somebranch/check-runs')
        .reply(200, []);

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', []);
      expect(res).toEqual(BranchStatus.red);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('defaults to pending', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/commits/somebranch/status')
        .reply(200, {
          state: 'unknown',
        })
        .get('/repos/some/repo/commits/somebranch/check-runs')
        .reply(200, []);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', []);
      expect(res).toEqual(BranchStatus.yellow);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should fail if a check run has failed', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/commits/somebranch/status')
        .reply(200, {
          state: 'pending',
          statuses: [],
        })
        .get('/repos/some/repo/commits/somebranch/check-runs')
        .reply(200, {
          total_count: 2,
          check_runs: [
            {
              id: 23950198,
              status: 'completed',
              conclusion: 'success',
              name: 'Travis CI - Pull Request',
            },
            {
              id: 23950195,
              status: 'completed',
              conclusion: 'failure',
              name: 'Travis CI - Branch',
            },
          ],
        });
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', []);
      expect(res).toEqual(BranchStatus.red);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should succeed if no status and all passed check runs', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/commits/somebranch/status')
        .reply(200, {
          state: 'pending',
          statuses: [],
        })
        .get('/repos/some/repo/commits/somebranch/check-runs')
        .reply(200, {
          total_count: 3,
          check_runs: [
            {
              id: 2390199,
              status: 'completed',
              conclusion: 'skipped',
              name: 'Conditional GitHub Action',
            },
            {
              id: 23950198,
              status: 'completed',
              conclusion: 'success',
              name: 'Travis CI - Pull Request',
            },
            {
              id: 23950195,
              status: 'completed',
              conclusion: 'success',
              name: 'Travis CI - Branch',
            },
          ],
        });
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', []);
      expect(res).toEqual(BranchStatus.green);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should fail if a check run is pending', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/commits/somebranch/status')
        .reply(200, {
          state: 'pending',
          statuses: [],
        })
        .get('/repos/some/repo/commits/somebranch/check-runs')
        .reply(200, {
          total_count: 2,
          check_runs: [
            {
              id: 23950198,
              status: 'completed',
              conclusion: 'success',
              name: 'Travis CI - Pull Request',
            },
            {
              id: 23950195,
              status: 'pending',
              name: 'Travis CI - Branch',
            },
          ],
        });
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatus('somebranch', []);
      expect(res).toEqual(BranchStatus.yellow);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('getBranchStatusCheck', () => {
    it('returns state if found', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get(
          '/repos/some/repo/commits/0d9c7726c3d628b7e28af234595cfd20febdbf8e/statuses'
        )
        .reply(200, [
          {
            context: 'context-1',
            state: 'success',
          },
          {
            context: 'context-2',
            state: 'pending',
          },
          {
            context: 'context-3',
            state: 'failure',
          },
        ]);
      await github.initRepo({
        repository: 'some/repo',
        token: 'token',
      } as any);
      const res = await github.getBranchStatusCheck(
        'renovate/future_branch',
        'context-2'
      );
      expect(res).toEqual(BranchStatus.yellow);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('returns null', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get(
          '/repos/some/repo/commits/0d9c7726c3d628b7e28af234595cfd20febdbf8e/statuses'
        )
        .reply(200, [
          {
            context: 'context-1',
            state: 'success',
          },
          {
            context: 'context-2',
            state: 'pending',
          },
          {
            context: 'context-3',
            state: 'error',
          },
        ]);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const res = await github.getBranchStatusCheck('somebranch', 'context-4');
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('setBranchStatus', () => {
    it('returns if already set', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get(
          '/repos/some/repo/commits/0d9c7726c3d628b7e28af234595cfd20febdbf8e/statuses'
        )
        .reply(200, [
          {
            context: 'some-context',
            state: 'pending',
          },
        ]);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.setBranchStatus({
        branchName: 'some-branch',
        context: 'some-context',
        description: 'some-description',
        state: BranchStatus.yellow,
        url: 'some-url',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('sets branch status', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get(
          '/repos/some/repo/commits/0d9c7726c3d628b7e28af234595cfd20febdbf8e/statuses'
        )
        .reply(200, [
          {
            context: 'context-1',
            state: 'state-1',
          },
          {
            context: 'context-2',
            state: 'state-2',
          },
          {
            context: 'context-3',
            state: 'state-3',
          },
        ])
        .post(
          '/repos/some/repo/statuses/0d9c7726c3d628b7e28af234595cfd20febdbf8e'
        )
        .reply(200)
        .get('/repos/some/repo/commits/some-branch/status')
        .reply(200, {})
        .get(
          '/repos/some/repo/commits/0d9c7726c3d628b7e28af234595cfd20febdbf8e/statuses'
        )
        .reply(200, {});

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.setBranchStatus({
        branchName: 'some-branch',
        context: 'some-context',
        description: 'some-description',
        state: BranchStatus.green,
        url: 'some-url',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('findIssue()', () => {
    it('returns null if no issue', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'open',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        });
      const res = await github.findIssue('title-3');
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('finds issue', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'open',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .get('/repos/undefined/issues/2')
        .reply(200, { body: 'new-content' });
      const res = await github.findIssue('title-2');
      expect(res).not.toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('ensureIssue()', () => {
    it('creates issue', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'open',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .post('/repos/undefined/issues')
        .reply(200);
      const res = await github.ensureIssue({
        title: 'new-title',
        body: 'new-content',
      });
      expect(res).toEqual('created');
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('creates issue if not ensuring only once', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'closed',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .get('/repos/undefined/issues/1')
        .reply(404);
      const res = await github.ensureIssue({
        title: 'title-1',
        body: 'new-content',
      });
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('does not create issue if ensuring only once', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'closed',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        });
      const once = true;
      const res = await github.ensureIssue({
        title: 'title-1',
        body: 'new-content',
        once,
      });
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('closes others if ensuring only once', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 3,
                    state: 'open',
                    title: 'title-1',
                  },
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'closed',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .get('/repos/undefined/issues/3')
        .reply(404);
      const once = true;
      const res = await github.ensureIssue({
        title: 'title-1',
        body: 'new-content',
        once,
      });
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('updates issue', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'open',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .get('/repos/undefined/issues/2')
        .reply(200, { body: 'new-content' })
        .patch('/repos/undefined/issues/2')
        .reply(200);
      const res = await github.ensureIssue({
        title: 'title-2',
        body: 'newer-content',
      });
      expect(res).toEqual('updated');
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('skips update if unchanged', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'open',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .get('/repos/undefined/issues/2')
        .reply(200, { body: 'newer-content' });
      const res = await github.ensureIssue({
        title: 'title-2',
        body: 'newer-content',
      });
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('deletes if duplicate', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-1',
                  },
                  {
                    number: 1,
                    state: 'open',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .patch('/repos/undefined/issues/1')
        .reply(200)
        .get('/repos/undefined/issues/2')
        .reply(200, { body: 'newer-content' });
      const res = await github.ensureIssue({
        title: 'title-1',
        body: 'newer-content',
      });
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('creates issue if reopen flag false and issue is not open', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'close',
                    title: 'title-2',
                  },
                ],
              },
            },
          },
        })
        .get('/repos/undefined/issues/2')
        .reply(200, { body: 'new-content' })
        .post('/repos/undefined/issues')
        .reply(200);
      const res = await github.ensureIssue({
        title: 'title-2',
        body: 'new-content',
        once: false,
        shouldReOpen: false,
      });
      expect(res).toEqual('created');
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('does not create issue if reopen flag false and issue is already open', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                ],
              },
            },
          },
        })
        .get('/repos/undefined/issues/2')
        .reply(200, { body: 'new-content' });
      const res = await github.ensureIssue({
        title: 'title-2',
        body: 'new-content',
        once: false,
        shouldReOpen: false,
      });
      expect(res).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('ensureIssueClosing()', () => {
    it('closes issue', async () => {
      httpMock
        .scope(githubApiHost)
        .post('/graphql')
        .reply(200, {
          data: {
            repository: {
              issues: {
                pageInfo: {
                  startCursor: null,
                  hasNextPage: false,
                  endCursor: null,
                },
                nodes: [
                  {
                    number: 2,
                    state: 'open',
                    title: 'title-2',
                  },
                  {
                    number: 1,
                    state: 'open',
                    title: 'title-1',
                  },
                ],
              },
            },
          },
        })
        .patch('/repos/undefined/issues/2')
        .reply(200);
      await github.ensureIssueClosing('title-2');
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('deleteLabel(issueNo, label)', () => {
    it('should delete the label', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.delete('/repos/some/repo/issues/42/labels/rebase').reply(200);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.deleteLabel(42, 'rebase');
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('addAssignees(issueNo, assignees)', () => {
    it('should add the given assignees to the issue', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.post('/repos/some/repo/issues/42/assignees').reply(200);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.addAssignees(42, ['someuser', 'someotheruser']);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('addReviewers(issueNo, reviewers)', () => {
    it('should add the given reviewers to the PR', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.post('/repos/some/repo/pulls/42/requested_reviewers').reply(200);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.addReviewers(42, [
        'someuser',
        'someotheruser',
        'team:someteam',
      ]);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('ensureComment', () => {
    it('add comment if not found', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, {})
        .get('/repos/some/repo/issues/42/comments?per_page=100')
        .reply(200, [])
        .post('/repos/some/repo/issues/42/comments')
        .reply(200);

      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.ensureComment({
        number: 42,
        topic: 'some-subject',
        content: 'some\ncontent',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('adds comment if found in closed PR list', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, graphqlClosedPullRequests)
        .post('/repos/some/repo/issues/2499/comments')
        .reply(200);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.ensureComment({
        number: 2499,
        topic: 'some-subject',
        content: 'some\ncontent',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('add updates comment if necessary', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, {})
        .get('/repos/some/repo/issues/42/comments?per_page=100')
        .reply(200, [{ id: 1234, body: '### some-subject\n\nblablabla' }])
        .patch('/repos/some/repo/issues/comments/1234')
        .reply(200);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.ensureComment({
        number: 42,
        topic: 'some-subject',
        content: 'some\ncontent',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('skips comment', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, {})
        .get('/repos/some/repo/issues/42/comments?per_page=100')
        .reply(200, [{ id: 1234, body: '### some-subject\n\nsome\ncontent' }]);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.ensureComment({
        number: 42,
        topic: 'some-subject',
        content: 'some\ncontent',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('handles comment with no description', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, {})
        .get('/repos/some/repo/issues/42/comments?per_page=100')
        .reply(200, [{ id: 1234, body: '!merge' }]);
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      await github.ensureComment({
        number: 42,
        topic: null,
        content: '!merge',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('ensureCommentRemoval', () => {
    it('deletes comment by topic if found', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, {})
        .get('/repos/some/repo/issues/42/comments?per_page=100')
        .reply(200, [{ id: 1234, body: '### some-subject\n\nblablabla' }])
        .delete('/repos/some/repo/issues/comments/1234')
        .reply(200);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      await github.ensureCommentRemoval({ number: 42, topic: 'some-subject' });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('deletes comment by content if found', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, {})
        .get('/repos/some/repo/issues/42/comments?per_page=100')
        .reply(200, [{ id: 1234, body: 'some-content' }])
        .delete('/repos/some/repo/issues/comments/1234')
        .reply(200);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      await github.ensureCommentRemoval({
        number: 42,
        content: 'some-content',
      });
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('findPr(branchName, prTitle, state)', () => {
    it('returns true if no title and all state', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/repos/undefined/pulls?per_page=100&state=all')
        .reply(200, [
          {
            number: 1,
            head: { ref: 'branch-a' },
            title: 'branch a pr',
            state: 'open',
          },
        ]);

      const res = await github.findPr({
        branchName: 'branch-a',
      });
      expect(res).toBeDefined();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('returns true if not open', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/repos/undefined/pulls?per_page=100&state=all')
        .reply(200, [
          {
            number: 1,
            head: { ref: 'branch-a' },
            title: 'branch a pr',
            state: 'closed',
          },
        ]);

      const res = await github.findPr({
        branchName: 'branch-a',
        state: '!open',
      });
      expect(res).toBeDefined();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('caches pr list', async () => {
      httpMock
        .scope(githubApiHost)
        .get('/repos/undefined/pulls?per_page=100&state=all')
        .reply(200, [
          {
            number: 1,
            head: { ref: 'branch-a' },
            title: 'branch a pr',
            state: 'open',
          },
        ]);
      let res = await github.findPr({ branchName: 'branch-a' });
      expect(res).toBeDefined();
      res = await github.findPr({
        branchName: 'branch-a',
        prTitle: 'branch a pr',
      });
      expect(res).toBeDefined();
      res = await github.findPr({
        branchName: 'branch-a',
        prTitle: 'branch a pr',
        state: 'open',
      });
      expect(res).toBeDefined();
      res = await github.findPr({ branchName: 'branch-b' });
      expect(res).not.toBeDefined();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('createPr()', () => {
    it('should create and return a PR object', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/repos/some/repo/pulls')
        .reply(200, {
          number: 123,
        })
        .post('/repos/some/repo/issues/123/labels')
        .reply(200, [])
        .get(
          '/repos/some/repo/commits/0d9c7726c3d628b7e28af234595cfd20febdbf8e/statuses'
        )
        .reply(200, [])
        .get('/repos/some/repo/commits/some-branch/status')
        .reply(200, {
          object: { sha: 'some-sha' },
        })
        .post(
          '/repos/some/repo/statuses/0d9c7726c3d628b7e28af234595cfd20febdbf8e'
        )
        .reply(200, [])
        .get(
          '/repos/some/repo/commits/0d9c7726c3d628b7e28af234595cfd20febdbf8e/statuses'
        )
        .reply(200, []);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = await github.createPr({
        branchName: 'some-branch',
        prTitle: 'The Title',
        prBody: 'Hello world',
        labels: ['deps', 'renovate'],
        useDefaultBranch: false,
        platformOptions: { statusCheckVerify: true },
      });
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should use defaultBranch', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.post('/repos/some/repo/pulls').reply(200, {
        number: 123,
      });
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = await github.createPr({
        branchName: 'some-branch',
        prTitle: 'The Title',
        prBody: 'Hello world',
        labels: null,
        useDefaultBranch: true,
      });
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should create a draftPR if set in the settings', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.post('/repos/some/repo/pulls').reply(200, {
        number: 123,
      });
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = await github.createPr({
        branchName: 'some-branch',
        prTitle: 'PR draft',
        prBody: 'This is a result of a draft',
        labels: null,
        useDefaultBranch: true,
        draftPR: true,
      });
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('getPr(prNo)', () => {
    it('should return null if no prNo is passed', async () => {
      const pr = await github.getPr(0);
      expect(pr).toBeNull();
    });
    it('should return PR from graphql result', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, graphqlOpenPullRequests)
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234123412341234123412341234123412341234',
          },
        });
      global.gitAuthor = {
        name: 'Renovate Bot',
        email: 'bot@renovateapp.com',
      };
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const pr = await github.getPr(2500);
      expect(pr).toBeDefined();
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return PR from closed graphql result', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .reply(200, graphqlOpenPullRequests)
        .post('/graphql')
        .reply(200, graphqlClosedPullRequests)
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234123412341234123412341234123412341234',
          },
        });
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const pr = await github.getPr(2499);
      expect(pr).toBeDefined();
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return null if no PR is returned from GitHub', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/pulls/1234')
        .reply(200)
        .post('/graphql')
        .twice()
        .reply(404);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = await github.getPr(1234);
      expect(pr).toBeNull();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it(`should return a PR object - 0`, async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'closed',
          base: { sha: '1234' },
          mergeable: true,
          merged_at: 'sometime',
        })
        .post('/graphql')
        .twice()
        .reply(404);
      await github.initRepo({
        repository: 'some/repo',
        token: 'token',
      } as any);
      const pr = await github.getPr(1234);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it(`should return a PR object - 1`, async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'open',
          mergeable_state: 'dirty',
          base: { sha: '1234' },
          commits: 1,
        })
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234',
          },
        })
        .post('/graphql')
        .twice()
        .reply(404);
      await github.initRepo({
        repository: 'some/repo',
        token: 'token',
      } as any);
      const pr = await github.getPr(1234);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it(`should return a PR object - 2`, async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'open',
          base: { sha: '5678' },
          commits: 1,
          mergeable: true,
        })
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234',
          },
        })
        .post('/graphql')
        .twice()
        .reply(404);
      await github.initRepo({
        repository: 'some/repo',
        token: 'token',
      } as any);
      const pr = await github.getPr(1234);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return a rebaseable PR despite multiple commits', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'open',
          mergeable_state: 'dirty',
          base: { sha: '1234' },
          commits: 2,
        })
        .get('/repos/some/repo/pulls/1234/commits')
        .reply(200, [
          {
            author: {
              login: 'foo',
            },
          },
        ])
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234',
          },
        })
        .post('/graphql')
        .twice()
        .reply(404);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = await github.getPr(1234);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return an unrebaseable PR if multiple authors', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .twice()
        .reply(404)
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'open',
          mergeable_state: 'dirty',
          base: { sha: '1234' },
          commits: 2,
        })
        .get('/repos/some/repo/pulls/1234/commits')
        .reply(200, [
          {
            commit: {
              author: {
                email: 'bar',
              },
            },
          },
          {
            committer: {
              login: 'web-flow',
            },
          },
          {},
        ])
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234',
          },
        });
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = await github.getPr(1234);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return a rebaseable PR if web-flow is second author', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .twice()
        .reply(404)
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'open',
          mergeable_state: 'dirty',
          base: { sha: '1234' },
          commits: 2,
        })
        .get('/repos/some/repo/pulls/1234/commits')
        .reply(200, [
          {
            author: {
              login: 'foo',
            },
          },
          {
            committer: {
              login: 'web-flow',
            },
            commit: {
              message: "Merge branch 'master' into renovate/foo",
            },
            parents: [1, 2],
          },
        ])
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234',
          },
        });
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = await github.getPr(1234);
      expect(pr.isModified).toBe(false);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return a rebaseable PR if gitAuthor matches 1 commit', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .twice()
        .reply(404)
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'open',
          mergeable_state: 'dirty',
          base: { sha: '1234' },
          commits: 1,
        })
        .get('/repos/some/repo/pulls/1234/commits')
        .reply(200, [
          {
            commit: {
              author: {
                email: 'bot@renovateapp.com',
              },
            },
          },
        ])
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234',
          },
        });
      global.gitAuthor = {
        name: 'Renovate Bot',
        email: 'bot@renovateapp.com',
      };
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const pr = await github.getPr(1234);
      expect(pr.isModified).toBe(false);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should return a not rebaseable PR if gitAuthor does not match 1 commit', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .post('/graphql')
        .twice()
        .reply(404)
        .get('/repos/some/repo/pulls/1234')
        .reply(200, {
          number: 1,
          state: 'open',
          mergeable_state: 'dirty',
          base: { sha: '1234' },
          commits: 1,
        })
        .get('/repos/some/repo/pulls/1234/commits')
        .reply(200, [
          {
            commit: {
              author: {
                email: 'foo@bar.com',
              },
            },
          },
        ])
        .get('/repos/some/repo/git/refs/heads/master')
        .reply(200, {
          object: {
            sha: '1234',
          },
        });
      global.gitAuthor = {
        name: 'Renovate Bot',
        email: 'bot@renovateapp.com',
      };
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const pr = await github.getPr(1234);
      expect(pr.isModified).toBe(true);
      expect(pr).toMatchSnapshot();
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('updatePr(prNo, title, body)', () => {
    it('should update the PR', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.patch('/repos/some/repo/pulls/1234').reply(200);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      await github.updatePr(1234, 'The New Title', 'Hello world again');
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('mergePr(prNo)', () => {
    it('should merge the PR', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.put('/repos/some/repo/pulls/1234/merge').reply(200);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = {
        number: 1234,
        head: {
          ref: 'someref',
        },
      };
      expect(await github.mergePr(pr.number, '')).toBe(true);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should handle merge error', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .put('/repos/some/repo/pulls/1234/merge')
        .replyWithError('merge error');
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = {
        number: 1234,
        head: {
          ref: 'someref',
        },
      };
      expect(await github.mergePr(pr.number, '')).toBe(false);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('getPrBody(input)', () => {
    it('returns updated pr body', () => {
      const input =
        'https://github.com/foo/bar/issues/5 plus also [a link](https://github.com/foo/bar/issues/5)';
      expect(github.getPrBody(input)).toMatchSnapshot();
    });
    it('returns not-updated pr body for GHE', async () => {
      const scope = httpMock
        .scope('https://github.company.com')
        .get('/user')
        .reply(200, {
          login: 'renovate-bot',
        })
        .get('/user/emails')
        .reply(200, {});
      initRepoMock(scope, 'some/repo');
      await github.initPlatform({
        endpoint: 'https://github.company.com',
        token: 'abc123',
      });
      hostRules.find.mockReturnValue({
        token: 'abc123',
      });
      await github.initRepo({
        repository: 'some/repo',
      } as any);
      const input =
        'https://github.com/foo/bar/issues/5 plus also [a link](https://github.com/foo/bar/issues/5)';
      expect(github.getPrBody(input)).toEqual(input);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('mergePr(prNo) - autodetection', () => {
    it('should try rebase first', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope.put('/repos/some/repo/pulls/1235/merge').reply(200);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = {
        number: 1235,
        head: {
          ref: 'someref',
        },
      };
      expect(await github.mergePr(pr.number, '')).toBe(true);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should try squash after rebase', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .put('/repos/some/repo/pulls/1236/merge')
        .reply(400, 'no rebasing allowed');
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = {
        number: 1236,
        head: {
          ref: 'someref',
        },
      };
      await github.mergePr(pr.number, '');
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should try merge after squash', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .put('/repos/some/repo/pulls/1237/merge')
        .reply(405, 'no rebasing allowed')
        .put('/repos/some/repo/pulls/1237/merge')
        .reply(405, 'no squashing allowed')
        .put('/repos/some/repo/pulls/1237/merge')
        .reply(200);
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = {
        number: 1237,
        head: {
          ref: 'someref',
        },
      };
      expect(await github.mergePr(pr.number, '')).toBe(true);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('should give up', async () => {
      const scope = httpMock.scope(githubApiHost);
      initRepoMock(scope, 'some/repo');
      scope
        .put('/repos/some/repo/pulls/1237/merge')
        .reply(405, 'no rebasing allowed')
        .put('/repos/some/repo/pulls/1237/merge')
        .replyWithError('no squashing allowed')
        .put('/repos/some/repo/pulls/1237/merge')
        .replyWithError('no merging allowed')
        .put('/repos/some/repo/pulls/1237/merge')
        .replyWithError('never gonna give you up');
      await github.initRepo({ repository: 'some/repo', token: 'token' } as any);
      const pr = {
        number: 1237,
        head: {
          ref: 'someref',
        },
      };
      expect(await github.mergePr(pr.number, '')).toBe(false);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
  describe('getVulnerabilityAlerts()', () => {
    it('returns empty if error', async () => {
      httpMock.scope(githubApiHost).post('/graphql').reply(200, {});
      const res = await github.getVulnerabilityAlerts();
      expect(res).toHaveLength(0);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('returns array if found', async () => {
      // prettier-ignore
      httpMock.scope(githubApiHost).post('/graphql').reply(200, {
        "data": {
          "repository": {
            "vulnerabilityAlerts": {
              "edges": [{
                "node": {
                  "externalIdentifier": "CVE-2018-1000136",
                  "externalReference": "https://nvd.nist.gov/vuln/detail/CVE-2018-1000136",
                  "affectedRange": ">= 1.8, < 1.8.3", "fixedIn": "1.8.3",
                  "id": "MDI4OlJlcG9zaXRvcnlWdWxuZXJhYmlsaXR5QWxlcnQ1MzE3NDk4MQ==", "packageName": "electron"
                }
              }]
            }
          }
        }
      });
      const res = await github.getVulnerabilityAlerts();
      expect(res).toHaveLength(1);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('returns empty if disabled', async () => {
      // prettier-ignore
      httpMock.scope(githubApiHost).post('/graphql').reply(200, {data: { repository: {} }} );
      const res = await github.getVulnerabilityAlerts();
      expect(res).toHaveLength(0);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
    it('handles network error', async () => {
      // prettier-ignore
      httpMock.scope(githubApiHost).post('/graphql').replyWithError('unknown error');
      const res = await github.getVulnerabilityAlerts();
      expect(res).toHaveLength(0);
      expect(httpMock.getTrace()).toMatchSnapshot();
    });
  });
});