tests: Expand helper for trace tests.

[abernix]

This one very important 115-line test:

apollo-server/packages/apollo-server-integration-testsuite/src/ApolloServer.ts

Lines 528 to 643 in c85c6d2

	it('validation > engine > extensions > formatError', async () => {
	const throwError = jest.fn(() => {
	throw new Error('nope');
	});
	const validationRule = jest.fn(() => {
	// formatError should be called after validation
	expect(formatError).not.toBeCalled();
	// extension should be called after validation
	expect(willSendResponseInExtension).not.toBeCalled();
	return true;
	});
	const willSendResponseInExtension = jest.fn();
	const formatError = jest.fn(error => {
	try {
	expect(error).toBeInstanceOf(Error);
	// extension should be called before formatError
	expect(willSendResponseInExtension).toHaveBeenCalledTimes(1);
	// validationRules should be called before formatError
	expect(validationRule).toHaveBeenCalledTimes(1);
	} finally {
	error.message = 'masked';
	return error;
	}
	});
	class Extension<TContext = any> extends GraphQLExtension {
	willSendResponse(o: {
	graphqlResponse: GraphQLResponse;
	context: TContext;
	}) {
	expect(o.graphqlResponse.errors.length).toEqual(1);
	// formatError should be called after extensions
	expect(formatError).not.toBeCalled();
	// validationRules should be called before extensions
	expect(validationRule).toHaveBeenCalledTimes(1);
	willSendResponseInExtension();
	}
	}
	let engineServerDidStart: Promise<void>;
	const didReceiveTrace = new Promise<ITrace>(resolve => {
	engineServerDidStart = startEngineServer({
	check: (req, res) => {
	const report = FullTracesReport.decode(req.body);
	const header = report.header;
	expect(header.schemaTag).toEqual('');
	expect(header.schemaHash).toBeDefined();
	const trace = Object.values(report.tracesPerQuery)[0].trace[0];
	resolve(trace);
	res.end();
	},
	});
	});
	await engineServerDidStart;
	const { url: uri } = await createApolloServer({
	typeDefs: gql`
	type Query {
	error: String
	}
	`,
	resolvers: {
	Query: {
	error: () => {
	throwError();
	},
	},
	},
	validationRules: [validationRule],
	extensions: [() => new Extension()],
	engine: {
	endpointUrl: `http://localhost:${
	(engineServer.address() as net.AddressInfo).port
	}`,
	apiKey: 'service:my-app:secret',
	maxUncompressedReportSize: 1,
	generateClientInfo: () => ({
	clientName: 'testing',
	clientReferenceId: '1234',
	clientVersion: 'v1.0.1',
	}),
	},
	formatError,
	debug: true,
	});
	const apolloFetch = createApolloFetch({ uri });
	const result = await apolloFetch({
	query: `{error}`,
	});
	expect(result.data).toEqual({
	error: null,
	});
	expect(result.errors).toBeDefined();
	expect(result.errors[0].message).toEqual('masked');
	expect(validationRule).toHaveBeenCalledTimes(1);
	expect(throwError).toHaveBeenCalledTimes(1);
	expect(formatError).toHaveBeenCalledTimes(1);
	expect(willSendResponseInExtension).toHaveBeenCalledTimes(1);
	const trace = await didReceiveTrace;
	expect(trace.clientReferenceId).toMatch(/1234/);
	expect(trace.clientName).toMatch(/testing/);
	expect(trace.clientVersion).toEqual('v1.0.1');
	expect(trace.root!.child![0].error![0].message).toMatch(/nope/);
	expect(trace.root!.child![0].error![0].message).not.toMatch(/masked/);
	});

...has grown to a point where it's a bit conflated. Rather than becoming a new test with a separate concern, it's been added to as we've continued to expand observability features.

When looking at #1639, I was tempted to do the same thing, but felt it was worth breaking out the test into various helpers for reusability in new (upcoming!) tests.

There are two main changes here:

• Rename the error field which is used amongst many of the tests to something more recognizable, particularly since error itself is a protobuf property which these tests exercise:

  apollo-server/packages/apollo-engine-reporting-protobuf/src/reports.proto

  Line 108 in a849cf9

  repeated Error error = 11;

  My poor brain was confused on more than one occasion by the presence of a error field within an error object, so I hope to spare those brain palpitations in the future.

• Turn the mock engine reporting server (meant to represent a server on the receiving side of apollo-engine-reporting) into a reusable, strongly-typed class: EngineMockServer.

As I noted in the commit message for 6e218ea, another take on this might have implemented nock, but that was a more substantial re-factor.