]> git.r.bdr.sh - rbdr/forum/blob - src/lib/stores/forums.test.ts
Apply formatting
[rbdr/forum] / src / lib / stores / forums.test.ts
1 import { GraphQLInteraction, Pact, Matchers } from '@pact-foundation/pact';
2 import { resolve } from 'path';
3
4 import { resolveAfter } from '$lib/utils/resolve_after';
5
6 const { eachLike, like } = Matchers;
7
8 jest.mock('$lib/config/config.ts');
9
10 import { getForum, getForums } from './forums';
11
12 const internals = {
13 provider: null
14 };
15
16 describe('Forums store pact', () => {
17 beforeAll(async () => {
18 internals.provider = new Pact({
19 port: 1234,
20 dir: resolve(process.cwd(), 'pacts'),
21 consumer: 'ForumClient',
22 provider: 'ForumServer',
23 pactfileWriteMode: 'update'
24 });
25
26 await internals.provider.setup();
27 });
28
29 afterEach(() => internals.provider.verify());
30 afterAll(() => internals.provider.finalize());
31
32 describe("When there's data", () => {
33 describe('GetForums', () => {
34 beforeAll(async () => {
35 const forumQuery = new GraphQLInteraction()
36 .given("there's data")
37 .uponReceiving('a request to list the forums')
38 .withRequest({
39 path: '/graphql',
40 method: 'POST'
41 })
42 .withOperation('GetForums')
43 .withQuery(
44 `query GetForums {
45 forums {
46 id
47 glyph
48 label
49 position
50 __typename
51 }
52 }`
53 )
54 .withVariables({})
55 .willRespondWith({
56 status: 200,
57 headers: {
58 'Content-Type': 'application/json; charset=utf-8'
59 },
60 body: {
61 data: {
62 forums: eachLike({
63 id: like('butter'),
64 glyph: like('⌘'),
65 label: like('test_forums.butter'),
66 position: like(1)
67 })
68 }
69 }
70 });
71 return await internals.provider.addInteraction(forumQuery);
72 });
73
74 test('it returns the forums', async () => {
75 const forums = getForums();
76 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
77 let response = null;
78 forums.subscribe((forumsValue) => {
79 response = forumsValue;
80 counter();
81 });
82 expect(response.data).toBeInstanceOf(Array);
83 expect(response.data.length).toBe(0);
84 expect(response.loading).toBe(true);
85 expect(response.error).toBe(undefined);
86 await resolveAfterTwo;
87 expect(response.data).toEqual(
88 expect.arrayContaining([
89 {
90 id: 'butter',
91 glyph: '⌘',
92 label: 'test_forums.butter',
93 position: 1
94 }
95 ])
96 );
97 expect(response.loading).toBe(false);
98 expect(response.error).toBe(undefined);
99 });
100 });
101
102 describe('GetForum', () => {
103 beforeAll(async () => {
104 const forumQuery = new GraphQLInteraction()
105 .given("there's data")
106 .uponReceiving('a request to get a single forum')
107 .withRequest({
108 path: '/graphql',
109 method: 'POST'
110 })
111 .withOperation('GetForum')
112 .withQuery(
113 `query GetForum($id: ID!) {
114 forum(id: $id) {
115 id
116 glyph
117 label
118 position
119 topics {
120 id
121 title
122 updated_at
123 ttl
124 __typename
125 }
126 __typename
127 }
128 }`
129 )
130 .withVariables({
131 id: 'freezer'
132 })
133 .willRespondWith({
134 status: 200,
135 headers: {
136 'Content-Type': 'application/json; charset=utf-8'
137 },
138 body: {
139 data: {
140 forum: like({
141 id: 'freezer',
142 glyph: like('✭'),
143 label: like('test_forums.freezer'),
144 position: like(3),
145 topics: eachLike({
146 id: like('629de02c-151a-4db7-bb86-43b2add8a15a'),
147 title: like('Very pacty topic'),
148 updated_at: like(1619954611616),
149 ttl: like(3601)
150 })
151 })
152 }
153 }
154 });
155 return await internals.provider.addInteraction(forumQuery);
156 });
157
158 test('it returns the forum', async () => {
159 const forum = getForum('freezer');
160 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
161 let response = null;
162 forum.subscribe((forumsValue) => {
163 response = forumsValue;
164 counter();
165 });
166 expect(response.data).toBe(null);
167 expect(response.loading).toBe(true);
168 expect(response.error).toBe(undefined);
169 await resolveAfterTwo;
170 expect(response.data.id).toBe('freezer');
171 expect(response.data.glyph).toBe('✭');
172 expect(response.data.label).toBe('test_forums.freezer');
173 expect(response.data.position).toBe(3);
174 expect(response.data.topics).toEqual(
175 expect.arrayContaining([
176 {
177 id: '629de02c-151a-4db7-bb86-43b2add8a15a',
178 title: 'Very pacty topic',
179 updated_at: 1619954611616,
180 ttl: 3601
181 }
182 ])
183 );
184 expect(response.loading).toBe(false);
185 expect(response.error).toBe(undefined);
186 });
187 });
188 });
189
190 describe("When there's no data", () => {
191 describe('GetForums', () => {
192 beforeAll(async () => {
193 const forumQuery = new GraphQLInteraction()
194 .given("there's no data")
195 .uponReceiving('a request to list the forums')
196 .withRequest({
197 path: '/graphql',
198 method: 'POST'
199 })
200 .withOperation('GetForums')
201 .withQuery(
202 `query GetForums {
203 forums {
204 id
205 glyph
206 label
207 position
208 __typename
209 }
210 }`
211 )
212 .withVariables({})
213 .willRespondWith({
214 status: 200,
215 headers: {
216 'Content-Type': 'application/json; charset=utf-8'
217 },
218 body: {
219 data: {
220 forums: []
221 }
222 }
223 });
224 return await internals.provider.addInteraction(forumQuery);
225 });
226
227 test('it returns the forums', async () => {
228 const forums = getForums();
229 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
230 let response = null;
231 forums.subscribe((forumsValue) => {
232 response = forumsValue;
233 counter();
234 });
235 expect(response.data).toBeInstanceOf(Array);
236 expect(response.data.length).toBe(0);
237 expect(response.loading).toBe(true);
238 expect(response.error).toBe(undefined);
239 await resolveAfterTwo;
240 expect(response.data).toBeInstanceOf(Array);
241 expect(response.data.length).toBe(0);
242 expect(response.loading).toBe(false);
243 expect(response.error).toBe(undefined);
244 });
245 });
246
247 describe('GetForum', () => {
248 beforeAll(async () => {
249 const forumQuery = new GraphQLInteraction()
250 .given("there's no data")
251 .uponReceiving('a request to get a single forum')
252 .withRequest({
253 path: '/graphql',
254 method: 'POST'
255 })
256 .withOperation('GetForum')
257 .withQuery(
258 `query GetForum($id: ID!) {
259 forum(id: $id) {
260 id
261 glyph
262 label
263 position
264 topics {
265 id
266 title
267 updated_at
268 ttl
269 __typename
270 }
271 __typename
272 }
273 }`
274 )
275 .withVariables({
276 id: 'freezer'
277 })
278 .willRespondWith({
279 status: 200,
280 headers: {
281 'Content-Type': 'application/json; charset=utf-8'
282 },
283 body: {
284 data: {
285 forum: null
286 }
287 }
288 });
289 return await internals.provider.addInteraction(forumQuery);
290 });
291
292 test('it returns the forum', async () => {
293 const forum = getForum('freezer');
294 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
295 let response = null;
296 forum.subscribe((forumsValue) => {
297 response = forumsValue;
298 counter();
299 });
300 expect(response.data).toBe(null);
301 expect(response.loading).toBe(true);
302 expect(response.error).toBe(undefined);
303 await resolveAfterTwo;
304 expect(response.data).toBe(null);
305 expect(response.loading).toBe(false);
306 expect(response.error).toBe(undefined);
307 });
308 });
309 });
310
311 describe("When there's a server error", () => {
312 describe('GetForums', () => {
313 beforeAll(async () => {
314 const forumQuery = new GraphQLInteraction()
315 .given("there's a server error")
316 .uponReceiving('a request to list the forums')
317 .withRequest({
318 path: '/graphql',
319 method: 'POST'
320 })
321 .withOperation('GetForums')
322 .withQuery(
323 `query GetForums {
324 forums {
325 id
326 glyph
327 label
328 position
329 __typename
330 }
331 }`
332 )
333 .withVariables({})
334 .willRespondWith({
335 status: 500
336 });
337 return await internals.provider.addInteraction(forumQuery);
338 });
339
340 test('it returns the error', async () => {
341 const forums = getForums();
342 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
343 let response = null;
344 forums.subscribe((forumsValue) => {
345 response = forumsValue;
346 counter();
347 });
348 expect(response.data).toBeInstanceOf(Array);
349 expect(response.data.length).toBe(0);
350 expect(response.loading).toBe(true);
351 expect(response.error).toBe(undefined);
352 await resolveAfterTwo;
353 expect(response.data).toBeInstanceOf(Array);
354 expect(response.data.length).toBe(0);
355 expect(response.loading).toBe(false);
356 expect(response.error).toBeInstanceOf(Error);
357 });
358 });
359
360 describe('GetForum', () => {
361 beforeAll(async () => {
362 const forumQuery = new GraphQLInteraction()
363 .given("there's a server error")
364 .uponReceiving('a request to get a single forum')
365 .withRequest({
366 path: '/graphql',
367 method: 'POST'
368 })
369 .withOperation('GetForum')
370 .withQuery(
371 `query GetForum($id: ID!) {
372 forum(id: $id) {
373 id
374 glyph
375 label
376 position
377 topics {
378 id
379 title
380 updated_at
381 ttl
382 __typename
383 }
384 __typename
385 }
386 }`
387 )
388 .withVariables({
389 id: 'freezer'
390 })
391 .willRespondWith({
392 status: 500
393 });
394 return await internals.provider.addInteraction(forumQuery);
395 });
396
397 test('it returns the error', async () => {
398 const forum = getForum('freezer');
399 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
400 let response = null;
401 forum.subscribe((forumsValue) => {
402 response = forumsValue;
403 counter();
404 });
405 expect(response.data).toBe(null);
406 expect(response.loading).toBe(true);
407 expect(response.error).toBe(undefined);
408 await resolveAfterTwo;
409 expect(response.data).toBe(null);
410 expect(response.loading).toBe(false);
411 expect(response.error).toBeInstanceOf(Error);
412 });
413 });
414 });
415
416 describe("When there's an error in the response", () => {
417 describe('GetForums', () => {
418 beforeAll(async () => {
419 const forumQuery = new GraphQLInteraction()
420 .given("there's an error in the response")
421 .uponReceiving('a request to list the forums')
422 .withRequest({
423 path: '/graphql',
424 method: 'POST'
425 })
426 .withOperation('GetForums')
427 .withQuery(
428 `query GetForums {
429 forums {
430 id
431 glyph
432 label
433 position
434 __typename
435 }
436 }`
437 )
438 .withVariables({})
439 .willRespondWith({
440 status: 200,
441 headers: {
442 'Content-Type': 'application/json; charset=utf-8'
443 },
444 body: {
445 errors: eachLike({
446 message: like('An error occurred when fetching forums')
447 })
448 }
449 });
450 return await internals.provider.addInteraction(forumQuery);
451 });
452
453 test('it returns the error', async () => {
454 const forums = getForums();
455 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
456 let response = null;
457 forums.subscribe((forumsValue) => {
458 response = forumsValue;
459 counter();
460 });
461 expect(response.data).toBeInstanceOf(Array);
462 expect(response.data.length).toBe(0);
463 expect(response.loading).toBe(true);
464 expect(response.error).toBe(undefined);
465 await resolveAfterTwo;
466 expect(response.data).toBeInstanceOf(Array);
467 expect(response.data.length).toBe(0);
468 expect(response.loading).toBe(false);
469 expect(response.error.graphQLErrors).toEqual(
470 expect.arrayContaining([
471 {
472 message: 'An error occurred when fetching forums'
473 }
474 ])
475 );
476 });
477 });
478
479 describe('GetForum', () => {
480 beforeAll(async () => {
481 const forumQuery = new GraphQLInteraction()
482 .given("there's an error in the response")
483 .uponReceiving('a request to get a single forum')
484 .withRequest({
485 path: '/graphql',
486 method: 'POST'
487 })
488 .withOperation('GetForum')
489 .withQuery(
490 `query GetForum($id: ID!) {
491 forum(id: $id) {
492 id
493 glyph
494 label
495 position
496 topics {
497 id
498 title
499 updated_at
500 ttl
501 __typename
502 }
503 __typename
504 }
505 }`
506 )
507 .withVariables({
508 id: 'freezer'
509 })
510 .willRespondWith({
511 status: 200,
512 headers: {
513 'Content-Type': 'application/json; charset=utf-8'
514 },
515 body: {
516 errors: eachLike({
517 message: like('An error occurred when fetching the forum')
518 })
519 }
520 });
521 return await internals.provider.addInteraction(forumQuery);
522 });
523
524 test('it returns the error', async () => {
525 const forum = getForum('freezer');
526 const { counter, promise: resolveAfterTwo } = resolveAfter(2);
527 let response = null;
528 forum.subscribe((forumsValue) => {
529 response = forumsValue;
530 counter();
531 });
532 expect(response.data).toBe(null);
533 expect(response.loading).toBe(true);
534 expect(response.error).toBe(undefined);
535 await resolveAfterTwo;
536 expect(response.data).toBe(null);
537 expect(response.loading).toBe(false);
538 expect(response.error.graphQLErrors).toEqual(
539 expect.arrayContaining([
540 {
541 message: 'An error occurred when fetching the forum'
542 }
543 ])
544 );
545 });
546 });
547 });
548 });