[TASK-178 / 25.06.27] Feature - 센트리 슬랙 웹훅 연동

src/controllers/__test__/webhook.controller.test.ts

@@ -0,0 +1,311 @@
+import 'reflect-metadata';
+import { Request, Response } from 'express';
+import { WebhookController } from '@/controllers/webhook.controller';
+import { sendSlackMessage } from '@/modules/slack/slack.notifier';
+
+// Mock dependencies
+jest.mock('@/modules/slack/slack.notifier');
+
+// logger 모킹
+jest.mock('@/configs/logger.config', () => ({
+  error: jest.fn(),
+  info: jest.fn(),
+}));
+
+describe('WebhookController', () => {
+  let webhookController: WebhookController;
+  let mockRequest: Partial<Request>;
+  let mockResponse: Partial<Response>;
+  let nextFunction: jest.Mock;
+  let mockSendSlackMessage: jest.MockedFunction<typeof sendSlackMessage>;
+
+  beforeEach(() => {
+    // WebhookController 인스턴스 생성
+    webhookController = new WebhookController();
+
+    // Request, Response, NextFunction 모킹
+    mockRequest = {
+      body: {},
+      headers: {},
+    };
+
+    mockResponse = {
+      json: jest.fn().mockReturnThis(),
+      status: jest.fn().mockReturnThis(),
+    };
+
+    nextFunction = jest.fn();
+    mockSendSlackMessage = sendSlackMessage as jest.MockedFunction<typeof sendSlackMessage>;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('handleSentryWebhook', () => {
+    // 실제 동작에 필요한 필수 값만 사용하도록 타입 미적용
+    const mockSentryData = {
+      action: 'created',
+      data: {
+        issue: {
+          id: 'test-issue-123',
+          title: '테스트 오류입니다',
+          culprit: 'TestFile.js:10',
+          status: 'unresolved',
+          count: "5",
+          userCount: 3,
+          firstSeen: '2024-01-01T12:00:00.000Z',
+          permalink: 'https://velog-dashboardv2.sentry.io/issues/test-issue-123/',
+          project: {
+            id: 'project-123',
+            name: 'Velog Dashboard',
+            slug: 'velog-dashboard'
+          }
+        }
+      }
+    };
+
+    it('유효한 Sentry 웹훅 데이터로 처리에 성공해야 한다', async () => {
+      mockRequest.body = mockSentryData;
+      mockSendSlackMessage.mockResolvedValue();
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(mockSendSlackMessage).toHaveBeenCalledWith(
+        expect.stringContaining('🚨 *새로운 오류가 발생하였습니다*')
+      );
+      expect(mockSendSlackMessage).toHaveBeenCalledWith(
+        expect.stringContaining('🔴 *제목:* 테스트 오류입니다')
+      );
+      expect(mockSendSlackMessage).toHaveBeenCalledWith(
+        expect.stringContaining('📍 *위치:* TestFile.js:10')
+      );
+      expect(mockSendSlackMessage).toHaveBeenCalledWith(
+        expect.stringContaining('🔗 *상세 보기:* https://velog-dashboardv2.sentry.io/issues/test-issue-123/')
+      );
+      expect(mockResponse.status).toHaveBeenCalledWith(200);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        success: true,
+        message: 'Sentry 웹훅 처리에 성공하였습니다.',
+        data: {},
+        error: null
+      });
+    });
+
+    it('permalink가 없는 경우 기본 URL 패턴을 사용해야 한다', async () => {
+      const dataWithoutPermalink = {
+        ...mockSentryData,
+        data: {
+          ...mockSentryData.data,
+          issue: {
+            ...mockSentryData.data.issue,
+            permalink: undefined
+          }
+        }
+      };
+      mockRequest.body = dataWithoutPermalink;
+      mockSendSlackMessage.mockResolvedValue();
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(mockSendSlackMessage).toHaveBeenCalledWith(
+        expect.stringContaining('🔗 *상세 보기:* https://velog-dashboardv2.sentry.io/issues/test-issue-123/')
+      );
+    });
+
+    it('Slack 메시지 전송 실패 시 에러를 전달해야 한다', async () => {
+      mockRequest.body = mockSentryData;
+      const slackError = new Error('Slack 전송 실패');
+      mockSendSlackMessage.mockRejectedValue(slackError);
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(nextFunction).toHaveBeenCalledWith(slackError);
+      expect(mockResponse.json).not.toHaveBeenCalled();
+    });
+
+    // Invalid Body 케이스 테스트들
+    it('action이 created가 아닌 경우 400 에러를 반환해야 한다', async () => {
+      mockRequest.body = { action: 'resolved' };
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        success: true,
+        message: 'Sentry 웹훅 처리에 실패했습니다',
+        data: {},
+        error: null
+      });
+      expect(nextFunction).not.toHaveBeenCalled();
+    });
+
+    it('빈 body인 경우 400 에러를 반환해야 한다', async () => {
+      mockRequest.body = {};
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        success: true,
+        message: 'Sentry 웹훅 처리에 실패했습니다',
+        data: {},
+        error: null
+      });
+    });
+
+    it('action이 없는 경우 400 에러를 반환해야 한다', async () => {
+      mockRequest.body = { data: { issue: {} } };
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        success: true,
+        message: 'Sentry 웹훅 처리에 실패했습니다',
+        data: {},
+        error: null
+      });
+    });
+
+    it('전혀 다른 형태의 객체인 경우 400 에러를 반환해야 한다', async () => {
+      mockRequest.body = {
+        username: 'test',
+        password: '123456',
+        email: '[email protected]'
+      };
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        success: true,
+        message: 'Sentry 웹훅 처리에 실패했습니다',
+        data: {},
+        error: null
+      });
+    });
+
+    it('action은 created이지만 필수 필드가 없는 경우 에러를 전달해야 한다', async () => {
+      mockRequest.body = {
+        action: 'created',
+        data: {
+          issue: {
+            // 필수 필드들이 누락됨
+          }
+        }
+      };
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(nextFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: 'Sentry 웹훅 데이터가 올바르지 않습니다'
+        })
+      );
+      expect(mockResponse.json).not.toHaveBeenCalled();
+    });
+
+    it('action은 created이지만 data가 없는 경우 에러를 전달해야 한다', async () => {
+      mockRequest.body = { action: 'created' };
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(nextFunction).toHaveBeenCalled();
+      expect(mockResponse.json).not.toHaveBeenCalled();
+    });
+
+    it('잘못된 타입의 body인 경우 400 에러를 반환해야 한다', async () => {
+      mockRequest.body = 'invalid string body';
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+    });
+  });
+
+  describe('formatSentryMessage (private method integration test)', () => {
+    it('완전한 Sentry 데이터로 올바른 형식의 메시지를 생성해야 한다', async () => {
+      // 실제 동작에 필요한 필수 값만 사용하도록 타입 미적용
+      const completeData = {
+        action: 'created',
+        data: {
+          issue: {
+            id: 'issue-456',
+            title: 'TypeError: Cannot read property of undefined',
+            culprit: 'components/UserProfile.tsx:25',
+            status: 'unresolved',
+            count: "12",
+            userCount: 8,
+            firstSeen: '2024-01-15T14:30:00.000Z',
+            permalink: 'https://velog-dashboardv2.sentry.io/issues/issue-456/',
+            project: {
+              id: 'proj-789',
+              name: 'Velog Dashboard V2',
+              slug: 'velog-dashboard-v2'
+            }
+          }
+        }
+      };
+
+      mockRequest.body = completeData;
+      mockSendSlackMessage.mockResolvedValue();
+
+      await webhookController.handleSentryWebhook(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction
+      );
+
+      const expectedMessage = `🚨 *새로운 오류가 발생하였습니다*
+
+🔴 *제목:* TypeError: Cannot read property of undefined
+
+📍 *위치:* components/UserProfile.tsx:25
+
+🔗 *상세 보기:* https://velog-dashboardv2.sentry.io/issues/issue-456/`;
+
+      expect(mockSendSlackMessage).toHaveBeenCalledWith(expectedMessage);
+    });
+  });
+}); 

