mirror of
https://github.com/wekan/wekan.git
synced 2026-11-20 09:45:04 -05:00
71 lines
5.0 KiB
JavaScript
71 lines
5.0 KiB
JavaScript
'use strict';
|
|
const { test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const { MongoClient, ObjectId } = require('mongodb');
|
|
const { prepareWebhookPlan, deliverWebhookPlan } = require('../../server/lib/syncWebhookPlan');
|
|
const { deliverStoredWebhookHttp, MAX_RESPONSE_BYTES } = require('../../server/lib/syncWebhookHttp');
|
|
const uri = process.env.WEKAN_SYNC_TEST_MONGO_URL;
|
|
async function fixture(t, is2way = true) {
|
|
const client = await new MongoClient(uri).connect(), db = client.db(`webhook_http_${new ObjectId().toHexString()}`);
|
|
t.after(async () => { await db.dropDatabase(); await client.close(); });
|
|
const activity = { _id: 'event', boardId: 'board', cardId: 'card', userId: 'actor' };
|
|
const plan = await prepareWebhookPlan({ activity,
|
|
integrations: [{ _id: 'hook', boardId: 'board', enabled: true, url: 'https://example.test/hook',
|
|
type: is2way ? 'bidirectional-webhooks' : 'outgoing-webhooks' }],
|
|
prepare: async () => ({ url: 'https://example.test/hook', headers: { 'Content-Type': 'application/json' },
|
|
body: '{"cardId":"card"}', is2way, language: 'en' }) });
|
|
const requests = [], actions = [];
|
|
const responses = db.collection('responses'), receipts = db.collection('receipts');
|
|
const options = { responses, assertCurrent: async () => {}, assertTarget: async () => true,
|
|
requestHttp: async (url, request) => { requests.push({ url, ...request }); return { status: 200, text: async () => '{"comment":"Reply"}' }; },
|
|
completeResponse: async action => { actions.push(action); return action.deliveryId; } };
|
|
const run = extra => deliverWebhookPlan({ activity, plan, receipts, assertCurrent: options.assertCurrent, assertTarget: options.assertTarget,
|
|
deliver: item => deliverStoredWebhookHttp({ ...options, ...extra, item }) });
|
|
return { run, options, requests, actions, responses, receipts, plan, activity };
|
|
}
|
|
test('stored HTTP acceptance survives response-action failure without another request', { skip: !uri }, async t => {
|
|
const f = await fixture(t);
|
|
await assert.rejects(f.run({ completeResponse: async () => { throw new Error('action interrupted'); } }), /action interrupted/);
|
|
assert.equal(await f.responses.countDocuments({}), 1); assert.equal(await f.receipts.countDocuments({}), 0);
|
|
await f.run(); await f.run();
|
|
assert.equal(f.requests.length, 1); assert.equal(f.actions.length, 1);
|
|
assert.equal(f.actions[0].data.comment, 'Reply');
|
|
assert.equal(f.requests[0].maxRedirects, 0); assert.equal(f.requests[0].maxResponseBytes, MAX_RESPONSE_BYTES);
|
|
assert.equal(f.requests[0].headers['X-Wekan-Delivery-Id'], f.actions[0].deliveryId);
|
|
});
|
|
test('uncertain response insert is read back and saved response corruption never triggers a replacement HTTP request', { skip: !uri }, async t => {
|
|
const f = await fixture(t);
|
|
const responses = { findOne: query => f.responses.findOne(query), insertOne: async row => {
|
|
await f.responses.insertOne(row); throw new Error('lost Mongo reply');
|
|
} };
|
|
await f.run({ responses, completeResponse: async () => 'wrong' }).then(() => assert.fail('requires effect receipt'), error => assert.match(error.message, /response-unconfirmed/));
|
|
assert.equal(f.requests.length, 1); assert.equal(await f.receipts.countDocuments({}), 0);
|
|
await f.responses.updateOne({}, { $set: { body: '{"comment":"Changed"}' } });
|
|
await assert.rejects(f.run(), /response-invalid/); assert.equal(f.requests.length, 1);
|
|
});
|
|
test('non-success, lost body and oversized UTF-8 responses never acknowledge delivery', { skip: !uri }, async t => {
|
|
const f = await fixture(t);
|
|
for (const response of [{ status: 500, text: async () => 'error' },
|
|
{ status: 200, text: async () => { throw new Error('body interrupted'); } },
|
|
{ status: 200, text: async () => 'ä'.repeat(MAX_RESPONSE_BYTES) }]) {
|
|
await assert.rejects(f.run({ requestHttp: async () => response }), /http-rejected|body interrupted|response-too-large/);
|
|
assert.equal(await f.responses.countDocuments({}), 0); assert.equal(await f.receipts.countDocuments({}), 0);
|
|
}
|
|
});
|
|
test('one-way and non-JSON two-way replies finish without a response action', { skip: !uri }, async t => {
|
|
const one = await fixture(t, false);
|
|
await one.run({ completeResponse: undefined }); assert.equal(one.actions.length, 0);
|
|
const two = await fixture(t);
|
|
await two.run({ requestHttp: async () => ({ status: 204, text: async () => '' }),
|
|
completeResponse: async () => assert.fail('no JSON action') });
|
|
assert.equal(await two.receipts.countDocuments({}), 1);
|
|
});
|
|
test('revoked target access prevents replay action and changed request cannot reuse old HTTP evidence', { skip: !uri }, async t => {
|
|
const f = await fixture(t);
|
|
await assert.rejects(f.run({ completeResponse: async () => { throw new Error('pause'); } }), /pause/);
|
|
await assert.rejects(f.run({ assertTarget: async () => false }), /target-denied/);
|
|
f.plan.targets[0].request.body = '{"changed":true}';
|
|
await assert.rejects(f.run(), /response-invalid/);
|
|
assert.equal(f.requests.length, 1); assert.equal(f.actions.length, 0);
|
|
});
|