2018-05-23 23:09:17 -07:00
|
|
|
import { expect } from 'chai';
|
|
|
|
import 'mocha';
|
|
|
|
import * as express from 'express';
|
|
|
|
|
|
|
|
import * as request from 'request';
|
2018-05-29 15:58:52 -07:00
|
|
|
import * as FormData from 'form-data';
|
|
|
|
import * as fs from 'fs';
|
2018-05-29 21:37:38 -07:00
|
|
|
import fetch from 'node-fetch';
|
2018-05-23 23:09:17 -07:00
|
|
|
import { createApolloFetch } from 'apollo-fetch';
|
|
|
|
|
2018-05-30 22:40:27 -07:00
|
|
|
import { ApolloServerBase, AuthenticationError } from 'apollo-server-core';
|
2018-05-23 23:09:17 -07:00
|
|
|
import { registerServer } from './ApolloServer';
|
|
|
|
|
2018-05-24 14:26:53 -07:00
|
|
|
const gql = String.raw;
|
|
|
|
|
2018-05-23 23:09:17 -07:00
|
|
|
const typeDefs = gql`
|
|
|
|
type Query {
|
|
|
|
hello: String
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
|
|
|
|
const resolvers = {
|
|
|
|
Query: {
|
|
|
|
hello: () => 'hi',
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
describe('apollo-server-express', () => {
|
2018-05-24 14:26:53 -07:00
|
|
|
//to remove the circular dependency, we reference it directly
|
|
|
|
const ApolloServer = require('../../apollo-server/dist/index').ApolloServer;
|
2018-06-04 09:46:55 -07:00
|
|
|
let server: ApolloServerBase<express.Request>;
|
|
|
|
let app: express.Application;
|
|
|
|
|
|
|
|
afterEach(async () => {
|
|
|
|
if (server) await server.stop();
|
|
|
|
});
|
2018-05-24 14:26:53 -07:00
|
|
|
|
2018-05-23 23:09:17 -07:00
|
|
|
describe('', () => {
|
|
|
|
it('accepts typeDefs and resolvers', () => {
|
|
|
|
const app = express();
|
|
|
|
const server = new ApolloServer({ typeDefs, resolvers });
|
|
|
|
expect(() => registerServer({ app, server })).not.to.throw;
|
|
|
|
});
|
|
|
|
|
|
|
|
it('accepts typeDefs and mocks', () => {
|
|
|
|
const app = express();
|
|
|
|
const server = new ApolloServer({ typeDefs, resolvers });
|
|
|
|
expect(() => registerServer({ app, server })).not.to.throw;
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
describe('registerServer', () => {
|
|
|
|
it('can be queried', async () => {
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
|
|
|
|
registerServer({ app, server });
|
|
|
|
|
|
|
|
const { url: uri } = await server.listen();
|
|
|
|
const apolloFetch = createApolloFetch({ uri });
|
|
|
|
const result = await apolloFetch({ query: '{hello}' });
|
|
|
|
|
|
|
|
expect(result.data).to.deep.equal({ hello: 'hi' });
|
|
|
|
expect(result.errors, 'errors should exist').not.to.exist;
|
|
|
|
});
|
|
|
|
|
|
|
|
it('renders GraphQL playground when browser requests', async () => {
|
|
|
|
const nodeEnv = process.env.NODE_ENV;
|
|
|
|
delete process.env.NODE_ENV;
|
|
|
|
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
|
|
|
|
registerServer({ app, server });
|
|
|
|
|
|
|
|
const { url } = await server.listen();
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
request(
|
|
|
|
{
|
|
|
|
url,
|
|
|
|
method: 'GET',
|
|
|
|
headers: {
|
|
|
|
accept:
|
|
|
|
'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
|
|
|
|
},
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
process.env.NODE_ENV = nodeEnv;
|
|
|
|
if (error) {
|
|
|
|
reject(error);
|
|
|
|
} else {
|
|
|
|
expect(body).to.contain('GraphQLPlayground');
|
|
|
|
expect(response.statusCode).to.equal(200);
|
|
|
|
resolve();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
it('accepts cors configuration', async () => {
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
|
|
|
|
registerServer({ app, server, cors: { origin: 'apollographql.com' } });
|
|
|
|
|
|
|
|
const { url: uri } = await server.listen({});
|
|
|
|
|
|
|
|
const apolloFetch = createApolloFetch({ uri }).useAfter(
|
|
|
|
(response, next) => {
|
|
|
|
expect(
|
|
|
|
response.response.headers.get('access-control-allow-origin'),
|
|
|
|
).to.equal('apollographql.com');
|
|
|
|
next();
|
|
|
|
},
|
|
|
|
);
|
|
|
|
await apolloFetch({ query: '{hello}' });
|
|
|
|
});
|
|
|
|
|
|
|
|
it('accepts body parser configuration', async () => {
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
|
|
|
|
registerServer({ app, server, bodyParserConfig: { limit: 0 } });
|
|
|
|
|
|
|
|
const { url: uri } = await server.listen({});
|
|
|
|
|
|
|
|
const apolloFetch = createApolloFetch({ uri });
|
|
|
|
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
apolloFetch({ query: '{hello}' })
|
|
|
|
.then(reject)
|
|
|
|
.catch(error => {
|
|
|
|
expect(error.response).to.exist;
|
|
|
|
expect(error.response.status).to.equal(413);
|
|
|
|
expect(error.toString()).to.contain('Payload Too Large');
|
|
|
|
resolve();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
describe('healthchecks', () => {
|
2018-05-24 14:26:53 -07:00
|
|
|
let server: ApolloServerBase<express.Request>;
|
2018-05-23 23:09:17 -07:00
|
|
|
|
|
|
|
afterEach(async () => {
|
|
|
|
await server.stop();
|
|
|
|
});
|
|
|
|
|
|
|
|
it('creates a healthcheck endpoint', async () => {
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
|
|
|
|
registerServer({ app, server, bodyParserConfig: { limit: 0 } });
|
|
|
|
|
|
|
|
const { port } = await server.listen();
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
request(
|
|
|
|
{
|
|
|
|
url: `http://localhost:${port}/.well-known/apollo/server-health`,
|
|
|
|
method: 'GET',
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error) {
|
|
|
|
reject(error);
|
|
|
|
} else {
|
|
|
|
expect(body).to.equal(JSON.stringify({ status: 'pass' }));
|
|
|
|
expect(response.statusCode).to.equal(200);
|
|
|
|
resolve();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
it('provides a callback for the healthcheck', async () => {
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
|
|
|
|
registerServer({
|
|
|
|
app,
|
|
|
|
server,
|
|
|
|
onHealthCheck: async () => {
|
|
|
|
throw Error("can't connect to DB");
|
|
|
|
},
|
|
|
|
});
|
|
|
|
|
|
|
|
const { port } = await server.listen({});
|
|
|
|
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
request(
|
|
|
|
{
|
|
|
|
url: `http://localhost:${port}/.well-known/apollo/server-health`,
|
|
|
|
method: 'GET',
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error) {
|
|
|
|
reject(error);
|
|
|
|
} else {
|
|
|
|
expect(body).to.equal(JSON.stringify({ status: 'fail' }));
|
|
|
|
expect(response.statusCode).to.equal(503);
|
|
|
|
resolve();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
it('can disable the healthCheck', async () => {
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
registerServer({
|
|
|
|
app,
|
|
|
|
server,
|
|
|
|
disableHealthCheck: true,
|
|
|
|
});
|
|
|
|
|
|
|
|
const { port } = await server.listen({});
|
|
|
|
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
request(
|
|
|
|
{
|
|
|
|
url: `http://localhost:${port}/.well-known/apollo/server-health`,
|
|
|
|
method: 'GET',
|
|
|
|
},
|
2018-06-01 15:16:16 -07:00
|
|
|
(error, response) => {
|
2018-05-23 23:09:17 -07:00
|
|
|
if (error) {
|
|
|
|
reject(error);
|
|
|
|
} else {
|
|
|
|
expect(response.statusCode).to.equal(404);
|
|
|
|
resolve();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2018-05-29 15:58:52 -07:00
|
|
|
describe('file uploads', () => {
|
|
|
|
it('enabled uploads', async () => {
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs: gql`
|
|
|
|
type File {
|
|
|
|
filename: String!
|
|
|
|
mimetype: String!
|
|
|
|
encoding: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
type Query {
|
|
|
|
uploads: [File]
|
|
|
|
}
|
|
|
|
|
|
|
|
type Mutation {
|
|
|
|
singleUpload(file: Upload!): File!
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
resolvers: {
|
|
|
|
Query: {
|
2018-06-01 15:16:16 -07:00
|
|
|
uploads: () => {},
|
2018-05-29 15:58:52 -07:00
|
|
|
},
|
|
|
|
Mutation: {
|
2018-06-01 15:16:16 -07:00
|
|
|
singleUpload: async (_, args) => {
|
2018-05-29 15:58:52 -07:00
|
|
|
expect((await args.file).stream).to.exist;
|
|
|
|
return args.file;
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
});
|
|
|
|
app = express();
|
|
|
|
registerServer({
|
|
|
|
app,
|
|
|
|
server,
|
|
|
|
});
|
|
|
|
|
|
|
|
const { port } = await server.listen({});
|
|
|
|
|
|
|
|
const body = new FormData();
|
|
|
|
|
|
|
|
body.append(
|
|
|
|
'operations',
|
|
|
|
JSON.stringify({
|
|
|
|
query: gql`
|
|
|
|
mutation($file: Upload!) {
|
|
|
|
singleUpload(file: $file) {
|
|
|
|
filename
|
|
|
|
encoding
|
|
|
|
mimetype
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
variables: {
|
|
|
|
file: null,
|
|
|
|
},
|
|
|
|
}),
|
|
|
|
);
|
|
|
|
|
|
|
|
body.append('map', JSON.stringify({ 1: ['variables.file'] }));
|
|
|
|
body.append('1', fs.createReadStream('package.json'));
|
|
|
|
|
|
|
|
try {
|
|
|
|
const resolved = await fetch(`http://localhost:${port}/graphql`, {
|
|
|
|
method: 'POST',
|
|
|
|
body,
|
|
|
|
});
|
|
|
|
const response = await resolved.json();
|
|
|
|
|
|
|
|
expect(response.data.singleUpload).to.deep.equal({
|
|
|
|
filename: 'package.json',
|
|
|
|
encoding: '7bit',
|
|
|
|
mimetype: 'application/json',
|
|
|
|
});
|
|
|
|
} catch (error) {
|
|
|
|
// This error began appearing randomly and seems to be a dev dependency bug.
|
|
|
|
// https://github.com/jaydenseric/apollo-upload-server/blob/18ecdbc7a1f8b69ad51b4affbd986400033303d4/test.js#L39-L42
|
|
|
|
if (error.code !== 'EPIPE') throw error;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
2018-05-30 22:40:27 -07:00
|
|
|
|
|
|
|
describe('errors', () => {
|
|
|
|
it('returns thrown context error as a valid graphql result', async () => {
|
|
|
|
const nodeEnv = process.env.NODE_ENV;
|
|
|
|
delete process.env.NODE_ENV;
|
|
|
|
const typeDefs = gql`
|
|
|
|
type Query {
|
|
|
|
hello: String
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
const resolvers = {
|
|
|
|
Query: {
|
2018-06-01 15:16:16 -07:00
|
|
|
hello: () => {
|
2018-05-30 22:40:27 -07:00
|
|
|
throw Error('never get here');
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
2018-06-01 15:16:16 -07:00
|
|
|
context: () => {
|
2018-05-30 22:40:27 -07:00
|
|
|
throw new AuthenticationError('valid result');
|
|
|
|
},
|
|
|
|
});
|
|
|
|
|
|
|
|
app = express();
|
|
|
|
registerServer({ app, server });
|
|
|
|
|
|
|
|
const { url: uri } = await server.listen();
|
|
|
|
const apolloFetch = createApolloFetch({ uri });
|
|
|
|
|
|
|
|
const result = await apolloFetch({ query: '{hello}' });
|
|
|
|
expect(result.errors.length).to.equal(1);
|
|
|
|
expect(result.data).not.to.exist;
|
|
|
|
|
|
|
|
const e = result.errors[0];
|
|
|
|
expect(e.message).to.contain('valid result');
|
|
|
|
expect(e.extensions).to.exist;
|
|
|
|
expect(e.extensions.code).to.equal('UNAUTHENTICATED');
|
|
|
|
expect(e.extensions.exception.stacktrace).to.exist;
|
|
|
|
|
|
|
|
process.env.NODE_ENV = nodeEnv;
|
|
|
|
});
|
|
|
|
|
|
|
|
it('propogates error codes in dev mode', async () => {
|
|
|
|
const nodeEnv = process.env.NODE_ENV;
|
|
|
|
delete process.env.NODE_ENV;
|
|
|
|
|
2018-06-04 09:46:55 -07:00
|
|
|
server = new ApolloServer({
|
2018-05-30 22:40:27 -07:00
|
|
|
typeDefs: gql`
|
|
|
|
type Query {
|
|
|
|
error: String
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
resolvers: {
|
|
|
|
Query: {
|
|
|
|
error: () => {
|
|
|
|
throw new AuthenticationError('we the best music');
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
});
|
|
|
|
|
|
|
|
app = express();
|
|
|
|
registerServer({ app, server });
|
|
|
|
|
|
|
|
const { url: uri } = await server.listen();
|
|
|
|
const apolloFetch = createApolloFetch({ uri });
|
|
|
|
|
|
|
|
const result = await apolloFetch({ query: `{error}` });
|
|
|
|
expect(result.data).to.exist;
|
|
|
|
expect(result.data).to.deep.equal({ error: null });
|
|
|
|
|
|
|
|
expect(result.errors, 'errors should exist').to.exist;
|
|
|
|
expect(result.errors.length).to.equal(1);
|
|
|
|
expect(result.errors[0].extensions.code).to.equal('UNAUTHENTICATED');
|
|
|
|
expect(result.errors[0].extensions.exception).to.exist;
|
|
|
|
expect(result.errors[0].extensions.exception.stacktrace).to.exist;
|
|
|
|
|
|
|
|
process.env.NODE_ENV = nodeEnv;
|
|
|
|
});
|
|
|
|
|
|
|
|
it('propogates error codes in production', async () => {
|
|
|
|
const nodeEnv = process.env.NODE_ENV;
|
|
|
|
process.env.NODE_ENV = 'production';
|
|
|
|
|
|
|
|
server = new ApolloServer({
|
|
|
|
typeDefs: gql`
|
|
|
|
type Query {
|
|
|
|
error: String
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
resolvers: {
|
|
|
|
Query: {
|
|
|
|
error: () => {
|
|
|
|
throw new AuthenticationError('we the best music');
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
});
|
|
|
|
|
|
|
|
app = express();
|
|
|
|
registerServer({ app, server });
|
|
|
|
|
|
|
|
const { url: uri } = await server.listen();
|
|
|
|
const apolloFetch = createApolloFetch({ uri });
|
|
|
|
|
|
|
|
const result = await apolloFetch({ query: `{error}` });
|
|
|
|
expect(result.data).to.exist;
|
|
|
|
expect(result.data).to.deep.equal({ error: null });
|
|
|
|
|
|
|
|
expect(result.errors, 'errors should exist').to.exist;
|
|
|
|
expect(result.errors.length).to.equal(1);
|
|
|
|
expect(result.errors[0].extensions.code).to.equal('UNAUTHENTICATED');
|
|
|
|
expect(result.errors[0].extensions.exception).not.to.exist;
|
|
|
|
|
|
|
|
process.env.NODE_ENV = nodeEnv;
|
|
|
|
});
|
|
|
|
|
|
|
|
it('propogates error codes with null response in production', async () => {
|
|
|
|
const nodeEnv = process.env.NODE_ENV;
|
|
|
|
process.env.NODE_ENV = 'production';
|
|
|
|
|
2018-06-04 09:46:55 -07:00
|
|
|
server = new ApolloServer({
|
2018-05-30 22:40:27 -07:00
|
|
|
typeDefs: gql`
|
|
|
|
type Query {
|
|
|
|
error: String!
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
resolvers: {
|
|
|
|
Query: {
|
|
|
|
error: () => {
|
|
|
|
throw new AuthenticationError('we the best music');
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
});
|
|
|
|
|
|
|
|
app = express();
|
|
|
|
registerServer({ app, server });
|
|
|
|
|
|
|
|
const { url: uri } = await server.listen();
|
|
|
|
const apolloFetch = createApolloFetch({ uri });
|
|
|
|
|
|
|
|
const result = await apolloFetch({ query: `{error}` });
|
|
|
|
expect(result.data).null;
|
|
|
|
|
|
|
|
expect(result.errors, 'errors should exist').to.exist;
|
|
|
|
expect(result.errors.length).to.equal(1);
|
|
|
|
expect(result.errors[0].extensions.code).to.equal('UNAUTHENTICATED');
|
|
|
|
expect(result.errors[0].extensions.exception).not.to.exist;
|
|
|
|
|
|
|
|
process.env.NODE_ENV = nodeEnv;
|
|
|
|
});
|
|
|
|
});
|
2018-05-23 23:09:17 -07:00
|
|
|
});
|
|
|
|
});
|