planning

node_modules/decap-cms-backend-github/src/__tests__/API.spec.js

@@ -0,0 +1,833 @@
+import { Base64 } from 'js-base64';
+
+import API from '../API';
+
+global.fetch = jest.fn().mockRejectedValue(new Error('should not call fetch inside tests'));
+
+describe('github API', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  function mockAPI(api, responses) {
+    api.request = jest.fn().mockImplementation((path, options = {}) => {
+      const normalizedPath = path.indexOf('?') !== -1 ? path.slice(0, path.indexOf('?')) : path;
+      const response = responses[normalizedPath];
+      return typeof response === 'function'
+        ? Promise.resolve(response(options))
+        : Promise.reject(new Error(`No response for path '${normalizedPath}'`));
+    });
+  }
+
+  describe('editorialWorkflowGit', () => {
+    it('should create PR with correct base branch name when publishing with editorial workflow', () => {
+      let prBaseBranch = null;
+      let labels = null;
+      const api = new API({
+        branch: 'gh-pages',
+        repo: 'owner/my-repo',
+        initialWorkflowStatus: 'draft',
+      });
+      const responses = {
+        '/repos/owner/my-repo/branches/gh-pages': () => ({ commit: { sha: 'def' } }),
+        '/repos/owner/my-repo/git/trees/def': () => ({ tree: [] }),
+        '/repos/owner/my-repo/git/trees': () => ({}),
+        '/repos/owner/my-repo/git/commits': () => ({}),
+        '/repos/owner/my-repo/git/refs': () => ({}),
+        '/repos/owner/my-repo/pulls': req => {
+          prBaseBranch = JSON.parse(req.body).base;
+          return { head: { sha: 'cbd' }, labels: [], number: 1 };
+        },
+        '/repos/owner/my-repo/issues/1/labels': req => {
+          labels = JSON.parse(req.body).labels;
+          return {};
+        },
+      };
+      mockAPI(api, responses);
+
+      return expect(
+        api.editorialWorkflowGit([], { slug: 'entry', sha: 'abc' }, null, {}).then(() => ({
+          prBaseBranch,
+          labels,
+        })),
+      ).resolves.toEqual({ prBaseBranch: 'gh-pages', labels: ['decap-cms/draft'] });
+    });
+
+    it('should create PR with correct base branch name with custom prefix when publishing with editorial workflow', () => {
+      let prBaseBranch = null;
+      let labels = null;
+      const api = new API({
+        branch: 'gh-pages',
+        repo: 'owner/my-repo',
+        initialWorkflowStatus: 'draft',
+        cmsLabelPrefix: 'other/',
+      });
+      const responses = {
+        '/repos/owner/my-repo/branches/gh-pages': () => ({ commit: { sha: 'def' } }),
+        '/repos/owner/my-repo/git/trees/def': () => ({ tree: [] }),
+        '/repos/owner/my-repo/git/trees': () => ({}),
+        '/repos/owner/my-repo/git/commits': () => ({}),
+        '/repos/owner/my-repo/git/refs': () => ({}),
+        '/repos/owner/my-repo/pulls': req => {
+          prBaseBranch = JSON.parse(req.body).base;
+          return { head: { sha: 'cbd' }, labels: [], number: 1 };
+        },
+        '/repos/owner/my-repo/issues/1/labels': req => {
+          labels = JSON.parse(req.body).labels;
+          return {};
+        },
+      };
+      mockAPI(api, responses);
+
+      return expect(
+        api.editorialWorkflowGit([], { slug: 'entry', sha: 'abc' }, null, {}).then(() => ({
+          prBaseBranch,
+          labels,
+        })),
+      ).resolves.toEqual({ prBaseBranch: 'gh-pages', labels: ['other/draft'] });
+    });
+  });
+
+  describe('updateTree', () => {
+    it('should create tree with nested paths', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      api.createTree = jest.fn().mockImplementation(() => Promise.resolve({ sha: 'newTreeSha' }));
+
+      const files = [
+        { path: '/static/media/new-image.jpeg', sha: null },
+        { path: 'content/posts/new-post.md', sha: 'new-post.md' },
+      ];
+
+      const baseTreeSha = 'baseTreeSha';
+
+      await expect(api.updateTree(baseTreeSha, files)).resolves.toEqual({
+        sha: 'newTreeSha',
+        parentSha: baseTreeSha,
+      });
+
+      expect(api.createTree).toHaveBeenCalledTimes(1);
+      expect(api.createTree).toHaveBeenCalledWith(baseTreeSha, [
+        {
+          path: 'static/media/new-image.jpeg',
+          mode: '100644',
+          type: 'blob',
+          sha: null,
+        },
+        {
+          path: 'content/posts/new-post.md',
+          mode: '100644',
+          type: 'blob',
+          sha: 'new-post.md',
+        },
+      ]);
+    });
+  });
+
+  describe('request', () => {
+    beforeEach(() => {
+      const fetch = jest.fn();
+      global.fetch = fetch;
+    });
+
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('should fetch url with authorization header', async () => {
+      const api = new API({ branch: 'gh-pages', repo: 'my-repo', token: 'token' });
+
+      fetch.mockResolvedValue({
+        text: jest.fn().mockResolvedValue('some response'),
+        ok: true,
+        status: 200,
+        headers: { get: () => '' },
+      });
+      const result = await api.request('/some-path');
+      expect(result).toEqual('some response');
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenCalledWith('https://api.github.com/some-path', {
+        cache: 'no-cache',
+        headers: {
+          Authorization: 'token token',
+          'Content-Type': 'application/json; charset=utf-8',
+        },
+        signal: expect.any(AbortSignal),
+      });
+    });
+
+    it('should throw error on not ok response', async () => {
+      const api = new API({ branch: 'gh-pages', repo: 'my-repo', token: 'token' });
+
+      fetch.mockResolvedValue({
+        text: jest.fn().mockResolvedValue({ message: 'some error' }),
+        ok: false,
+        status: 404,
+        headers: { get: () => '' },
+      });
+
+      await expect(api.request('some-path')).rejects.toThrow(
+        expect.objectContaining({
+          message: 'some error',
+          name: 'API_ERROR',
+          status: 404,
+          api: 'GitHub',
+        }),
+      );
+    });
+
+    it('should allow overriding requestHeaders to return a promise ', async () => {
+      const api = new API({ branch: 'gh-pages', repo: 'my-repo', token: 'token' });
+
+      api.requestHeaders = jest.fn().mockResolvedValue({
+        Authorization: 'promise-token',
+        'Content-Type': 'application/json; charset=utf-8',
+      });
+
+      fetch.mockResolvedValue({
+        text: jest.fn().mockResolvedValue('some response'),
+        ok: true,
+        status: 200,
+        headers: { get: () => '' },
+      });
+      const result = await api.request('/some-path');
+      expect(result).toEqual('some response');
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenCalledWith('https://api.github.com/some-path', {
+        cache: 'no-cache',
+        headers: {
+          Authorization: 'promise-token',
+          'Content-Type': 'application/json; charset=utf-8',
+        },
+        signal: expect.any(AbortSignal),
+      });
+    });
+  });
+
+  describe('persistFiles', () => {
+    it('should update tree, commit and patch branch when useWorkflow is false', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      const responses = {
+        // upload the file
+        '/repos/owner/repo/git/blobs': () => ({ sha: 'new-file-sha' }),
+
+        // get the branch
+        '/repos/owner/repo/branches/master': () => ({ commit: { sha: 'root' } }),
+
+        // create new tree
+        '/repos/owner/repo/git/trees': options => {
+          const data = JSON.parse(options.body);
+          return { sha: data.base_tree };
+        },
+
+        // update the commit with the tree
+        '/repos/owner/repo/git/commits': () => ({ sha: 'commit-sha' }),
+
+        // patch the branch
+        '/repos/owner/repo/git/refs/heads/master': () => ({}),
+      };
+      mockAPI(api, responses);
+
+      const entry = {
+        dataFiles: [
+          {
+            slug: 'entry',
+            sha: 'abc',
+            path: 'content/posts/new-post.md',
+            raw: 'content',
+          },
+        ],
+        assets: [],
+      };
+      await api.persistFiles(entry.dataFiles, entry.assets, { commitMessage: 'commitMessage' });
+
+      expect(api.request).toHaveBeenCalledTimes(5);
+
+      expect(api.request.mock.calls[0]).toEqual([
+        '/repos/owner/repo/git/blobs',
+        {
+          method: 'POST',
+          body: JSON.stringify({
+            content: Base64.encode(entry.dataFiles[0].raw),
+            encoding: 'base64',
+          }),
+        },
+      ]);
+
+      expect(api.request.mock.calls[1]).toEqual(['/repos/owner/repo/branches/master']);
+
+      expect(api.request.mock.calls[2]).toEqual([
+        '/repos/owner/repo/git/trees',
+        {
+          body: JSON.stringify({
+            base_tree: 'root',
+            tree: [
+              {
+                path: 'content/posts/new-post.md',
+                mode: '100644',
+                type: 'blob',
+                sha: 'new-file-sha',
+              },
+            ],
+          }),
+          method: 'POST',
+        },
+      ]);
+
+      expect(api.request.mock.calls[3]).toEqual([
+        '/repos/owner/repo/git/commits',
+        {
+          body: JSON.stringify({
+            message: 'commitMessage',
+            tree: 'root',
+            parents: ['root'],
+          }),
+          method: 'POST',
+        },
+      ]);
+
+      expect(api.request.mock.calls[4]).toEqual([
+        '/repos/owner/repo/git/refs/heads/master',
+        {
+          body: JSON.stringify({
+            sha: 'commit-sha',
+            force: false,
+          }),
+          method: 'PATCH',
+        },
+      ]);
+    });
+
+    it('should call editorialWorkflowGit when useWorkflow is true', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      api.uploadBlob = jest.fn();
+      api.editorialWorkflowGit = jest.fn();
+
+      const entry = {
+        dataFiles: [
+          {
+            slug: 'entry',
+            sha: 'abc',
+            path: 'content/posts/new-post.md',
+            raw: 'content',
+          },
+        ],
+        assets: [
+          {
+            path: '/static/media/image-1.png',
+            sha: 'image-1.png',
+          },
+          {
+            path: '/static/media/image-2.png',
+            sha: 'image-2.png',
+          },
+        ],
+      };
+
+      await api.persistFiles(entry.dataFiles, entry.assets, { useWorkflow: true });
+
+      expect(api.uploadBlob).toHaveBeenCalledTimes(3);
+      expect(api.uploadBlob).toHaveBeenCalledWith(entry.dataFiles[0]);
+      expect(api.uploadBlob).toHaveBeenCalledWith(entry.assets[0]);
+      expect(api.uploadBlob).toHaveBeenCalledWith(entry.assets[1]);
+
+      expect(api.editorialWorkflowGit).toHaveBeenCalledTimes(1);
+
+      expect(api.editorialWorkflowGit).toHaveBeenCalledWith(
+        entry.assets.concat(entry.dataFiles),
+        entry.dataFiles[0].slug,
+        [
+          { path: 'static/media/image-1.png', sha: 'image-1.png' },
+          { path: 'static/media/image-2.png', sha: 'image-2.png' },
+        ],
+        { useWorkflow: true },
+      );
+    });
+  });
+
+  describe('migratePullRequest', () => {
+    it('should migrate to pull request labels when no version', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      const pr = {
+        head: { ref: 'cms/2019-11-11-post-title' },
+        title: 'pr title',
+        number: 1,
+        labels: [],
+      };
+      const metadata = { type: 'PR' };
+      api.retrieveMetadataOld = jest.fn().mockResolvedValue(metadata);
+      const newBranch = 'cms/posts/2019-11-11-post-title';
+      const migrateToVersion1Result = {
+        metadata: { ...metadata, branch: newBranch, version: '1' },
+        pullRequest: { ...pr, number: 2 },
+      };
+      api.migrateToVersion1 = jest.fn().mockResolvedValue(migrateToVersion1Result);
+      api.migrateToPullRequestLabels = jest.fn();
+
+      await api.migratePullRequest(pr);
+
+      expect(api.migrateToVersion1).toHaveBeenCalledTimes(1);
+      expect(api.migrateToVersion1).toHaveBeenCalledWith(pr, metadata);
+
+      expect(api.migrateToPullRequestLabels).toHaveBeenCalledTimes(1);
+      expect(api.migrateToPullRequestLabels).toHaveBeenCalledWith(
+        migrateToVersion1Result.pullRequest,
+        migrateToVersion1Result.metadata,
+      );
+
+      expect(api.retrieveMetadataOld).toHaveBeenCalledTimes(1);
+      expect(api.retrieveMetadataOld).toHaveBeenCalledWith('2019-11-11-post-title');
+    });
+
+    it('should migrate to pull request labels when version is 1', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      api.migrateToVersion1 = jest.fn();
+      const pr = {
+        head: { ref: 'cms/posts/2019-11-11-post-title' },
+        title: 'pr title',
+        number: 1,
+        labels: [],
+      };
+      const metadata = { type: 'PR', version: '1' };
+      api.retrieveMetadataOld = jest.fn().mockResolvedValue(metadata);
+      api.migrateToPullRequestLabels = jest.fn().mockResolvedValue(pr, metadata);
+
+      await api.migratePullRequest(pr);
+
+      expect(api.migrateToVersion1).toHaveBeenCalledTimes(0);
+
+      expect(api.migrateToPullRequestLabels).toHaveBeenCalledTimes(1);
+      expect(api.migrateToPullRequestLabels).toHaveBeenCalledWith(pr, metadata);
+
+      expect(api.retrieveMetadataOld).toHaveBeenCalledTimes(1);
+      expect(api.retrieveMetadataOld).toHaveBeenCalledWith('posts/2019-11-11-post-title');
+    });
+  });
+
+  describe('migrateToVersion1', () => {
+    it('should migrate to version 1', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      const pr = {
+        head: { ref: 'cms/2019-11-11-post-title', sha: 'pr_head' },
+        title: 'pr title',
+        number: 1,
+        labels: [],
+      };
+
+      const newBranch = { ref: 'refs/heads/cms/posts/2019-11-11-post-title' };
+      api.createBranch = jest.fn().mockResolvedValue(newBranch);
+      api.getBranch = jest.fn().mockRejectedValue(new Error('Branch not found'));
+
+      const newPr = { ...pr, number: 2 };
+      api.createPR = jest.fn().mockResolvedValue(newPr);
+      api.getPullRequests = jest.fn().mockResolvedValue([]);
+
+      api.storeMetadata = jest.fn();
+      api.closePR = jest.fn();
+      api.deleteBranch = jest.fn();
+      api.deleteMetadata = jest.fn();
+
+      const branch = 'cms/2019-11-11-post-title';
+      const metadata = {
+        branch,
+        type: 'PR',
+        pr: { head: pr.head.sha },
+        commitMessage: 'commitMessage',
+        collection: 'posts',
+      };
+
+      const expectedMetadata = {
+        type: 'PR',
+        pr: { head: newPr.head.sha, number: 2 },
+        commitMessage: 'commitMessage',
+        collection: 'posts',
+        branch: 'cms/posts/2019-11-11-post-title',
+        version: '1',
+      };
+      await expect(api.migrateToVersion1(pr, metadata)).resolves.toEqual({
+        metadata: expectedMetadata,
+        pullRequest: newPr,
+      });
+
+      expect(api.getBranch).toHaveBeenCalledTimes(1);
+      expect(api.getBranch).toHaveBeenCalledWith('cms/posts/2019-11-11-post-title');
+      expect(api.createBranch).toHaveBeenCalledTimes(1);
+      expect(api.createBranch).toHaveBeenCalledWith('cms/posts/2019-11-11-post-title', 'pr_head');
+
+      expect(api.getPullRequests).toHaveBeenCalledTimes(1);
+      expect(api.getPullRequests).toHaveBeenCalledWith(
+        'cms/posts/2019-11-11-post-title',
+        'all',
+        expect.any(Function),
+      );
+      expect(api.createPR).toHaveBeenCalledTimes(1);
+      expect(api.createPR).toHaveBeenCalledWith('pr title', 'cms/posts/2019-11-11-post-title');
+
+      expect(api.storeMetadata).toHaveBeenCalledTimes(1);
+      expect(api.storeMetadata).toHaveBeenCalledWith(
+        'posts/2019-11-11-post-title',
+        expectedMetadata,
+      );
+
+      expect(api.closePR).toHaveBeenCalledTimes(1);
+      expect(api.closePR).toHaveBeenCalledWith(pr.number);
+
+      expect(api.deleteBranch).toHaveBeenCalledTimes(1);
+      expect(api.deleteBranch).toHaveBeenCalledWith('cms/2019-11-11-post-title');
+
+      expect(api.deleteMetadata).toHaveBeenCalledTimes(1);
+      expect(api.deleteMetadata).toHaveBeenCalledWith('2019-11-11-post-title');
+    });
+
+    it('should not create new branch if exists', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      const pr = {
+        head: { ref: 'cms/2019-11-11-post-title', sha: 'pr_head' },
+        title: 'pr title',
+        number: 1,
+        labels: [],
+      };
+
+      const newBranch = { ref: 'refs/heads/cms/posts/2019-11-11-post-title' };
+      api.createBranch = jest.fn();
+      api.getBranch = jest.fn().mockResolvedValue(newBranch);
+
+      const newPr = { ...pr, number: 2 };
+      api.createPR = jest.fn().mockResolvedValue(newPr);
+      api.getPullRequests = jest.fn().mockResolvedValue([]);
+
+      api.storeMetadata = jest.fn();
+      api.closePR = jest.fn();
+      api.deleteBranch = jest.fn();
+      api.deleteMetadata = jest.fn();
+
+      const branch = 'cms/2019-11-11-post-title';
+      const metadata = {
+        branch,
+        type: 'PR',
+        pr: { head: pr.head.sha },
+        commitMessage: 'commitMessage',
+        collection: 'posts',
+      };
+
+      const expectedMetadata = {
+        type: 'PR',
+        pr: { head: newPr.head.sha, number: 2 },
+        commitMessage: 'commitMessage',
+        collection: 'posts',
+        branch: 'cms/posts/2019-11-11-post-title',
+        version: '1',
+      };
+      await expect(api.migrateToVersion1(pr, metadata)).resolves.toEqual({
+        metadata: expectedMetadata,
+        pullRequest: newPr,
+      });
+
+      expect(api.getBranch).toHaveBeenCalledTimes(1);
+      expect(api.getBranch).toHaveBeenCalledWith('cms/posts/2019-11-11-post-title');
+      expect(api.createBranch).toHaveBeenCalledTimes(0);
+
+      expect(api.getPullRequests).toHaveBeenCalledTimes(1);
+      expect(api.getPullRequests).toHaveBeenCalledWith(
+        'cms/posts/2019-11-11-post-title',
+        'all',
+        expect.any(Function),
+      );
+      expect(api.createPR).toHaveBeenCalledTimes(1);
+      expect(api.createPR).toHaveBeenCalledWith('pr title', 'cms/posts/2019-11-11-post-title');
+
+      expect(api.storeMetadata).toHaveBeenCalledTimes(1);
+      expect(api.storeMetadata).toHaveBeenCalledWith(
+        'posts/2019-11-11-post-title',
+        expectedMetadata,
+      );
+
+      expect(api.closePR).toHaveBeenCalledTimes(1);
+      expect(api.closePR).toHaveBeenCalledWith(pr.number);
+
+      expect(api.deleteBranch).toHaveBeenCalledTimes(1);
+      expect(api.deleteBranch).toHaveBeenCalledWith('cms/2019-11-11-post-title');
+
+      expect(api.deleteMetadata).toHaveBeenCalledTimes(1);
+      expect(api.deleteMetadata).toHaveBeenCalledWith('2019-11-11-post-title');
+    });
+
+    it('should not create new pr if exists', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      const pr = {
+        head: { ref: 'cms/2019-11-11-post-title', sha: 'pr_head' },
+        title: 'pr title',
+        number: 1,
+        labels: [],
+      };
+
+      const newBranch = { ref: 'refs/heads/cms/posts/2019-11-11-post-title' };
+      api.createBranch = jest.fn();
+      api.getBranch = jest.fn().mockResolvedValue(newBranch);
+
+      const newPr = { ...pr, number: 2 };
+      api.createPR = jest.fn();
+      api.getPullRequests = jest.fn().mockResolvedValue([newPr]);
+
+      api.storeMetadata = jest.fn();
+      api.closePR = jest.fn();
+      api.deleteBranch = jest.fn();
+      api.deleteMetadata = jest.fn();
+
+      const branch = 'cms/2019-11-11-post-title';
+      const metadata = {
+        branch,
+        type: 'PR',
+        pr: { head: pr.head.sha },
+        commitMessage: 'commitMessage',
+        collection: 'posts',
+      };
+
+      const expectedMetadata = {
+        type: 'PR',
+        pr: { head: newPr.head.sha, number: 2 },
+        commitMessage: 'commitMessage',
+        collection: 'posts',
+        branch: 'cms/posts/2019-11-11-post-title',
+        version: '1',
+      };
+      await expect(api.migrateToVersion1(pr, metadata)).resolves.toEqual({
+        metadata: expectedMetadata,
+        pullRequest: newPr,
+      });
+
+      expect(api.getBranch).toHaveBeenCalledTimes(1);
+      expect(api.getBranch).toHaveBeenCalledWith('cms/posts/2019-11-11-post-title');
+      expect(api.createBranch).toHaveBeenCalledTimes(0);
+
+      expect(api.getPullRequests).toHaveBeenCalledTimes(1);
+      expect(api.getPullRequests).toHaveBeenCalledWith(
+        'cms/posts/2019-11-11-post-title',
+        'all',
+        expect.any(Function),
+      );
+      expect(api.createPR).toHaveBeenCalledTimes(0);
+
+      expect(api.storeMetadata).toHaveBeenCalledTimes(1);
+      expect(api.storeMetadata).toHaveBeenCalledWith(
+        'posts/2019-11-11-post-title',
+        expectedMetadata,
+      );
+
+      expect(api.closePR).toHaveBeenCalledTimes(1);
+      expect(api.closePR).toHaveBeenCalledWith(pr.number);
+
+      expect(api.deleteBranch).toHaveBeenCalledTimes(1);
+      expect(api.deleteBranch).toHaveBeenCalledWith('cms/2019-11-11-post-title');
+
+      expect(api.deleteMetadata).toHaveBeenCalledTimes(1);
+      expect(api.deleteMetadata).toHaveBeenCalledWith('2019-11-11-post-title');
+    });
+  });
+
+  describe('migrateToPullRequestLabels', () => {
+    it('should migrate to pull request labels', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      const pr = {
+        head: { ref: 'cms/posts/2019-11-11-post-title', sha: 'pr_head' },
+        title: 'pr title',
+        number: 1,
+        labels: [],
+      };
+
+      api.setPullRequestStatus = jest.fn();
+      api.deleteMetadata = jest.fn();
+
+      const metadata = {
+        branch: pr.head.ref,
+        type: 'PR',
+        pr: { head: pr.head.sha },
+        commitMessage: 'commitMessage',
+        collection: 'posts',
+        status: 'pending_review',
+      };
+
+      await api.migrateToPullRequestLabels(pr, metadata);
+
+      expect(api.setPullRequestStatus).toHaveBeenCalledTimes(1);
+      expect(api.setPullRequestStatus).toHaveBeenCalledWith(pr, 'pending_review');
+
+      expect(api.deleteMetadata).toHaveBeenCalledTimes(1);
+      expect(api.deleteMetadata).toHaveBeenCalledWith('posts/2019-11-11-post-title');
+    });
+  });
+
+  describe('rebaseSingleCommit', () => {
+    it('should create updated tree and commit', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      api.getDifferences = jest.fn().mockResolvedValueOnce({
+        files: [
+          { filename: 'removed.md', status: 'removed', sha: 'removed_sha' },
+          {
+            filename: 'renamed.md',
+            status: 'renamed',
+            previous_filename: 'previous_filename.md',
+            sha: 'renamed_sha',
+          },
+          { filename: 'added.md', status: 'added', sha: 'added_sha' },
+        ],
+      });
+
+      const newTree = { sha: 'new_tree_sha' };
+      api.updateTree = jest.fn().mockResolvedValueOnce(newTree);
+
+      const newCommit = { sha: 'newCommit' };
+      api.createCommit = jest.fn().mockResolvedValueOnce(newCommit);
+
+      const baseCommit = { sha: 'base_commit_sha' };
+      const commit = {
+        sha: 'sha',
+        parents: [{ sha: 'parent_sha' }],
+        commit: {
+          message: 'message',
+          author: { name: 'author' },
+          committer: { name: 'committer' },
+        },
+      };
+
+      await expect(api.rebaseSingleCommit(baseCommit, commit)).resolves.toBe(newCommit);
+
+      expect(api.getDifferences).toHaveBeenCalledTimes(1);
+      expect(api.getDifferences).toHaveBeenCalledWith('parent_sha', 'sha');
+
+      expect(api.updateTree).toHaveBeenCalledTimes(1);
+      expect(api.updateTree).toHaveBeenCalledWith('base_commit_sha', [
+        { path: 'removed.md', sha: null },
+        { path: 'previous_filename.md', sha: null },
+        { path: 'renamed.md', sha: 'renamed_sha' },
+        { path: 'added.md', sha: 'added_sha' },
+      ]);
+
+      expect(api.createCommit).toHaveBeenCalledTimes(1);
+      expect(api.createCommit).toHaveBeenCalledWith(
+        'message',
+        newTree.sha,
+        [baseCommit.sha],
+        { name: 'author' },
+        { name: 'committer' },
+      );
+    });
+  });
+
+  describe('listFiles', () => {
+    it('should get files by depth', async () => {
+      const api = new API({ branch: 'master', repo: 'owner/repo' });
+
+      const tree = [
+        {
+          path: 'post.md',
+          type: 'blob',
+        },
+        {
+          path: 'dir1',
+          type: 'tree',
+        },
+        {
+          path: 'dir1/nested-post.md',
+          type: 'blob',
+        },
+        {
+          path: 'dir1/dir2',
+          type: 'tree',
+        },
+        {
+          path: 'dir1/dir2/nested-post.md',
+          type: 'blob',
+        },
+      ];
+      api.request = jest.fn().mockResolvedValue({ tree });
+
+      await expect(api.listFiles('posts', { depth: 1 })).resolves.toEqual([
+        {
+          path: 'posts/post.md',
+          type: 'blob',
+          name: 'post.md',
+        },
+      ]);
+      expect(api.request).toHaveBeenCalledTimes(1);
+      expect(api.request).toHaveBeenCalledWith('/repos/owner/repo/git/trees/master:posts', {
+        params: {},
+      });
+
+      jest.clearAllMocks();
+      await expect(api.listFiles('posts', { depth: 2 })).resolves.toEqual([
+        {
+          path: 'posts/post.md',
+          type: 'blob',
+          name: 'post.md',
+        },
+        {
+          path: 'posts/dir1/nested-post.md',
+          type: 'blob',
+          name: 'nested-post.md',
+        },
+      ]);
+      expect(api.request).toHaveBeenCalledTimes(1);
+      expect(api.request).toHaveBeenCalledWith('/repos/owner/repo/git/trees/master:posts', {
+        params: { recursive: 1 },
+      });
+
+      jest.clearAllMocks();
+      await expect(api.listFiles('posts', { depth: 3 })).resolves.toEqual([
+        {
+          path: 'posts/post.md',
+          type: 'blob',
+          name: 'post.md',
+        },
+        {
+          path: 'posts/dir1/nested-post.md',
+          type: 'blob',
+          name: 'nested-post.md',
+        },
+        {
+          path: 'posts/dir1/dir2/nested-post.md',
+          type: 'blob',
+          name: 'nested-post.md',
+        },
+      ]);
+      expect(api.request).toHaveBeenCalledTimes(1);
+      expect(api.request).toHaveBeenCalledWith('/repos/owner/repo/git/trees/master:posts', {
+        params: { recursive: 1 },
+      });
+    });
+  });
+
+  test('should get preview statuses', async () => {
+    const api = new API({ repo: 'repo' });
+
+    const statuses = [
+      { context: 'deploy', state: 'success', target_url: 'deploy-url' },
+      { context: 'build', state: 'error' },
+    ];
+
+    api.request = jest.fn(() => Promise.resolve({ statuses }));
+    const sha = 'sha';
+    api.getBranchPullRequest = jest.fn(() => Promise.resolve({ head: { sha } }));
+
+    const collection = 'collection';
+    const slug = 'slug';
+    await expect(api.getStatuses(collection, slug)).resolves.toEqual([
+      { context: 'deploy', state: 'success', target_url: 'deploy-url' },
+      { context: 'build', state: 'other' },
+    ]);
+
+    expect(api.getBranchPullRequest).toHaveBeenCalledTimes(1);
+    expect(api.getBranchPullRequest).toHaveBeenCalledWith('cms/collection/slug');
+    expect(api.request).toHaveBeenCalledTimes(1);
+    expect(api.request).toHaveBeenCalledWith(`/repos/repo/commits/${sha}/status`);
+  });
+});

