decap-server 1.4.0-beta.0

package/src/middlewares/joi/index.spec.ts

@@ -0,0 +1,617 @@
+import { defaultSchema, joi } from '.';
+
+import type express from 'express';
+import type Joi from '@hapi/joi';
+
+function assetFailure(result: Joi.ValidationResult, expectedMessage: string) {
+  const { error } = result;
+  expect(error).not.toBeNull();
+  expect(error!.details).toHaveLength(1);
+  const message = error!.details.map(({ message }) => message)[0];
+  expect(message).toBe(expectedMessage);
+}
+
+const defaultParams = {
+  branch: 'master',
+};
+
+describe('defaultSchema', () => {
+  it('should fail on unsupported body', () => {
+    const schema = defaultSchema();
+
+    assetFailure(schema.validate({}), '"action" is required');
+  });
+
+  it('should fail on unsupported action', () => {
+    const schema = defaultSchema();
+
+    assetFailure(
+      schema.validate({ action: 'unknown', params: {} }),
+      '"action" must be one of [info, entriesByFolder, entriesByFiles, getEntry, unpublishedEntries, unpublishedEntry, unpublishedEntryDataFile, unpublishedEntryMediaFile, deleteUnpublishedEntry, persistEntry, updateUnpublishedEntryStatus, publishUnpublishedEntry, getMedia, getMediaFile, persistMedia, deleteFile, deleteFiles, getDeployPreview]',
+    );
+  });
+
+  describe('info', () => {
+    it('should pass with no params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'info',
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('entriesByFolder', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'entriesByFolder', params: { ...defaultParams } }),
+        '"params.folder" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'entriesByFolder',
+          params: { ...defaultParams, folder: 'folder' },
+        }),
+        '"params.extension" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'entriesByFolder',
+          params: { ...defaultParams, folder: 'folder', extension: 'md' },
+        }),
+        '"params.depth" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'entriesByFolder',
+        params: { ...defaultParams, folder: 'folder', extension: 'md', depth: 1 },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('entriesByFiles', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'entriesByFiles', params: { ...defaultParams } }),
+        '"params.files" is required',
+      );
+      assetFailure(
+        schema.validate({ action: 'entriesByFiles', params: { ...defaultParams, files: {} } }),
+        '"params.files" must be an array',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'entriesByFiles',
+          params: { ...defaultParams, files: [{ id: 'id' }] },
+        }),
+        '"params.files[0].path" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'entriesByFiles',
+        params: { ...defaultParams, files: [{ path: 'path' }] },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('getEntry', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'getEntry', params: { ...defaultParams } }),
+        '"params.path" is required',
+      );
+      assetFailure(
+        schema.validate({ action: 'getEntry', params: { ...defaultParams, path: 1 } }),
+        '"params.path" must be a string',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'getEntry',
+        params: { ...defaultParams, path: 'path' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('unpublishedEntries', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'unpublishedEntries', params: {} }),
+        '"params.branch" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'unpublishedEntries',
+        params: { ...defaultParams, branch: 'master' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('unpublishedEntry', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+      assetFailure(
+        schema.validate({ action: 'unpublishedEntry', params: {} }),
+        '"params.branch" is required',
+      );
+    });
+
+    it('should pass on valid collection and slug', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'unpublishedEntry',
+        params: { ...defaultParams, collection: 'collection', slug: 'slug' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+
+    it('should pass on valid id', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'unpublishedEntry',
+        params: { ...defaultParams, id: 'id' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  ['unpublishedEntryDataFile', 'unpublishedEntryMediaFile'].forEach(action => {
+    describe(action, () => {
+      it('should fail on invalid params', () => {
+        const schema = defaultSchema();
+
+        assetFailure(
+          schema.validate({ action, params: { ...defaultParams } }),
+          '"params.collection" is required',
+        );
+        assetFailure(
+          schema.validate({
+            action,
+            params: { ...defaultParams, collection: 'collection' },
+          }),
+          '"params.slug" is required',
+        );
+        assetFailure(
+          schema.validate({
+            action,
+            params: { ...defaultParams, collection: 'collection', slug: 'slug' },
+          }),
+          '"params.id" is required',
+        );
+        assetFailure(
+          schema.validate({
+            action,
+            params: { ...defaultParams, collection: 'collection', slug: 'slug', id: 'id' },
+          }),
+          '"params.path" is required',
+        );
+      });
+
+      it('should pass on valid params', () => {
+        const schema = defaultSchema();
+        const { error } = schema.validate({
+          action,
+          params: {
+            ...defaultParams,
+            collection: 'collection',
+            slug: 'slug',
+            id: 'id',
+            path: 'path',
+          },
+        });
+
+        expect(error).toBeUndefined();
+      });
+    });
+  });
+
+  describe('deleteUnpublishedEntry', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'deleteUnpublishedEntry', params: { ...defaultParams } }),
+        '"params.collection" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'deleteUnpublishedEntry',
+          params: { ...defaultParams, collection: 'collection' },
+        }),
+        '"params.slug" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'deleteUnpublishedEntry',
+          params: { ...defaultParams, collection: 'collection', slug: 1 },
+        }),
+        '"params.slug" must be a string',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'deleteUnpublishedEntry',
+        params: { ...defaultParams, collection: 'collection', slug: 'slug' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('persistEntry', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({
+          action: 'persistEntry',
+          params: {
+            ...defaultParams,
+            assets: [],
+            options: {
+              commitMessage: 'commitMessage',
+              useWorkflow: true,
+              status: 'draft',
+            },
+          },
+        }),
+        '"params" must contain at least one of [entry, dataFiles]',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'persistEntry',
+          params: { ...defaultParams, entry: { slug: 'slug', path: 'path', raw: 'content' } },
+        }),
+        '"params.assets" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'persistEntry',
+          params: {
+            ...defaultParams,
+            entry: { slug: 'slug', path: 'path', raw: 'content' },
+            assets: [],
+          },
+        }),
+        '"params.options" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'persistEntry',
+          params: {
+            ...defaultParams,
+            entry: { slug: 'slug', path: 'path', raw: 'content' },
+            assets: [],
+            options: {},
+          },
+        }),
+        '"params.options.commitMessage" is required',
+      );
+    });
+
+    it('should pass on valid params (entry argument)', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'persistEntry',
+        params: {
+          ...defaultParams,
+          entry: { slug: 'slug', path: 'path', raw: 'content' },
+          assets: [{ path: 'path', content: 'content', encoding: 'base64' }],
+          options: {
+            commitMessage: 'commitMessage',
+            useWorkflow: true,
+            status: 'draft',
+          },
+        },
+      });
+
+      expect(error).toBeUndefined();
+    });
+
+    it('should pass on valid params (dataFiles argument)', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'persistEntry',
+        params: {
+          ...defaultParams,
+          dataFiles: [{ slug: 'slug', path: 'path', raw: 'content' }],
+          assets: [{ path: 'path', content: 'content', encoding: 'base64' }],
+          options: {
+            commitMessage: 'commitMessage',
+            useWorkflow: true,
+            status: 'draft',
+          },
+        },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('updateUnpublishedEntryStatus', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'updateUnpublishedEntryStatus', params: { ...defaultParams } }),
+        '"params.collection" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'updateUnpublishedEntryStatus',
+          params: { ...defaultParams, collection: 'collection' },
+        }),
+        '"params.slug" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'updateUnpublishedEntryStatus',
+          params: { ...defaultParams, collection: 'collection', slug: 'slug' },
+        }),
+        '"params.newStatus" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'updateUnpublishedEntryStatus',
+        params: { ...defaultParams, collection: 'collection', slug: 'slug', newStatus: 'draft' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('publishUnpublishedEntry', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'publishUnpublishedEntry', params: { ...defaultParams } }),
+        '"params.collection" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'publishUnpublishedEntry',
+          params: { ...defaultParams, collection: 'collection' },
+        }),
+        '"params.slug" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'publishUnpublishedEntry',
+        params: { ...defaultParams, collection: 'collection', slug: 'slug' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('getMedia', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'getMedia', params: { ...defaultParams } }),
+        '"params.mediaFolder" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'getMedia',
+        params: { ...defaultParams, mediaFolder: 'src/static/images' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('getMediaFile', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'getMediaFile', params: { ...defaultParams } }),
+        '"params.path" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'getMediaFile',
+        params: { ...defaultParams, path: 'src/static/images/image.png' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('persistMedia', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'persistMedia', params: { ...defaultParams } }),
+        '"params.asset" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'persistMedia',
+          params: { ...defaultParams, asset: { path: 'path' } },
+        }),
+        '"params.asset.content" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'persistMedia',
+        params: {
+          ...defaultParams,
+          asset: { path: 'path', content: 'content', encoding: 'base64' },
+          options: { commitMessage: 'commitMessage' },
+        },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'deleteFile', params: { ...defaultParams } }),
+        '"params.path" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'deleteFile',
+        params: {
+          ...defaultParams,
+          path: 'src/static/images/image.png',
+          options: { commitMessage: 'commitMessage' },
+        },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('deleteFiles', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'deleteFiles', params: { ...defaultParams } }),
+        '"params.paths" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'deleteFiles',
+        params: {
+          ...defaultParams,
+          paths: ['src/static/images/image.png'],
+          options: { commitMessage: 'commitMessage' },
+        },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+
+  describe('getDeployPreview', () => {
+    it('should fail on invalid params', () => {
+      const schema = defaultSchema();
+
+      assetFailure(
+        schema.validate({ action: 'getDeployPreview', params: { ...defaultParams } }),
+        '"params.collection" is required',
+      );
+      assetFailure(
+        schema.validate({
+          action: 'getDeployPreview',
+          params: { ...defaultParams, collection: 'collection' },
+        }),
+        '"params.slug" is required',
+      );
+    });
+
+    it('should pass on valid params', () => {
+      const schema = defaultSchema();
+      const { error } = schema.validate({
+        action: 'getDeployPreview',
+        params: { ...defaultParams, collection: 'collection', slug: 'slug' },
+      });
+
+      expect(error).toBeUndefined();
+    });
+  });
+});
+
+describe('joi', () => {
+  it('should call next on valid schema', () => {
+    const next = jest.fn();
+
+    const req = {
+      body: {
+        action: 'entriesByFolder',
+        params: { branch: 'master', folder: 'folder', extension: 'md', depth: 1 },
+      },
+    } as express.Request;
+    const res: express.Response = {} as express.Response;
+    joi(defaultSchema())(req, res, next);
+
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it('should send error on invalid schema', () => {
+    const next = jest.fn();
+
+    const req = {
+      body: {
+        action: 'entriesByFolder',
+      },
+    } as express.Request;
+    const json = jest.fn();
+    const status = jest.fn(() => ({ json }));
+    const res: express.Response = { status } as unknown as express.Response;
+
+    joi(defaultSchema())(req, res, next);
+
+    expect(next).toHaveBeenCalledTimes(0);
+
+    expect(status).toHaveBeenCalledTimes(1);
+    expect(json).toHaveBeenCalledTimes(1);
+
+    expect(status).toHaveBeenCalledWith(422);
+    expect(json).toHaveBeenCalledWith({ error: '"params" is required' });
+  });
+});