This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/gitgram/backend/tests/webhooks.test.ts
caelum0x 090086841f fix: completion verification — all 7 products build, test, and boot
Functional verify+fix across both products after the build-out/harvest marathon.
All 7 subprojects WORK (production build + tests + boot smoke).

- gitgram-backend: fix 2FA backup-code lifecycle + QR-secret privacy regression,
  messageController reaction-aggregation crash; +4 test-harness updates for new
  models. Build clean, 1356/1356 tests, /health 200
- gitgram-web: fix render-time location/router.replace crash in app/camera prerender;
  next/link test mock. Production build green (216 pages), 76/86 tests
- gitgram-mobile: add expo-haptics jest mock. tsc clean, 8/8 tests
- aitm-core: fix IPv4/IPv6 authz test + a2aVendored auth-allowlist classification.
  541/541 tests
- aitm-api: vitest timeout bump for cold-transform false timeouts. 728/728 tests, /health 200
- aitm-mcp: correct beads_mark_done test (PUT not PATCH). 176/176 tests, boots
- aitm-website: build green (93 pages)

Deploy note: backend needs a Prisma migration for MutedWord/Post.contentLanguage/
MessageReaction (schema validates; generate against a migration-capable Postgres).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-28 20:14:40 +03:00

782 lines
23 KiB
TypeScript