src/controllers/webhook.controller.ts

@@ -0,0 +1,57 @@
+import { NextFunction, Request, RequestHandler, Response } from 'express';
+import { EmptyResponseDto, SentryWebhookData } from '@/types';
+import logger from '@/configs/logger.config';
+import { sendSlackMessage } from '@/modules/slack/slack.notifier';
+
+export class WebhookController {
+  private readonly STATUS_EMOJI = {
+    'unresolved': '🔴',
+    'resolved': '✅',
+    'ignored': '🔇',
+  } as const;
+
+  handleSentryWebhook: RequestHandler = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+
+      if (req.body?.action !== "created") { 
+        const response = new EmptyResponseDto(true, 'Sentry 웹훅 처리에 실패했습니다', {}, null);
+        res.status(400).json(response);
+        return;
+      }
+
+      const sentryData: SentryWebhookData = req.body;
+
+      const slackMessage = this.formatSentryMessage(sentryData);
+      await sendSlackMessage(slackMessage);
+
+      const response = new EmptyResponseDto(true, 'Sentry 웹훅 처리에 성공하였습니다.', {}, null);
+      res.status(200).json(response);
+    } catch (error) {
+      logger.error('Sentry 웹훅 처리 실패:', error);
+      next(error);
+    }
+  };
+
+  private formatSentryMessage(sentryData: SentryWebhookData): string {
+    const { data: { issue } } = sentryData;
+
+    if(!issue.status || !issue.title || !issue.culprit || !issue.id) throw new Error('Sentry 웹훅 데이터가 올바르지 않습니다');
+
+    const { status, title: issueTitle, culprit, permalink, id } = issue;
+    const statusEmoji = this.STATUS_EMOJI[status as keyof typeof this.STATUS_EMOJI];
+
+    // URL 생성 - permalink가 있으면 사용, 없으면 실제 프로젝트 URL 패턴으로 생성
+    const detailUrl = permalink || `https://velog-dashboardv2.sentry.io/issues/${id}/`;
+
+    let message = `🚨 *새로운 오류가 발생하였습니다*\n\n`;
+    message += `${statusEmoji} *제목:* ${issueTitle}\n\n`;
+    message += `📍 *위치:* ${culprit}\n\n`;
+    message += `🔗 *상세 보기:* ${detailUrl}`;
+
+    return message;
+  }
+} 

src/routes/index.ts

@@ -4,6 +4,7 @@ import PostRouter from './post.router';
 import NotiRouter from './noti.router';
 import LeaderboardRouter from './leaderboard.router';
 import TotalStatsRouter from './totalStats.router';
+import WebhookRouter from './webhook.router';
 
 const router: Router = express.Router();
 
@@ -16,5 +17,6 @@ router.use('/', PostRouter);
 router.use('/', NotiRouter);
 router.use('/', LeaderboardRouter);
 router.use('/', TotalStatsRouter);
+router.use('/', WebhookRouter);
 
 export default router;