node_modules/decap-cms-backend-github/src/__tests__/GraphQLAPI.spec.js

@@ -0,0 +1,69 @@
+import GraphQLAPI from '../GraphQLAPI';
+
+global.fetch = jest.fn().mockRejectedValue(new Error('should not call fetch inside tests'));
+
+describe('github GraphQL API', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('editorialWorkflowGit', () => {
+    it('should should flatten nested tree into a list of files', () => {
+      const api = new GraphQLAPI({ branch: 'gh-pages', repo: 'owner/my-repo' });
+      const entries = [
+        {
+          name: 'post-1.md',
+          sha: 'sha-1',
+          type: 'blob',
+          blob: { size: 1 },
+        },
+        {
+          name: 'post-2.md',
+          sha: 'sha-2',
+          type: 'blob',
+          blob: { size: 2 },
+        },
+        {
+          name: '2019',
+          sha: 'dir-sha',
+          type: 'tree',
+          object: {
+            entries: [
+              {
+                name: 'nested-post.md',
+                sha: 'nested-post-sha',
+                type: 'blob',
+                blob: { size: 3 },
+              },
+            ],
+          },
+        },
+      ];
+      const path = 'posts';
+
+      expect(api.getAllFiles(entries, path)).toEqual([
+        {
+          name: 'post-1.md',
+          id: 'sha-1',
+          type: 'blob',
+          size: 1,
+          path: 'posts/post-1.md',
+        },
+        {
+          name: 'post-2.md',
+          id: 'sha-2',
+          type: 'blob',
+          size: 2,
+          path: 'posts/post-2.md',
+        },
+        {
+          name: 'nested-post.md',
+          id: 'nested-post-sha',
+          type: 'blob',
+          size: 3,
+          path: 'posts/2019/nested-post.md',
+        },
+      ]);
+    });
+  });
+});

