update dependencies and devDependencies
[websub-hub] / test / src / communication.js
1 /* eslint-env mocha */
2 /* eslint-disable capitalized-comments, sonarjs/no-duplicate-string */
3
4 'use strict';
5
6 const assert = require('assert');
7 const sinon = require('sinon'); // eslint-disable-line node/no-unpublished-require
8
9 const Communication = require('../../src/communication');
10 const Config = require('../../config');
11 const Errors = require('../../src/errors');
12
13 const stubDb = require('../stub-db');
14 const stubLogger = require('../stub-logger');
15
16 const noExpectedException = 'did not get expected exception';
17
18 describe('Communication', function () {
19 let communication, options;
20
21 beforeEach(function () {
22 options = new Config('test');
23 communication = new Communication(stubLogger, stubDb, options);
24 stubDb._reset();
25 stubLogger._reset();
26 });
27 afterEach(function () {
28 sinon.restore();
29 });
30
31 it('instantiates', function () {
32 assert(communication);
33 });
34
35 it('covers config value', function () {
36 options.dingus.selfBaseUrl = undefined;
37 communication = new Communication(stubLogger, stubDb, options);
38 });
39
40 describe('Axios timing coverage', function () {
41 const request = {};
42 const response = {
43 config: request,
44 };
45 it('tags request', function () {
46 communication.axios.interceptors.request.handlers[0].fulfilled(request);
47 assert(request.startTimestampMs);
48 });
49 it('tags response', function () {
50 communication.axios.interceptors.response.handlers[0].fulfilled(response);
51 assert(response.elapsedTimeMs);
52 });
53 }); // Axios timing coverage
54
55 describe('userAgentString', function () {
56 it('has default behavior', function () {
57 const result = Communication.userAgentString();
58 assert(result);
59 assert(result.length > 30);
60 });
61 it('is settable', function () {
62 const result = Communication.userAgentString({
63 product: 'myhub',
64 version: '9.9.9',
65 implementation: 'custom',
66 });
67 assert(result);
68 assert.strictEqual(result, 'myhub/9.9.9 (custom)');
69 });
70 it('covers branches', function () {
71 const result = Communication.userAgentString({
72 product: 'myhub',
73 version: '9.9.9',
74 implementation: '',
75 });
76 assert(result);
77 assert.strictEqual(result, 'myhub/9.9.9');
78 });
79 });
80
81 describe('generateChallenge', function () {
82 it('generates a thing', async function () {
83 const result = await Communication.generateChallenge();
84 assert(result);
85 assert(result.length);
86 });
87 });
88
89 describe('signature', function () {
90 let message, secret, algorithm, expected;
91 beforeEach(function () {
92 message = 'Jackdaws love my big sphinx of quartz.';
93 secret = 'secretsecret';
94 algorithm = 'sha256';
95 expected = 'sha256=ee92148d9cd043cdfb8da7cf5ee1897abaafdb5ab840e85010abd4bf235fa31e';
96 });
97 it('signs a thing', function () {
98 const result = Communication.signature(message, secret, algorithm);
99 assert.strictEqual(result, expected);
100 });
101 });
102
103 describe('contentHash', function () {
104 let content, algorithm, expected;
105 beforeEach(function () {
106 content = 'Jived fox nymph grabs quick waltz.';
107 algorithm = 'sha256';
108 expected = '6e5e1a93bde78910b0d7c5fd8aba393294d4eca5d3fbf2bfd49100df3d5cc85d';
109 });
110 it('hashes', function () {
111 const result = Communication.contentHash(content, algorithm);
112 assert.strictEqual(result, expected);
113 })
114 });
115
116 describe('Axios Configurations', function () {
117 let requestUrl, expectedUrl, topicUrl;
118 beforeEach(function () {
119 requestUrl = 'https://example.com/callback/?id=123';
120 expectedUrl = 'https://example.com/callback/';
121 topicUrl = 'http://example.com/blog/';
122 });
123 it('_axiosConfig', function () {
124 const method = 'GET';
125 const contentType = 'text/plain';
126 const body = undefined;
127 const params = {
128 'extra_parameter': 'foobar',
129 };
130 const expectedUrlObj = new URL('https://example.com/callback/?id=123&extra_parameter=foobar');
131 const expected = {
132 method,
133 url: 'https://example.com/callback/',
134 headers: {
135 'Content-Type': 'text/plain',
136 },
137 params: expectedUrlObj.searchParams,
138 responseType: 'text',
139 };
140 const result = Communication._axiosConfig(method, requestUrl, body, params, {
141 'Content-Type': contentType,
142 });
143 delete result.transformResponse;
144 assert.deepStrictEqual(result, expected);
145 });
146 it('_axiosConfig covers defaults', function () {
147 const method = 'OPTIONS';
148 const expectedUrlObj = new URL(requestUrl);
149 const expected = {
150 method,
151 url: expectedUrl,
152 headers: {},
153 params: expectedUrlObj.searchParams,
154 responseType: 'text',
155 };
156 const result = Communication._axiosConfig(method, requestUrl);
157 delete result.transformResponse;
158 assert.deepStrictEqual(result, expected);
159 });
160 it('covers null response transform', function () {
161 const result = Communication._axiosConfig('GET', 'https://example.com/', undefined, {}, {});
162 result.transformResponse[0]();
163 });
164 it('_intentVerifyAxiosConfig', function () {
165 const mode = 'subscribe';
166 const leaseSeconds = 864000;
167 const challenge = 'abcxyz';
168 const expectedUrlObj = new URL(`${requestUrl}&hub.mode=${mode}&hub.topic=${encodeURIComponent(topicUrl)}&hub.challenge=${challenge}&hub.lease_seconds=${leaseSeconds}`);
169 const expected = {
170 method: 'GET',
171 url: expectedUrl,
172 headers: {},
173 params: expectedUrlObj.searchParams,
174 responseType: 'text',
175 };
176 const result = Communication._intentVerifyAxiosConfig(requestUrl, topicUrl, mode, leaseSeconds, challenge);
177 delete result.transformResponse;
178 assert.deepStrictEqual(result, expected);
179 });
180 it('_intentDenyAxiosConfig', function () {
181 const reason = 'something';
182 const expectedUrlObj = new URL(`${requestUrl}&hub.mode=denied&hub.topic=${encodeURIComponent(topicUrl)}&hub.reason=${reason}`);
183 const expected = {
184 method: 'GET',
185 url: expectedUrl,
186 headers: {},
187 params: expectedUrlObj.searchParams,
188 responseType: 'text',
189 };
190 const result = Communication._intentDenyAxiosConfig(requestUrl, topicUrl, reason);
191 delete result.transformResponse;
192 assert.deepStrictEqual(result, expected);
193 });
194 it('_publisherValidationAxiosConfig', function () {
195 const topic = {
196 url: topicUrl,
197 publisherValidationUrl: 'https://example.com/publisher/',
198 };
199 const verification = {
200 callback: requestUrl,
201 topic: topicUrl,
202 };
203 const expectedUrlObj = new URL(topic.publisherValidationUrl);
204 const expected = {
205 method: 'POST',
206 url: topic.publisherValidationUrl,
207 data: {
208 callback: requestUrl,
209 topic: topicUrl,
210 },
211 headers: {
212 'Content-Type': 'application/json',
213 },
214 params: expectedUrlObj.searchParams,
215 responseType: 'text',
216 };
217 const result = Communication._publisherValidationAxiosConfig(topic, verification);
218 delete result.transformResponse;
219 assert.deepStrictEqual(result, expected);
220 });
221 it('_topicFetchAxiosConfig', function () {
222 const topic = {
223 url: topicUrl,
224 contentType: 'text/plain',
225 };
226 const expectedUrlObj = new URL(topicUrl);
227 const expected = {
228 method: 'GET',
229 url: topicUrl,
230 params: expectedUrlObj.searchParams,
231 headers: {
232 Accept: 'text/plain, */*;q=0.9',
233 },
234 responseType: 'text',
235 };
236 const result = Communication._topicFetchAxiosConfig(topic);
237 delete result.transformResponse;
238 assert.deepStrictEqual(result, expected);
239 });
240 }); // Axios Configurations
241
242 describe('verificationProcess', function () {
243 const challenge = 'a_challenge';
244 let dbCtx, callback, requestId, topicId;
245 let topic, verification;
246 beforeEach(function () {
247 dbCtx = {};
248 callback = 'https://example.com/callback/?id=123';
249 requestId = '7d37ea20-4ef7-417e-a08d-c0ba71269ab1';
250 topicId = '234ec6fb-f1cd-4ac3-8ea9-29ed42ae0e21';
251 topic = {
252 id: topicId,
253 url: 'https://example.com/blog/',
254 isActive: true,
255 isDeleted: false,
256 };
257 verification = {
258 callback,
259 mode: 'subscribe',
260 isPublisherValidated: true,
261 leaseSeconds: 864000,
262 };
263
264 sinon.stub(Communication, 'generateChallenge').resolves(challenge);
265 sinon.stub(communication, 'publisherValidate').resolves(true);
266 sinon.stub(communication, 'axios').resolves({
267 status: 200,
268 statusText: 'OK',
269 headers: {
270 'content-type': 'text/plain',
271 },
272 data: challenge,
273 });
274
275 communication.db.verificationGetById.resolves(verification);
276 communication.db.topicGetById.resolves(topic);
277 communication.db.verificationRelease.resolves({});
278 communication.db.verificationUpdate.resolves({});
279 communication.db.verificationIncomplete.resolves({});
280 communication.db.verificationComplete.resolves({});
281 });
282
283 it('errors on non-existent verification', async function () {
284 communication.db.verificationGetById.restore();
285 sinon.stub(communication.db, 'verificationGetById').resolves();
286
287 try {
288 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
289 assert.fail(noExpectedException);
290 } catch (e) {
291 assert(e instanceof Errors.InternalInconsistencyError);
292 }
293 });
294
295 it('errors on non-existent topic', async function () {
296 communication.db.topicGetById.restore();
297 sinon.stub(communication.db, 'topicGetById').resolves();
298
299 try {
300 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
301 assert.fail(noExpectedException);
302 } catch (e) {
303 assert(e instanceof Errors.InternalInconsistencyError);
304 }
305 });
306
307 it('skips inactive topic', async function () {
308 communication.db.topicGetById.restore();
309 topic.isActive = false;
310 sinon.stub(communication.db, 'topicGetById').resolves(topic);
311
312 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
313
314 assert(communication.db.verificationRelease.called);
315 assert(!communication.axios.called);
316 });
317
318 it('denies subscription to deleted topic', async function () {
319 communication.db.topicGetById.restore();
320 topic.isDeleted = true;
321 sinon.stub(communication.db, 'topicGetById').resolves(topic);
322
323 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
324
325 assert(communication.db.verificationUpdate.called);
326 assert.strictEqual(verification.mode, 'denied');
327 });
328
329 it('checks publisher validation if needed', async function() {
330 communication.db.verificationGetById.restore();
331 verification.isPublisherValidated = false;
332 sinon.stub(communication.db, 'verificationGetById').resolves(verification);
333 communication.db.topicGetById.restore();
334 topic.publisherValidationUrl = 'https://example.com/publisher/';
335 sinon.stub(communication.db, 'topicGetById').resolves(topic);
336
337 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
338
339 assert(communication.publisherValidate.called);
340 assert(communication.db.verificationComplete.called);
341 });
342
343 it('handles publisher validation failure', async function() {
344 communication.db.verificationGetById.restore();
345 verification.isPublisherValidated = false;
346 sinon.stub(communication.db, 'verificationGetById').resolves(verification);
347 communication.db.topicGetById.restore();
348 topic.publisherValidationUrl = 'https://example.com/publisher/';
349 sinon.stub(communication.db, 'topicGetById').resolves(topic);
350 communication.publisherValidate.restore();
351 sinon.stub(communication, 'publisherValidate').resolves(false);
352
353 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
354
355 assert(communication.publisherValidate.called);
356 assert(communication.db.verificationIncomplete.called);
357 });
358
359 it('handles request error', async function () {
360 communication.axios.restore();
361 sinon.stub(communication, 'axios').throws(new Error());
362
363 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
364
365 assert(communication.db.verificationIncomplete.called);
366 });
367
368 it('handles 500 response', async function () {
369 communication.axios.restore();
370 sinon.stub(communication, 'axios').resolves({
371 status: 500,
372 });
373
374 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
375
376 assert(communication.db.verificationIncomplete.called);
377 });
378
379 it('handles non-200 response', async function () {
380 communication.axios.restore();
381 sinon.stub(communication, 'axios').resolves({
382 status: 400,
383 });
384
385 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
386
387 assert(communication.db.verificationComplete.called);
388 });
389
390 it('subscription succeeds', async function () {
391 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
392
393 assert(communication.db.subscriptionUpsert.called);
394 assert(communication.db.verificationComplete.called);
395 });
396
397 it('unsubscription succeeds', async function () {
398 communication.db.verificationGetById.restore();
399 verification.mode = 'unsubscribe';
400 sinon.stub(communication.db, 'verificationGetById').resolves(verification);
401
402 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
403
404 assert(communication.db.subscriptionDelete.called);
405 assert(communication.db.verificationComplete.called);
406 });
407
408 it('unsubscription from deleted topic deletes topic', async function () {
409 communication.db.verificationGetById.restore();
410 verification.mode = 'unsubscribe';
411 sinon.stub(communication.db, 'verificationGetById').resolves(verification);
412 communication.db.topicGetById.restore();
413 sinon.stub(communication.db, 'topicGetById').resolves({
414 ...topic,
415 isDeleted: true,
416 });
417
418 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
419
420 assert(communication.db.subscriptionDelete.called);
421 assert(communication.db.verificationComplete.called);
422 assert(communication.db.topicPendingDelete.called);
423 });
424
425 it('unsubscription denial succeeds', async function () {
426 communication.db.verificationGetById.restore();
427 verification.mode = 'unsubscribe';
428 sinon.stub(communication.db, 'verificationGetById').resolves(verification);
429 communication.axios.restore();
430 sinon.stub(communication, 'axios').resolves({
431 status: 200,
432 statusText: 'OK',
433 headers: {
434 'content-type': 'text/plain',
435 },
436 data: 'not the challenge',
437 });
438
439 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
440
441 assert(!communication.db.subscriptionDelete.called);
442 assert(communication.db.verificationComplete.called);
443 });
444
445 it('does not handle strange mode', async function() {
446 communication.db.verificationGetById.restore();
447 verification.mode = 'flarp';
448 sinon.stub(communication.db, 'verificationGetById').resolves(verification);
449
450 try {
451 await communication.verificationProcess(dbCtx, callback, topicId, requestId);
452 assert.fail(noExpectedException);
453 } catch (e) {
454 assert(e instanceof Errors.InternalInconsistencyError);
455 }
456 });
457 }); // verificationProcess
458
459 describe('publisherValidate', function () {
460 let dbCtx, topic, verification;
461 beforeEach(function () {
462 dbCtx = {};
463 topic = {
464 url: 'https://example.com/topic/',
465 publisherValidationUrl: 'https://example.com/pub_valid/',
466 };
467 verification = {
468 callback: 'https://exmaple.com/callback/?id=123',
469 httpFrom: 'user@example.com',
470 httpRemoteAddr: '127.0.0.0',
471 };
472
473 sinon.stub(communication, 'axios').resolves({
474 status: 200,
475 statusText: 'OK',
476 headers: {
477 'content-type': 'application/json',
478 },
479 });
480
481 communication.db.verificationIncomplete.resolves();
482 communication.db.verificationUpdate.resolves();
483 communication.db.verificationValidated.resolves();
484 });
485
486 it('succeeds', async function () {
487 const result = await communication.publisherValidate(dbCtx, topic, verification);
488
489 assert(communication.db.verificationValidated.called);
490 assert.strictEqual(result, true);
491 });
492
493 it('succeeds with rejection', async function () {
494 communication.axios.restore();
495 sinon.stub(communication, 'axios').resolves({
496 status: 400,
497 statusText: 'Bad Request',
498 headers: {
499 'content-type': 'application/json',
500 },
501 });
502
503 const result = await communication.publisherValidate(dbCtx, topic, verification);
504
505 assert(communication.db.verificationValidated.called);
506 assert(communication.db.verificationUpdate.called);
507 assert.strictEqual(result, true);
508 });
509
510 it('defers on request server error', async function () {
511 communication.axios.restore();
512 sinon.stub(communication, 'axios').resolves({
513 status: 502,
514 statusText: 'Bad Gateway',
515 headers: {
516 'content-type': 'text/plain',
517 },
518 });
519
520 const result = await communication.publisherValidate(dbCtx, topic, verification);
521
522 assert.strictEqual(result, false);
523 });
524
525 it('handles request error', async function () {
526 communication.axios.restore();
527 sinon.stub(communication, 'axios').throws(new Error());
528
529 const result = await communication.publisherValidate(dbCtx, topic, verification);
530
531 assert.strictEqual(result, false);
532 });
533
534 }); // publisherValidate
535
536 describe('topicFetchProcess', function () {
537 let dbCtx, topic, requestId, topicId;
538
539 beforeEach(function () {
540 dbCtx = {};
541 topic = {
542 url: 'https://example.com/topic/',
543 isDeleted: false,
544 contentHashAlgorithm: 'sha512',
545 };
546 requestId = '7d37ea20-4ef7-417e-a08d-c0ba71269ab1';
547 topicId = '234ec6fb-f1cd-4ac3-8ea9-29ed42ae0e21';
548
549 sinon.stub(communication, 'axios').resolves({
550 status: 200,
551 statusText: 'OK',
552 headers: {
553 'content-type': 'text/plain',
554 link: '<https://example.com/hub/>; rel="hub"',
555 },
556 data: 'Jackdaws love my big sphinx of quartz.',
557 });
558
559 communication.db.topicGetById.resolves(topic);
560 });
561
562 it('requires topic exists', async function () {
563 communication.db.topicGetById.restore();
564 sinon.stub(communication.db, 'topicGetById').resolves();
565
566 try {
567 await communication.topicFetchProcess(dbCtx, topicId, requestId);
568 assert.fail(noExpectedException);
569 } catch (e) {
570 assert(e instanceof Errors.InternalInconsistencyError);
571 }
572 });
573
574 it ('skips deleted topic', async function () {
575 communication.db.topicGetById.restore();
576 topic.isDeleted = true;
577 sinon.stub(communication.db, 'topicGetById').resolves(topic);
578
579 await communication.topicFetchProcess(dbCtx, topicId, requestId);
580
581 assert(!communication.axios.called);
582 });
583
584 it('handles request error', async function () {
585 communication.axios.restore();
586 sinon.stub(communication, 'axios').throws(new Error());
587
588 await communication.topicFetchProcess(dbCtx, topicId, requestId);
589
590 assert(communication.db.topicFetchIncomplete.called);
591 });
592
593 it('handles 500 response', async function () {
594 communication.axios.restore();
595 sinon.stub(communication, 'axios').resolves({
596 status: 500,
597 statusText: 'Internal Server Error',
598 headers: {
599 'content-type': 'text/plain',
600 },
601 });
602
603 await communication.topicFetchProcess(dbCtx, topicId, requestId);
604
605 assert(communication.db.topicFetchIncomplete.called);
606 });
607
608 it('handles bad response', async function () {
609 communication.axios.restore();
610 sinon.stub(communication, 'axios').resolves({
611 status: 404,
612 statusText: 'Not Found',
613 headers: {
614 'content-type': 'text/plain',
615 },
616 });
617
618 await communication.topicFetchProcess(dbCtx, topicId, requestId);
619
620 assert(communication.db.topicFetchIncomplete.called);
621 });
622
623 it('recognizes unchanged content', async function () {
624 communication.db.topicGetById.restore();
625 topic.contentHash = 'a630999c61738f3e066d79a1b299a295c5d0598c173e0904d04a707d43988e3e81660bfc1b1779377f4ec26f837d1bb31fa2b860c9ad2d37495d83de32647fea';
626 sinon.stub(communication.db, 'topicGetById').resolves(topic);
627
628 await communication.topicFetchProcess(dbCtx, topicId, requestId);
629
630 assert(communication.db.topicFetchComplete.called);
631 assert(!communication.db.topicSetContent.called);
632 });
633
634 it('updates content', async function () {
635 await communication.topicFetchProcess(dbCtx, topicId, requestId);
636
637 assert(communication.db.topicFetchComplete.called);
638 assert(communication.db.topicSetContent.called);
639 });
640
641 it('updates content with lax link enforcement', async function () {
642 communication.axios.restore();
643 sinon.stub(communication, 'axios').resolves({
644 status: 200,
645 statusText: 'OK',
646 headers: {
647 'content-type': 'text/plain',
648 link: '<https://example.com/other/hub/>; rel="hub"',
649 },
650 data: 'Jackdaws love my big sphinx of quartz.',
651 });
652
653 communication.options.communication.strictTopicHubLink = false;
654
655 await communication.topicFetchProcess(dbCtx, topicId, requestId);
656
657 assert(communication.db.topicFetchComplete.called);
658 assert(communication.db.topicSetContent.called);
659 });
660
661 it('deletes topic when hub relation unsatisfied', async function () {
662 communication.axios.restore();
663 sinon.stub(communication, 'axios').resolves({
664 status: 200,
665 statusText: 'OK',
666 headers: {
667 'content-type': 'text/plain',
668 link: '<https://example.com/other/hub/>; rel="hub"',
669 },
670 data: 'Jackdaws love my big sphinx of quartz.',
671 });
672
673 await communication.topicFetchProcess(dbCtx, topicId, requestId);
674
675 assert(communication.db.topicFetchComplete.called);
676 assert(communication.db.topicDeleted.called);
677 });
678 }); // topicFetchProcess
679
680 describe('subscriptionDeliveryProcess', function () {
681 let dbCtx, requestId, topic, topicId, subscription, subscriptionId;
682
683 beforeEach(function () {
684 dbCtx = {};
685 topic = {
686 url: 'https://example.com/topic/',
687 isDeleted: false,
688 contentHashAlgorithm: 'sha512',
689 content: 'Jackdaws love my big sphinx of quartz.',
690 };
691 requestId = '7d37ea20-4ef7-417e-a08d-c0ba71269ab1';
692 topicId = '234ec6fb-f1cd-4ac3-8ea9-29ed42ae0e21';
693 subscriptionId = 'c5e6a3ac-dab8-11eb-b758-0025905f714a';
694 subscription = {
695 topicId,
696 callback: 'https://example.com/callback/123',
697 secret: 'superdupersecret',
698 signatureAlgorithm: 'sha512',
699 };
700
701 sinon.stub(communication, 'axios').resolves({
702 status: 200,
703 statusText: 'OK',
704 headers: {
705 'content-type': 'text/plain',
706 },
707 data: 'Jackdaws love my big sphinx of quartz.',
708 });
709
710 communication.db.topicGetContentById.resolves(topic);
711 communication.db.subscriptionGetById.resolves(subscription);
712 });
713
714 it('requires subscription to exist', async function () {
715 communication.db.subscriptionGetById.restore();
716 sinon.stub(communication.db, 'subscriptionGetById').resolves();
717 try {
718 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
719 assert.fail(noExpectedException);
720 } catch (e) {
721 assert(e instanceof Errors.InternalInconsistencyError);
722 }
723 });
724
725 it('requires topic to exist', async function () {
726 communication.db.topicGetContentById.restore();
727 sinon.stub(communication.db, 'topicGetContentById').resolves();
728 try {
729 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
730 assert.fail(noExpectedException);
731 } catch (e) {
732 assert(e instanceof Errors.InternalInconsistencyError);
733 }
734 });
735
736 it('succeeds', async function () {
737 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
738
739 assert(communication.db.subscriptionDeliveryComplete.called);
740 });
741
742 it('handles request error', async function () {
743 communication.axios.restore();
744 sinon.stub(communication, 'axios').throws();
745
746 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
747
748 assert(communication.db.subscriptionDeliveryIncomplete.called);
749 });
750
751 it('handles 5xx response', async function () {
752 communication.axios.restore();
753 sinon.stub(communication, 'axios').resolves({
754 status: 500,
755 statusText: 'Internal Server Error',
756 headers: {
757 'content-type': 'text/plain',
758 },
759 });
760
761 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
762
763 assert(communication.db.subscriptionDeliveryIncomplete.called);
764 });
765
766 it('handles 4xx response', async function () {
767 communication.axios.restore();
768 sinon.stub(communication, 'axios').resolves({
769 status: 404,
770 statusText: 'Not Found',
771 headers: {
772 'content-type': 'text/plain',
773 },
774 });
775
776 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
777
778 assert(communication.db.subscriptionDeliveryIncomplete.called);
779 });
780
781 it('handles 410 response', async function () {
782 communication.axios.restore();
783 sinon.stub(communication, 'axios').resolves({
784 status: 410,
785 statusText: 'Gone',
786 headers: {
787 'content-type': 'text/plain',
788 },
789 });
790
791 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
792
793 assert(communication.db.subscriptionDeliveryGone.called);
794 });
795
796 it('unsubscribes when topic is deleted', async function () {
797 topic.isDeleted = true;
798 communication.db.topicGetContentById.restore();
799 sinon.stub(communication.db, 'topicGetContentById').resolves(topic);
800
801 await communication.subscriptionDeliveryProcess(dbCtx, subscriptionId, requestId);
802
803 assert(communication.db.verificationInsert.called);
804 assert(communication.db.subscriptionDeliveryComplete.called);
805 });
806 }); // subscriptionDeliveryProcess
807
808 describe('topicFetchClaimAndProcessById', function () {
809 let dbCtx, topicId, requestId;
810 beforeEach(function () {
811 dbCtx = {};
812 requestId = '7d37ea20-4ef7-417e-a08d-c0ba71269ab1';
813 topicId = '234ec6fb-f1cd-4ac3-8ea9-29ed42ae0e21';
814 sinon.stub(communication, 'topicFetchProcess');
815 });
816 it('covers claim', async function () {
817 communication.db.topicFetchClaimById.resolves({
818 changes: 1,
819 })
820 await communication.topicFetchClaimAndProcessById(dbCtx, topicId, requestId);
821 assert(communication.topicFetchProcess.called);
822 });
823 it('covers no claim', async function () {
824 communication.db.topicFetchClaimById.resolves({
825 changes: 0,
826 })
827 await communication.topicFetchClaimAndProcessById(dbCtx, topicId, requestId);
828 assert(!communication.topicFetchProcess.called);
829 });
830 }); // topicFetchClaimAndProcessById
831
832 describe('verificationClaimAndProcessById', function () {
833 let dbCtx, verificationId, requestId;
834 beforeEach(function () {
835 dbCtx = {};
836 verificationId = '28488311-6652-42ea-9839-7bbc42b246cb';
837 requestId = '7d37ea20-4ef7-417e-a08d-c0ba71269ab1';
838 sinon.stub(communication, 'verificationProcess');
839 });
840 it('covers claim', async function () {
841 communication.db.verificationClaimById.resolves({
842 changes: 1,
843 })
844 await communication.verificationClaimAndProcessById(dbCtx, verificationId, requestId);
845 assert(communication.verificationProcess.called);
846 });
847 it('covers no claim', async function () {
848 communication.db.verificationClaimById.resolves({
849 changes: 0,
850 })
851 await communication.verificationClaimAndProcessById(dbCtx, verificationId, requestId);
852 assert(!communication.verificationProcess.called);
853 });
854 }); // verificationClaimAndProcessById
855
856 describe('workFeed', function () {
857 let stubCtx, wanted;
858 beforeEach(function () {
859 stubCtx = {};
860 sinon.stub(communication, 'topicFetchProcess');
861 sinon.stub(communication, 'verificationProcess');
862 sinon.stub(communication, 'subscriptionDeliveryProcess');
863 });
864 it('succeeds', async function () {
865 const topicIds = [ { id: '' }, { id: '' } ];
866 communication.db.topicFetchClaim.resolves(topicIds);
867 const verificationIds = [ { id: '' }, { id: '' } ];
868 communication.db.verificationClaim.resolves(verificationIds);
869 const subscriptionIds = [ { id: '' }, { id: '' } ];
870 communication.db.subscriptionDeliveryClaim.resolves(subscriptionIds);
871 const expectedLength = [topicIds, verificationIds, subscriptionIds].map((x) => x.length).reduce((a, b) => a + b, 0);
872 wanted = 10;
873
874 const result = await communication.workFeed(stubCtx, wanted);
875
876 assert.strictEqual(result.length, expectedLength);
877 });
878 it('covers no wanted work', async function () {
879 wanted = 0;
880 const result = await communication.workFeed(stubCtx, wanted);
881 assert.strictEqual(result.length, 0);
882 assert(!communication.db.topicFetchClaim.called);
883 assert(!communication.db.verificationClaim.called);
884 assert(!communication.db.subscriptionDeliveryClaim.called);
885 });
886 it('deals with failure', async function () {
887 const topicIds = [ { id: '' }, { id: '' } ];
888 communication.db.topicFetchClaim.resolves(topicIds);
889 communication.db.verificationClaim.throws();
890 const expectedLength = topicIds.length;
891 wanted = 10;
892
893 const result = await communication.workFeed(stubCtx, wanted);
894
895 assert.strictEqual(result.length, expectedLength);
896 });
897 }); // workFeed
898
899 }); // Communication