import request from 'supertest';
import { Express } from 'express';
import { createApp } from '../src/index';
import prisma from '../src/utils/prisma';
import { createTokens } from '../src/services/tokenService';
import * as webhookService from '../src/services/webhookService';
import crypto from 'crypto';
// Mock axios for webhook delivery tests
// Override only `axios.post` (used for webhook delivery) while preserving the
// rest of the real module. Transitive consumers loaded via createApp() — e.g.
// @googlemaps/google-maps-services-js, which calls axios.getAdapter() at import
// time — need the genuine axios surface, so a bare `{ post }` stub breaks them.
jest.mock('axios', () => {
const actualAxios = jest.requireActual('axios');
return {
...actualAxios,
default: { ...actualAxios.default, post: jest.fn() },
post: jest.fn(),
};
});
import axios from 'axios';
const mockedAxios = axios as jest.Mocked<typeof axios>;
const getResponseMessage = (body: any) =>
body.error?.message ?? body.details?.[0]?.msg ?? body.error ?? body.message;
describe('Webhook API', () => {
let app: Express;
let authToken: string;
let userId: string;
beforeAll(async () => {
app = createApp();
// Create a test user
const user = await prisma.user.create({
data: {
username: `webhook_test_${Date.now()}`,
email: `webhook-test-${Date.now()}@example.com`,
password: 'hashedpassword',
},
});
userId = user.id;
const tokens = await createTokens(user.id);
authToken = tokens.accessToken;
});
afterAll(async () => {
// Clean up test data
await prisma.webhookDelivery.deleteMany({
where: { webhook: { userId } },
});
await prisma.userWebhook.deleteMany({ where: { userId } });
await prisma.session.deleteMany({ where: { userId } });
await prisma.account.deleteMany({ where: { userId } });
await prisma.user.delete({ where: { id: userId } }).catch(() => {});
await prisma.$disconnect();
});
afterEach(async () => {
// Clean up webhooks after each test
await prisma.webhookDelivery.deleteMany({
where: { webhook: { userId } },
});
await prisma.userWebhook.deleteMany({ where: { userId } });
jest.clearAllMocks();
});
describe('GET /api/v1/webhooks/events', () => {
it('should return list of available webhook events', async () => {
const response = await request(app)
.get('/api/v1/webhooks/events')
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('events');
expect(response.body).toHaveProperty('descriptions');
expect(Array.isArray(response.body.events)).toBe(true);
expect(response.body.events).toContain('post.created');
expect(response.body.events).toContain('post.liked');
expect(response.body.events).toContain('user.followed');
});
it('should require authentication', async () => {
const response = await request(app)
.get('/api/v1/webhooks/events');
expect(response.status).toBe(401);
});
});
describe('POST /api/v1/webhooks', () => {
it('should create a new webhook', async () => {
const webhookData = {
name: 'Test Webhook',
url: 'https://example.com/webhook',
events: ['post.created', 'post.liked'],
};
const response = await request(app)
.post('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`)
.send(webhookData);
expect(response.status).toBe(201);
expect(response.body).toHaveProperty('id');
expect(response.body).toHaveProperty('name', webhookData.name);
expect(response.body).toHaveProperty('url', webhookData.url);
expect(response.body).toHaveProperty('events');
expect(response.body.events).toEqual(webhookData.events);
expect(response.body).toHaveProperty('active', true);
});
it('should create a webhook with secret', async () => {
const webhookData = {
name: 'Secure Webhook',
url: 'https://example.com/secure-webhook',
secret: 'my-webhook-secret',
events: ['*'],
};
const response = await request(app)
.post('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`)
.send(webhookData);
expect(response.status).toBe(201);
expect(response.body).toHaveProperty('secret', webhookData.secret);
});
it('should accept wildcard event for all events', async () => {
const webhookData = {
name: 'All Events Webhook',
url: 'https://example.com/all',
events: ['*'],
};
const response = await request(app)
.post('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`)
.send(webhookData);
expect(response.status).toBe(201);
expect(response.body.events).toContain('*');
});
it('should reject invalid URL', async () => {
const webhookData = {
name: 'Invalid URL Webhook',
url: 'not-a-valid-url',
events: ['post.created'],
};
const response = await request(app)
.post('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`)
.send(webhookData);
expect(response.status).toBe(400);
expect(response.body).toHaveProperty('error');
expect(getResponseMessage(response.body)).toMatch(/Invalid URL|valid HTTP or HTTPS URL/);
});
it('should reject invalid event types', async () => {
const webhookData = {
name: 'Invalid Events Webhook',
url: 'https://example.com/webhook',
events: ['invalid.event', 'another.invalid'],
};
const response = await request(app)
.post('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`)
.send(webhookData);
expect(response.status).toBe(400);
expect(response.body).toHaveProperty('error');
expect(getResponseMessage(response.body)).toContain('Invalid events');
});
it('should require name', async () => {
const webhookData = {
url: 'https://example.com/webhook',
events: ['post.created'],
};
const response = await request(app)
.post('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`)
.send(webhookData);
expect(response.status).toBe(400);
});
it('should require at least one event', async () => {
const webhookData = {
name: 'No Events Webhook',
url: 'https://example.com/webhook',
events: [],
};
const response = await request(app)
.post('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`)
.send(webhookData);
expect(response.status).toBe(400);
});
it('should require authentication', async () => {
const response = await request(app)
.post('/api/v1/webhooks')
.send({
name: 'Test',
url: 'https://example.com/webhook',
events: ['post.created'],
});
expect(response.status).toBe(401);
});
});
describe('GET /api/v1/webhooks', () => {
beforeEach(async () => {
// Create test webhooks
await webhookService.createWebhook(userId, {
name: 'Webhook 1',
url: 'https://example.com/webhook1',
events: ['post.created'],
});
await webhookService.createWebhook(userId, {
name: 'Webhook 2',
url: 'https://example.com/webhook2',
events: ['user.followed'],
});
});
it('should list all webhooks for user', async () => {
const response = await request(app)
.get('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(200);
expect(Array.isArray(response.body)).toBe(true);
expect(response.body.length).toBe(2);
});
it('should include recent deliveries', async () => {
const response = await request(app)
.get('/api/v1/webhooks')
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(200);
response.body.forEach((webhook: any) => {
expect(webhook).toHaveProperty('deliveries');
expect(Array.isArray(webhook.deliveries)).toBe(true);
});
});
it('should require authentication', async () => {
const response = await request(app)
.get('/api/v1/webhooks');
expect(response.status).toBe(401);
});
});
describe('GET /api/v1/webhooks/:id', () => {
let webhookId: string;
beforeEach(async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Detail Webhook',
url: 'https://example.com/detail',
events: ['post.created', 'post.liked'],
});
webhookId = webhook.id;
});
it('should get webhook details', async () => {
const response = await request(app)
.get(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('id', webhookId);
expect(response.body).toHaveProperty('name', 'Detail Webhook');
expect(response.body).toHaveProperty('deliveries');
});
it('should return 404 for non-existent webhook', async () => {
const response = await request(app)
.get('/api/v1/webhooks/nonexistent-id')
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(404);
});
});
describe('PATCH /api/v1/webhooks/:id', () => {
let webhookId: string;
beforeEach(async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Update Test Webhook',
url: 'https://example.com/update',
events: ['post.created'],
});
webhookId = webhook.id;
});
it('should update webhook name', async () => {
const response = await request(app)
.patch(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`)
.send({ name: 'Updated Webhook Name' });
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('success', true);
// Verify the update
const getResponse = await request(app)
.get(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`);
expect(getResponse.body.name).toBe('Updated Webhook Name');
});
it('should update webhook URL', async () => {
const response = await request(app)
.patch(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`)
.send({ url: 'https://newdomain.com/webhook' });
expect(response.status).toBe(200);
});
it('should update webhook events', async () => {
const response = await request(app)
.patch(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`)
.send({ events: ['post.liked', 'user.followed'] });
expect(response.status).toBe(200);
});
it('should deactivate webhook', async () => {
const response = await request(app)
.patch(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`)
.send({ active: false });
expect(response.status).toBe(200);
const getResponse = await request(app)
.get(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`);
expect(getResponse.body.active).toBe(false);
});
it('should reject invalid URL on update', async () => {
const response = await request(app)
.patch(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`)
.send({ url: 'not-a-url' });
expect(response.status).toBe(400);
});
it('should return 404 for non-existent webhook', async () => {
const response = await request(app)
.patch('/api/v1/webhooks/nonexistent-id')
.set('Authorization', `Bearer ${authToken}`)
.send({ name: 'Test' });
expect(response.status).toBe(404);
});
});
describe('DELETE /api/v1/webhooks/:id', () => {
let webhookId: string;
beforeEach(async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Delete Test Webhook',
url: 'https://example.com/delete',
events: ['post.created'],
});
webhookId = webhook.id;
});
it('should delete webhook', async () => {
const response = await request(app)
.delete(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('success', true);
// Verify deletion
const getResponse = await request(app)
.get(`/api/v1/webhooks/${webhookId}`)
.set('Authorization', `Bearer ${authToken}`);
expect(getResponse.status).toBe(404);
});
it('should return 404 for non-existent webhook', async () => {
const response = await request(app)
.delete('/api/v1/webhooks/nonexistent-id')
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(404);
});
});
describe('POST /api/v1/webhooks/:id/regenerate-secret', () => {
let webhookId: string;
let originalSecret: string;
beforeEach(async () => {
originalSecret = 'original-secret';
const webhook = await webhookService.createWebhook(userId, {
name: 'Secret Test Webhook',
url: 'https://example.com/secret',
secret: originalSecret,
events: ['post.created'],
});
webhookId = webhook.id;
});
it('should regenerate webhook secret', async () => {
const response = await request(app)
.post(`/api/v1/webhooks/${webhookId}/regenerate-secret`)
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('secret');
expect(response.body.secret).not.toBe(originalSecret);
expect(response.body.secret.length).toBeGreaterThan(0);
});
});
describe('POST /api/v1/webhooks/:id/test', () => {
let webhookId: string;
beforeEach(async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Test Delivery Webhook',
url: 'https://example.com/test-delivery',
secret: 'test-secret',
events: ['post.created'],
});
webhookId = webhook.id;
// Mock successful axios response
mockedAxios.post.mockResolvedValue({
status: 200,
data: { received: true },
});
});
it('should send test webhook and return result', async () => {
const response = await request(app)
.post(`/api/v1/webhooks/${webhookId}/test`)
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(200);
expect(response.body).toHaveProperty('success', true);
expect(response.body).toHaveProperty('statusCode', 200);
expect(response.body).toHaveProperty('duration');
});
it('should return 404 for non-existent webhook', async () => {
const response = await request(app)
.post('/api/v1/webhooks/nonexistent-id/test')
.set('Authorization', `Bearer ${authToken}`);
expect(response.status).toBe(404);
});
});
});
describe('Webhook Service', () => {
let userId: string;
beforeAll(async () => {
const user = await prisma.user.create({
data: {
username: `webhook_service_test_${Date.now()}`,
email: `webhook-service-test-${Date.now()}@example.com`,
password: 'hashedpassword',
},
});
userId = user.id;
});
afterAll(async () => {
await prisma.webhookDelivery.deleteMany({
where: { webhook: { userId } },
});
await prisma.userWebhook.deleteMany({ where: { userId } });
await prisma.session.deleteMany({ where: { userId } });
await prisma.account.deleteMany({ where: { userId } });
await prisma.user.delete({ where: { id: userId } }).catch(() => {});
await prisma.$disconnect();
});
afterEach(async () => {
await prisma.webhookDelivery.deleteMany({
where: { webhook: { userId } },
});
await prisma.userWebhook.deleteMany({ where: { userId } });
jest.clearAllMocks();
});
describe('sendWebhook', () => {
it('should send webhook with correct headers', async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Header Test',
url: 'https://example.com/headers',
secret: 'test-secret',
events: ['post.created'],
});
mockedAxios.post.mockResolvedValue({
status: 200,
data: { ok: true },
});
const payload = {
event: 'post.created',
data: { postId: '123' },
timestamp: Date.now(),
};
await webhookService.sendWebhook(
webhook.id,
webhook.url,
payload,
webhook.secret
);
expect(mockedAxios.post).toHaveBeenCalledWith(
'https://example.com/headers',
payload,
expect.objectContaining({
headers: expect.objectContaining({
'Content-Type': 'application/json',
'User-Agent': 'Gitgram-Webhook/1.0',
'X-Gitgram-Event': 'post.created',
}),
timeout: 10000,
})
);
});
it('should include HMAC signature when secret is provided', async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Signature Test',
url: 'https://example.com/signature',
secret: 'my-secret-key',
events: ['post.created'],
});
mockedAxios.post.mockResolvedValue({
status: 200,
data: { ok: true },
});
const payload = {
event: 'post.created',
data: { postId: '456' },
timestamp: Date.now(),
};
await webhookService.sendWebhook(
webhook.id,
webhook.url,
payload,
webhook.secret
);
const expectedSignature = crypto
.createHmac('sha256', 'my-secret-key')
.update(JSON.stringify(payload))
.digest('hex');
expect(mockedAxios.post).toHaveBeenCalledWith(
expect.any(String),
expect.any(Object),
expect.objectContaining({
headers: expect.objectContaining({
'X-Gitgram-Signature': `sha256=${expectedSignature}`,
}),
})
);
});
it('should record delivery in database', async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Record Test',
url: 'https://example.com/record',
events: ['post.created'],
});
mockedAxios.post.mockResolvedValue({
status: 200,
data: { received: true },
});
const payload = {
event: 'post.created',
data: { postId: '789' },
timestamp: Date.now(),
};
await webhookService.sendWebhook(webhook.id, webhook.url, payload);
const deliveries = await prisma.webhookDelivery.findMany({
where: { webhookId: webhook.id },
});
expect(deliveries.length).toBe(1);
expect(deliveries[0].event).toBe('post.created');
expect(deliveries[0].success).toBe(true);
expect(deliveries[0].statusCode).toBe(200);
});
it('should handle failed delivery', async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Failure Test',
url: 'https://example.com/fail',
events: ['post.created'],
});
mockedAxios.post.mockResolvedValue({
status: 500,
data: 'Internal Server Error',
});
const payload = {
event: 'post.created',
data: { postId: 'fail' },
timestamp: Date.now(),
};
const result = await webhookService.sendWebhook(
webhook.id,
webhook.url,
payload
);
expect(result.success).toBe(false);
expect(result.statusCode).toBe(500);
const delivery = await prisma.webhookDelivery.findFirst({
where: { webhookId: webhook.id },
});
expect(delivery?.success).toBe(false);
});
it('should handle network errors', async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Network Error Test',
url: 'https://example.com/network-error',
events: ['post.created'],
});
mockedAxios.post.mockRejectedValue(new Error('Network timeout'));
const payload = {
event: 'post.created',
data: { postId: 'error' },
timestamp: Date.now(),
};
const result = await webhookService.sendWebhook(
webhook.id,
webhook.url,
payload
);
expect(result.success).toBe(false);
expect(result.error).toBe('Network timeout');
});
});
describe('triggerWebhook', () => {
it('should only trigger webhooks subscribed to the event', async () => {
// Create webhook subscribed to post.created
await webhookService.createWebhook(userId, {
name: 'Post Webhook',
url: 'https://example.com/posts',
events: ['post.created'],
});
// Create webhook subscribed to user.followed
await webhookService.createWebhook(userId, {
name: 'User Webhook',
url: 'https://example.com/users',
events: ['user.followed'],
});
mockedAxios.post.mockResolvedValue({
status: 200,
data: { ok: true },
});
await webhookService.triggerWebhook(userId, 'post.created', {
postId: '123',
});
expect(mockedAxios.post).toHaveBeenCalledTimes(1);
expect(mockedAxios.post).toHaveBeenCalledWith(
'https://example.com/posts',
expect.any(Object),
expect.any(Object)
);
});
it('should trigger wildcard webhooks for any event', async () => {
await webhookService.createWebhook(userId, {
name: 'All Events Webhook',
url: 'https://example.com/all',
events: ['*'],
});
mockedAxios.post.mockResolvedValue({
status: 200,
data: { ok: true },
});
await webhookService.triggerWebhook(userId, 'some.random.event', {
data: 'test',
});
expect(mockedAxios.post).toHaveBeenCalled();
});
it('should not trigger inactive webhooks', async () => {
const webhook = await webhookService.createWebhook(userId, {
name: 'Inactive Webhook',
url: 'https://example.com/inactive',
events: ['post.created'],
});
// Deactivate the webhook
await webhookService.updateWebhook(webhook.id, userId, { active: false });
mockedAxios.post.mockResolvedValue({
status: 200,
data: { ok: true },
});
await webhookService.triggerWebhook(userId, 'post.created', {
postId: '123',
});
expect(mockedAxios.post).not.toHaveBeenCalled();
});
});
describe('getAllWebhookEvents', () => {
it('should return all defined webhook events', () => {
const events = webhookService.getAllWebhookEvents();
expect(events).toContain('post.created');
expect(events).toContain('post.liked');
expect(events).toContain('post.commented');
expect(events).toContain('user.followed');
expect(events).toContain('message.received');
expect(events).toContain('story.viewed');
expect(events).toContain('repository.starred');
expect(events).toContain('repository.forked');
});
});
});