git.r.bdr.sh - rbdr/forum/blame_incremental - src/lib/stores/forums.test.ts

import { GraphQLInteraction, Pact, Matchers } from '@pact-foundation/pact';
import { resolve } from 'path';

import { resolveAfter } from '$lib/utils/resolve_after';

const { eachLike, like } = Matchers;

jest.mock('$lib/config/config.ts');

import { getForum, getForums } from './forums';

const internals = {
	provider: null
};

describe('Forums store pact', () => {
	beforeAll(async () => {
		internals.provider = new Pact({
			port: 1234,
			dir: resolve(process.cwd(), 'pacts'),
			consumer: 'ForumClient',
			provider: 'ForumServer',
			pactfileWriteMode: 'update'
		});

		await internals.provider.setup();
	});

	afterEach(() => internals.provider.verify());
	afterAll(() => internals.provider.finalize());

	describe("When there's data", () => {
		describe('GetForums', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's data")
					.uponReceiving('a request to list the forums')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForums')
					.withQuery(
						`query GetForums {
              forums {
                id
                glyph
                label
                position
                __typename
              }
            }`
					)
					.withVariables({})
					.willRespondWith({
						status: 200,
						headers: {
							'Content-Type': 'application/json; charset=utf-8'
						},
						body: {
							data: {
								forums: eachLike({
									id: like('butter'),
									glyph: like('⌘'),
									label: like('test_forums.butter'),
									position: like(1)
								})
							}
						}
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the forums', async () => {
				const forums = getForums();
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forums.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBeInstanceOf(Array);
				expect(response.data.length).toBe(0);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data).toEqual(
					expect.arrayContaining([
						{
							id: 'butter',
							glyph: '⌘',
							label: 'test_forums.butter',
							position: 1
						}
					])
				);
				expect(response.loading).toBe(false);
				expect(response.error).toBe(undefined);
			});
		});

		describe('GetForum', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's data")
					.uponReceiving('a request to get a single forum')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForum')
					.withQuery(
						`query GetForum($id: ID!) {
              forum(id: $id) {
                id
                glyph
                label
                position
                topics {
                  id
                  title
                  updated_at
                  ttl
                  __typename
                }
                __typename
              }
            }`
					)
					.withVariables({
						id: 'freezer'
					})
					.willRespondWith({
						status: 200,
						headers: {
							'Content-Type': 'application/json; charset=utf-8'
						},
						body: {
							data: {
								forum: like({
									id: 'freezer',
									glyph: like('✭'),
									label: like('test_forums.freezer'),
									position: like(3),
									topics: eachLike({
										id: like('629de02c-151a-4db7-bb86-43b2add8a15a'),
										title: like('Very pacty topic'),
										updated_at: like(1619954611616),
										ttl: like(3601)
									})
								})
							}
						}
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the forum', async () => {
				const forum = getForum('freezer');
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forum.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBe(null);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data.id).toBe('freezer');
				expect(response.data.glyph).toBe('✭');
				expect(response.data.label).toBe('test_forums.freezer');
				expect(response.data.position).toBe(3);
				expect(response.data.topics).toEqual(
					expect.arrayContaining([
						{
							id: '629de02c-151a-4db7-bb86-43b2add8a15a',
							title: 'Very pacty topic',
							updated_at: 1619954611616,
							ttl: 3601
						}
					])
				);
				expect(response.loading).toBe(false);
				expect(response.error).toBe(undefined);
			});
		});
	});

	describe("When there's no data", () => {
		describe('GetForums', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's no data")
					.uponReceiving('a request to list the forums')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForums')
					.withQuery(
						`query GetForums {
              forums {
                id
                glyph
                label
                position
                __typename
              }
            }`
					)
					.withVariables({})
					.willRespondWith({
						status: 200,
						headers: {
							'Content-Type': 'application/json; charset=utf-8'
						},
						body: {
							data: {
								forums: []
							}
						}
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the forums', async () => {
				const forums = getForums();
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forums.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBeInstanceOf(Array);
				expect(response.data.length).toBe(0);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data).toBeInstanceOf(Array);
				expect(response.data.length).toBe(0);
				expect(response.loading).toBe(false);
				expect(response.error).toBe(undefined);
			});
		});

		describe('GetForum', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's no data")
					.uponReceiving('a request to get a single forum')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForum')
					.withQuery(
						`query GetForum($id: ID!) {
              forum(id: $id) {
                id
                glyph
                label
                position
                topics {
                  id
                  title
                  updated_at
                  ttl
                  __typename
                }
                __typename
              }
            }`
					)
					.withVariables({
						id: 'freezer'
					})
					.willRespondWith({
						status: 200,
						headers: {
							'Content-Type': 'application/json; charset=utf-8'
						},
						body: {
							data: {
								forum: null
							}
						}
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the forum', async () => {
				const forum = getForum('freezer');
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forum.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBe(null);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data).toBe(null);
				expect(response.loading).toBe(false);
				expect(response.error).toBe(undefined);
			});
		});
	});

	describe("When there's a server error", () => {
		describe('GetForums', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's a server error")
					.uponReceiving('a request to list the forums')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForums')
					.withQuery(
						`query GetForums {
              forums {
                id
                glyph
                label
                position
                __typename
              }
            }`
					)
					.withVariables({})
					.willRespondWith({
						status: 500
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the error', async () => {
				const forums = getForums();
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forums.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBeInstanceOf(Array);
				expect(response.data.length).toBe(0);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data).toBeInstanceOf(Array);
				expect(response.data.length).toBe(0);
				expect(response.loading).toBe(false);
				expect(response.error).toBeInstanceOf(Error);
			});
		});

		describe('GetForum', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's a server error")
					.uponReceiving('a request to get a single forum')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForum')
					.withQuery(
						`query GetForum($id: ID!) {
              forum(id: $id) {
                id
                glyph
                label
                position
                topics {
                  id
                  title
                  updated_at
                  ttl
                  __typename
                }
                __typename
              }
            }`
					)
					.withVariables({
						id: 'freezer'
					})
					.willRespondWith({
						status: 500
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the error', async () => {
				const forum = getForum('freezer');
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forum.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBe(null);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data).toBe(null);
				expect(response.loading).toBe(false);
				expect(response.error).toBeInstanceOf(Error);
			});
		});
	});

	describe("When there's an error in the response", () => {
		describe('GetForums', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's an error in the response")
					.uponReceiving('a request to list the forums')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForums')
					.withQuery(
						`query GetForums {
              forums {
                id
                glyph
                label
                position
                __typename
              }
            }`
					)
					.withVariables({})
					.willRespondWith({
						status: 200,
						headers: {
							'Content-Type': 'application/json; charset=utf-8'
						},
						body: {
							errors: eachLike({
								message: like('An error occurred when fetching forums')
							})
						}
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the error', async () => {
				const forums = getForums();
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forums.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBeInstanceOf(Array);
				expect(response.data.length).toBe(0);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data).toBeInstanceOf(Array);
				expect(response.data.length).toBe(0);
				expect(response.loading).toBe(false);
				expect(response.error.graphQLErrors).toEqual(
					expect.arrayContaining([
						{
							message: 'An error occurred when fetching forums'
						}
					])
				);
			});
		});

		describe('GetForum', () => {
			beforeAll(async () => {
				const forumQuery = new GraphQLInteraction()
					.given("there's an error in the response")
					.uponReceiving('a request to get a single forum')
					.withRequest({
						path: '/graphql',
						method: 'POST'
					})
					.withOperation('GetForum')
					.withQuery(
						`query GetForum($id: ID!) {
              forum(id: $id) {
                id
                glyph
                label
                position
                topics {
                  id
                  title
                  updated_at
                  ttl
                  __typename
                }
                __typename
              }
            }`
					)
					.withVariables({
						id: 'freezer'
					})
					.willRespondWith({
						status: 200,
						headers: {
							'Content-Type': 'application/json; charset=utf-8'
						},
						body: {
							errors: eachLike({
								message: like('An error occurred when fetching the forum')
							})
						}
					});
				return await internals.provider.addInteraction(forumQuery);
			});

			test('it returns the error', async () => {
				const forum = getForum('freezer');
				const { counter, promise: resolveAfterTwo } = resolveAfter(2);
				let response = null;
				forum.subscribe((forumsValue) => {
					response = forumsValue;
					counter();
				});
				expect(response.data).toBe(null);
				expect(response.loading).toBe(true);
				expect(response.error).toBe(undefined);
				await resolveAfterTwo;
				expect(response.data).toBe(null);
				expect(response.loading).toBe(false);
				expect(response.error.graphQLErrors).toEqual(
					expect.arrayContaining([
						{
							message: 'An error occurred when fetching the forum'
						}
					])
				);
			});
		});
	});
});
Commit	Line	Data
	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	});