fix(tests): cover more gitlab hooks, consolidate middleware

src/endpoint/BaseEndpoint.ts

@@ -13,7 +13,11 @@ import { ServiceDefinition } from '../Service';
 import { Transform, TransformData } from '../transform';
 import { doesExist, getMethods, mustExist } from '../utils';
 
+export const STATUS_ERROR = 500;
 export const STATUS_FORBIDDEN = 403;
+export const STATUS_NOTFOUND = 404;
+export const STATUS_SUCCESS = 200;
+export const STATUS_UNKNOWN = 404;
 
 export type BaseEndpointOptions<TData extends EndpointData> = BotServiceOptions<TData>;
 

src/endpoint/GithubEndpoint.ts

@@ -4,8 +4,7 @@ import { Inject } from 'noicejs';
 import { Handler } from '.';
 import { INJECT_STORAGE } from '../BotService';
 import { CommandVerb } from '../entity/Command';
-import { BaseEndpoint, BaseEndpointOptions } from './BaseEndpoint';
-import { STATUS_SUCCESS } from './HealthEndpoint';
+import { BaseEndpoint, BaseEndpointOptions, STATUS_SUCCESS } from './BaseEndpoint';
 import { HookEndpointData } from './HookEndpoint';
 
 export interface GithubEndpointData extends HookEndpointData {

src/endpoint/GitlabEndpoint.ts

@@ -1,15 +1,15 @@
-import { json as expressJSON, Request, RequestHandler, Response } from 'express';
+import { Request, Response } from 'express';
 import { isString } from 'lodash';
 
-import { Endpoint, Handler, HandlerMetadata, RouterOptions } from '.';
+import { Endpoint, Handler } from '.';
 import { Command, CommandOptions, CommandVerb } from '../entity/Command';
 import { ChannelData, Context } from '../entity/Context';
 import { Message } from '../entity/Message';
 import { applyTransforms, scopeToData } from '../transform/helpers';
 import { mustExist } from '../utils';
 import { TYPE_JSON } from '../utils/Mime';
 import { TemplateScope } from '../utils/Template';
-import { BaseEndpointOptions } from './BaseEndpoint';
+import { BaseEndpointOptions, STATUS_NOTFOUND, STATUS_SUCCESS } from './BaseEndpoint';
 import { HookEndpoint, HookEndpointData } from './HookEndpoint';
 
 export interface GitlabBaseWebhook {
@@ -93,10 +93,6 @@ export interface GitlabEndpointData extends HookEndpointData {
   defaultCommand: CommandOptions;
 }
 
-const STATUS_SUCCESS = 200;
-const STATUS_ERROR = 500;
-export const STATUS_UNKNOWN = 404;
-
 export class GitlabEndpoint extends HookEndpoint<GitlabEndpointData> implements Endpoint {
   constructor(options: BaseEndpointOptions<GitlabEndpointData>) {
     super(options, 'isolex#/definitions/service-endpoint-gitlab');
@@ -110,7 +106,7 @@ export class GitlabEndpoint extends HookEndpoint<GitlabEndpointData> implements
   }
 
   @Handler(CommandVerb.Create, '/webhook')
-  public async hookSwitch(req: Request, res: Response) {
+  public async postHook(req: Request, res: Response) {
     this.logger.debug({
       body: req.body,
       req,
@@ -138,7 +134,7 @@ export class GitlabEndpoint extends HookEndpoint<GitlabEndpointData> implements
         this.logger.warn({
           kind: data.object_kind,
         }, 'unknown hook kind');
-        res.sendStatus(STATUS_UNKNOWN);
+        res.sendStatus(STATUS_NOTFOUND);
     }
   }
 
@@ -206,13 +202,6 @@ export class GitlabEndpoint extends HookEndpoint<GitlabEndpointData> implements
     res.sendStatus(STATUS_SUCCESS);
   }
 
-  protected getHandlerMiddleware(metadata: HandlerMetadata, options: RouterOptions): Array<RequestHandler> {
-    return [
-      ...super.getHandlerMiddleware(metadata, options),
-      expressJSON(),
-    ];
-  }
-
   protected getHookChannel(data: GitlabWebhook): ChannelData {
     return {
       id: data.object_kind,

src/endpoint/HealthEndpoint.ts

@@ -2,13 +2,7 @@ import { Request, Response } from 'express';
 
 import { Endpoint, EndpointData, Handler } from '.';
 import { CommandVerb } from '../entity/Command';
-import { BaseEndpoint, BaseEndpointOptions } from './BaseEndpoint';
-
-export const BODY_SUCCESS = 'OK';
-export const BODY_ERROR = 'ERROR';
-
-export const STATUS_SUCCESS = 200;
-export const STATUS_ERROR = 500;
+import { BaseEndpoint, BaseEndpointOptions, STATUS_ERROR, STATUS_SUCCESS } from './BaseEndpoint';
 
 export class HealthEndpoint extends BaseEndpoint<EndpointData> implements Endpoint {
   constructor(options: BaseEndpointOptions<EndpointData>) {

src/endpoint/HookEndpoint.ts

@@ -1,6 +1,7 @@
+import { json, RequestHandler } from 'express';
 import { Inject } from 'noicejs';
 
-import { Endpoint } from '.';
+import { Endpoint, HandlerMetadata, RouterOptions } from '.';
 import { BotServiceData, INJECT_STORAGE } from '../BotService';
 import { User } from '../entity/auth/User';
 import { UserRepository } from '../entity/auth/UserRepository';
@@ -34,6 +35,13 @@ export class HookEndpoint<TData extends HookEndpointData> extends BaseEndpoint<T
     this.hookUser = await repository.loadRoles(user);
   }
 
+  protected getHandlerMiddleware(metadata: HandlerMetadata, options: RouterOptions): Array<RequestHandler> {
+    return [
+      ...super.getHandlerMiddleware(metadata, options),
+      json(),
+    ];
+  }
+
   protected async createHookContext(channel: ChannelData) {
     const user = mustExist(this.hookUser);
     return this.createContext({

test/endpoint/TestGithubEndpoint.ts

@@ -4,8 +4,8 @@ import { ineeda } from 'ineeda';
 import passport from 'passport';
 import { spy, stub } from 'sinon';
 
+import { STATUS_SUCCESS } from '../../src/endpoint/BaseEndpoint';
 import { GithubEndpoint } from '../../src/endpoint/GithubEndpoint';
-import { STATUS_SUCCESS } from '../../src/endpoint/HealthEndpoint';
 import { describeLeaks, itLeaks } from '../helpers/async';
 import { createEndpoint } from '../helpers/request';
 

test/endpoint/TestGitlabEndpoint.ts

@@ -4,7 +4,8 @@ import { ineeda } from 'ineeda';
 import passport from 'passport';
 import { spy, stub } from 'sinon';
 
-import { GitlabEndpoint, GitlabEndpointData, STATUS_UNKNOWN } from '../../src/endpoint/GitlabEndpoint';
+import { STATUS_SUCCESS, STATUS_UNKNOWN } from '../../src/endpoint/BaseEndpoint';
+import { GitlabEndpoint, GitlabEndpointData } from '../../src/endpoint/GitlabEndpoint';
 import { CommandVerb } from '../../src/entity/Command';
 import { describeLeaks, itLeaks } from '../helpers/async';
 import { createEndpoint } from '../helpers/request';
@@ -21,6 +22,23 @@ const TEST_DATA: GitlabEndpointData = {
   strict: false,
 };
 
+const TEST_EVENTS = [{
+  data: {},
+  name: 'issue',
+}, {
+  data: {},
+  name: 'job',
+}, {
+  data: {},
+  name: 'note',
+}, {
+  data: {},
+  name: 'pipeline',
+}, {
+  data: {},
+  name: 'push',
+}];
+
 describeLeaks('gitlab endpoint', async () => {
   itLeaks('should have paths', async () => {
     const endpoint = await createEndpoint(GitlabEndpoint, false, false, TEST_DATA);
@@ -46,12 +64,30 @@ describeLeaks('gitlab endpoint', async () => {
     itLeaks('should fail without a body', async () => {
       const endpoint = await createEndpoint(GitlabEndpoint, false, false, TEST_DATA);
       const sendStatus = spy();
-      await endpoint.hookSwitch(ineeda<Request>({
+      await endpoint.postHook(ineeda<Request>({
         header: stub().returns([]),
       }), ineeda<Response>({
         sendStatus,
       }));
       expect(sendStatus).to.have.been.calledOnce.and.calledWithExactly(STATUS_UNKNOWN);
     });
+
+    for (const eventData of TEST_EVENTS) {
+      itLeaks(`should succeed on ${eventData.name} events`, async () => {
+        const endpoint = await createEndpoint(GitlabEndpoint, false, false, TEST_DATA);
+        await endpoint.start();
+        const sendStatus = spy();
+        await endpoint.postHook(ineeda<Request>({
+          body: {
+            ...eventData.data,
+            object_kind: eventData.name,
+          // tslint:disable-next-line:no-any
+          } as any,
+        }), ineeda<Response>({
+          sendStatus,
+        }));
+        expect(sendStatus).to.have.been.calledOnce.and.calledWithExactly(STATUS_SUCCESS);
+      });
+    }
   });
 });

test/endpoint/TestHealthEndpoint.ts

@@ -4,7 +4,8 @@ import { ineeda } from 'ineeda';
 import passport from 'passport';
 import { spy } from 'sinon';
 
-import { HealthEndpoint, STATUS_ERROR, STATUS_SUCCESS } from '../../src/endpoint/HealthEndpoint';
+import { STATUS_ERROR, STATUS_SUCCESS } from '../../src/endpoint/BaseEndpoint';
+import { HealthEndpoint } from '../../src/endpoint/HealthEndpoint';
 import { describeLeaks, itLeaks } from '../helpers/async';
 import { createEndpoint } from '../helpers/request';
 

test/helpers/request.ts

@@ -8,6 +8,9 @@ import { Bot } from '../../src/Bot';
 import { INJECT_BOT, INJECT_STORAGE } from '../../src/BotService';
 import { EndpointData } from '../../src/endpoint';
 import { BaseEndpoint, BaseEndpointOptions } from '../../src/endpoint/BaseEndpoint';
+import { User } from '../../src/entity/auth/User';
+import { UserRepository } from '../../src/entity/auth/UserRepository';
+import { Context } from '../../src/entity/Context';
 import { BotModule } from '../../src/module/BotModule';
 import { Storage } from '../../src/storage';
 import { createService, createServiceContainer } from '../helpers/container';
@@ -37,18 +40,34 @@ export async function createEndpoint<
       return storageReady;
     },
     set isConnected(val: boolean) { /* noop */ },
+    getCustomRepository() {
+      return ineeda<UserRepository>({
+        async findOneOrFail() {
+          return ineeda<User>();
+        },
+        async loadRoles() {
+          return ineeda<User>();
+        },
+      });
+    },
     getRepository() {
-      return ineeda<Repository<{}>>();
+      return ineeda<Repository<{}>>({
+        async save() {
+          return ineeda<Context>();
+        },
+      });
     },
   });
   const bot = ineeda<Bot>({
     get isConnected() {
       return botReady;
     },
     set isConnected(val: boolean) { /* noop */ },
+    executeCommand: spy(),
     getStorage() {
       return storage;
     },
+    sendMessage: spy(),
   });
 
   const botModule = new BotModule({