node_modules/decap-cms-backend-github/src/__tests__/implementation.spec.js

@@ -0,0 +1,361 @@
+import { Cursor, CURSOR_COMPATIBILITY_SYMBOL } from 'decap-cms-lib-util';
+
+import GitHubImplementation from '../implementation';
+
+jest.spyOn(console, 'error').mockImplementation(() => {});
+
+describe('github backend implementation', () => {
+  const config = {
+    backend: {
+      repo: 'owner/repo',
+      open_authoring: false,
+      api_root: 'https://api.github.com',
+    },
+  };
+
+  const createObjectURL = jest.fn();
+  global.URL = {
+    createObjectURL,
+  };
+
+  createObjectURL.mockReturnValue('displayURL');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('forkExists', () => {
+    it('should return true when repo is fork and parent matches originRepo', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.currentUser = jest.fn().mockResolvedValue({ login: 'login' });
+
+      global.fetch = jest.fn().mockResolvedValue({
+        // matching should be case-insensitive
+        json: () => ({ fork: true, parent: { full_name: 'OWNER/REPO' } }),
+      });
+
+      await expect(gitHubImplementation.forkExists({ token: 'token' })).resolves.toBe(true);
+
+      expect(gitHubImplementation.currentUser).toHaveBeenCalledTimes(1);
+      expect(gitHubImplementation.currentUser).toHaveBeenCalledWith({ token: 'token' });
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+      expect(global.fetch).toHaveBeenCalledWith('https://api.github.com/repos/login/repo', {
+        method: 'GET',
+        headers: {
+          Authorization: 'token token',
+        },
+        signal: expect.any(AbortSignal),
+      });
+    });
+
+    it('should return false when repo is not a fork', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.currentUser = jest.fn().mockResolvedValue({ login: 'login' });
+
+      global.fetch = jest.fn().mockResolvedValue({
+        // matching should be case-insensitive
+        json: () => ({ fork: false }),
+      });
+
+      expect.assertions(1);
+      await expect(gitHubImplementation.forkExists({ token: 'token' })).resolves.toBe(false);
+    });
+
+    it("should return false when parent doesn't match originRepo", async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.currentUser = jest.fn().mockResolvedValue({ login: 'login' });
+
+      global.fetch = jest.fn().mockResolvedValue({
+        json: () => ({ fork: true, parent: { full_name: 'owner/other_repo' } }),
+      });
+
+      expect.assertions(1);
+      await expect(gitHubImplementation.forkExists({ token: 'token' })).resolves.toBe(false);
+    });
+  });
+
+  describe('persistMedia', () => {
+    const persistFiles = jest.fn();
+    const mockAPI = {
+      persistFiles,
+    };
+
+    persistFiles.mockImplementation((_, files) => {
+      files.forEach((file, index) => {
+        file.sha = index;
+      });
+    });
+
+    it('should persist media file', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+
+      const mediaFile = {
+        fileObj: { size: 100, name: 'image.png' },
+        path: '/media/image.png',
+      };
+
+      expect.assertions(5);
+      await expect(gitHubImplementation.persistMedia(mediaFile, {})).resolves.toEqual({
+        id: 0,
+        name: 'image.png',
+        size: 100,
+        displayURL: 'displayURL',
+        path: 'media/image.png',
+      });
+
+      expect(persistFiles).toHaveBeenCalledTimes(1);
+      expect(persistFiles).toHaveBeenCalledWith([], [mediaFile], {});
+      expect(createObjectURL).toHaveBeenCalledTimes(1);
+      expect(createObjectURL).toHaveBeenCalledWith(mediaFile.fileObj);
+    });
+
+    it('should log and throw error on "persistFiles" error', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+
+      const error = new Error('failed to persist files');
+      persistFiles.mockRejectedValue(error);
+
+      const mediaFile = {
+        value: 'image.png',
+        fileObj: { size: 100 },
+        path: '/media/image.png',
+      };
+
+      expect.assertions(5);
+      await expect(gitHubImplementation.persistMedia(mediaFile)).rejects.toThrowError(error);
+
+      expect(persistFiles).toHaveBeenCalledTimes(1);
+      expect(createObjectURL).toHaveBeenCalledTimes(0);
+      expect(console.error).toHaveBeenCalledTimes(1);
+      expect(console.error).toHaveBeenCalledWith(error);
+    });
+  });
+
+  describe('unpublishedEntry', () => {
+    const generateContentKey = jest.fn();
+    const retrieveUnpublishedEntryData = jest.fn();
+
+    const mockAPI = {
+      generateContentKey,
+      retrieveUnpublishedEntryData,
+    };
+
+    it('should return unpublished entry data', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+      gitHubImplementation.loadEntryMediaFiles = jest
+        .fn()
+        .mockResolvedValue([{ path: 'image.png', id: 'sha' }]);
+
+      generateContentKey.mockReturnValue('contentKey');
+
+      const data = {
+        collection: 'collection',
+        slug: 'slug',
+        status: 'draft',
+        diffs: [],
+        updatedAt: 'updatedAt',
+      };
+      retrieveUnpublishedEntryData.mockResolvedValue(data);
+
+      const collection = 'posts';
+      const slug = 'slug';
+      await expect(gitHubImplementation.unpublishedEntry({ collection, slug })).resolves.toEqual(
+        data,
+      );
+
+      expect(generateContentKey).toHaveBeenCalledTimes(1);
+      expect(generateContentKey).toHaveBeenCalledWith('posts', 'slug');
+
+      expect(retrieveUnpublishedEntryData).toHaveBeenCalledTimes(1);
+      expect(retrieveUnpublishedEntryData).toHaveBeenCalledWith('contentKey');
+    });
+  });
+
+  describe('entriesByFolder', () => {
+    const listFiles = jest.fn();
+    const readFile = jest.fn();
+    const readFileMetadata = jest.fn(() => Promise.resolve({ author: '', updatedOn: '' }));
+
+    const mockAPI = {
+      listFiles,
+      readFile,
+      readFileMetadata,
+      originRepoURL: 'originRepoURL',
+    };
+
+    it('should return entries and cursor', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+
+      const files = [];
+      const count = 1501;
+      for (let i = 0; i < count; i++) {
+        const id = `${i}`.padStart(`${count}`.length, '0');
+        files.push({
+          id,
+          path: `posts/post-${id}.md`,
+        });
+      }
+
+      listFiles.mockResolvedValue(files);
+      readFile.mockImplementation((path, id) => Promise.resolve(`${id}`));
+
+      const expectedEntries = files
+        .slice(0, 20)
+        .map(({ id, path }) => ({ data: id, file: { path, id, author: '', updatedOn: '' } }));
+
+      const expectedCursor = Cursor.create({
+        actions: ['next', 'last'],
+        meta: { page: 1, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      expectedEntries[CURSOR_COMPATIBILITY_SYMBOL] = expectedCursor;
+
+      const result = await gitHubImplementation.entriesByFolder('posts', 'md', 1);
+
+      expect(result).toEqual(expectedEntries);
+      expect(listFiles).toHaveBeenCalledTimes(1);
+      expect(listFiles).toHaveBeenCalledWith('posts', { depth: 1, repoURL: 'originRepoURL' });
+      expect(readFile).toHaveBeenCalledTimes(20);
+    });
+  });
+
+  describe('traverseCursor', () => {
+    const listFiles = jest.fn();
+    const readFile = jest.fn((path, id) => Promise.resolve(`${id}`));
+    const readFileMetadata = jest.fn(() => Promise.resolve({}));
+
+    const mockAPI = {
+      listFiles,
+      readFile,
+      originRepoURL: 'originRepoURL',
+      readFileMetadata,
+    };
+
+    const files = [];
+    const count = 1501;
+    for (let i = 0; i < count; i++) {
+      const id = `${i}`.padStart(`${count}`.length, '0');
+      files.push({
+        id,
+        path: `posts/post-${id}.md`,
+      });
+    }
+
+    it('should handle next action', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+
+      const cursor = Cursor.create({
+        actions: ['next', 'last'],
+        meta: { page: 1, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const expectedEntries = files
+        .slice(20, 40)
+        .map(({ id, path }) => ({ data: id, file: { path, id } }));
+
+      const expectedCursor = Cursor.create({
+        actions: ['prev', 'first', 'next', 'last'],
+        meta: { page: 2, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const result = await gitHubImplementation.traverseCursor(cursor, 'next');
+
+      expect(result).toEqual({
+        entries: expectedEntries,
+        cursor: expectedCursor,
+      });
+    });
+
+    it('should handle prev action', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+
+      const cursor = Cursor.create({
+        actions: ['prev', 'first', 'next', 'last'],
+        meta: { page: 2, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const expectedEntries = files
+        .slice(0, 20)
+        .map(({ id, path }) => ({ data: id, file: { path, id } }));
+
+      const expectedCursor = Cursor.create({
+        actions: ['next', 'last'],
+        meta: { page: 1, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const result = await gitHubImplementation.traverseCursor(cursor, 'prev');
+
+      expect(result).toEqual({
+        entries: expectedEntries,
+        cursor: expectedCursor,
+      });
+    });
+
+    it('should handle last action', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+
+      const cursor = Cursor.create({
+        actions: ['next', 'last'],
+        meta: { page: 1, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const expectedEntries = files
+        .slice(1500)
+        .map(({ id, path }) => ({ data: id, file: { path, id } }));
+
+      const expectedCursor = Cursor.create({
+        actions: ['prev', 'first'],
+        meta: { page: 76, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const result = await gitHubImplementation.traverseCursor(cursor, 'last');
+
+      expect(result).toEqual({
+        entries: expectedEntries,
+        cursor: expectedCursor,
+      });
+    });
+
+    it('should handle first action', async () => {
+      const gitHubImplementation = new GitHubImplementation(config);
+      gitHubImplementation.api = mockAPI;
+
+      const cursor = Cursor.create({
+        actions: ['prev', 'first'],
+        meta: { page: 76, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const expectedEntries = files
+        .slice(0, 20)
+        .map(({ id, path }) => ({ data: id, file: { path, id } }));
+
+      const expectedCursor = Cursor.create({
+        actions: ['next', 'last'],
+        meta: { page: 1, count, pageSize: 20, pageCount: 76 },
+        data: { files },
+      });
+
+      const result = await gitHubImplementation.traverseCursor(cursor, 'first');
+
+      expect(result).toEqual({
+        entries: expectedEntries,
+        cursor: expectedCursor,
+      });
+    });
+  });
+});