Allows resolvers to be used with mocks

[rdrey]

Previously mocks would overwrite any resolvers. Includes test. As discussed in ardatan/graphql-tools#53.

[apollo-cla]

@rdrey: Thank you for submitting a pull request! Before we can merge it, you'll need to sign the Meteor Contributor Agreement here: https://contribute.meteor.com/

[coveralls]

Coverage remained the same at 93.827% when pulling 2f5ced2 on rdrey:master into 2a4a419 on apollostack:master.

[rdrey]

Once this is merged we need to update http://docs.apollostack.com/apollo-server/tools.html#mocks

The first sentence could be:

If provided, mocks will mock the results of the GraphQL query for any resolve functions not defined on the schema.

[helfer]

Thanks, this looks good! I like the sentence you wrote, can you add that to the docs?

[sebastienbarre]

I'm having issue with this one (version 0.2). Or maybe I'm not understanding what it does correctly. Does it imply that I don't need to have all my resolvers defined, as long as they are mocked? Which would be great.
Right now, I'm getting an error from makeExecutableSchema if any resolver is missing:

Error: Resolve function missing for "Query.employee"

even though I intend on mocking it later on when calling addMockFunctionsToSchema.

My resolvers.js is more or less:

const resolvers = {
  // Query: {
  //   employee(_, args) {
  //     return Employee.find({ where: args });
  //   },
  // },
};

and my mock.js:

const mocks = {
  Query: () => ({
    employee: (root, args) => {
      return { first_name: args.first_name, last_name: args.last_name };
    },
  }),
  Employee: () => ({ first_name: () => casual.first_name, last_name: () => casual.last_name }),

Thanks guys

[sebastienbarre]

OK, after digging in the doc, it appears a few more options are needed when calling makeExecutableSchema beforehand, for this scenario to work:

const executableSchema = makeExecutableSchema({
  typeDefs: Schema,
  resolvers: Resolvers,
  allowUndefinedInResolve: true,
  resolverValidationOptions: {
    requireResolversForArgs: false,
    requireResolversForNonScalar: false,
  },
});
...
addMockFunctionsToSchema({
  schema: executableSchema,
  mocks: Mocks,
  preserveResolvers: true,
});

I can submit a PR to update the Mocking page accordingly, if needed. It's not entirely related to preserveResolvers but this seems to be the only way to add mocks using addMockFunctionsToSchema (and without mockServer). Otherwise makeExecutableSchema will always complain about missing resolvers (that are meant to be mocked). Am I missing something?

[rdrey]

You're using the lower-level functions manually. This PR was for apolloServer() specifically, which lets you mix resolvers and mocks. You're right that you need to set preserveResolvers: true, etc, if you chain the functions together yourself. :)

[sebastienbarre]

Sorry, I'm not sure I follow. I'm looking at both the docs for appolloServer setup, and the definition of apolloOptions, and I do not see how you can pass mocks there. It seems the constructor only accept an executable GraphQL schema, so my assumption is that makeExecutableSchema and addMockFunctionsToSchema always need to be called to make the schema executable and specify mocks. Correct? Is there a different way to create and mock the server, without calling the low-level functions manually?

[rdrey]

Ah sorry, I haven't had time to play with Apollo in a while.

When I sent this PR those setup methods didn't exist yet, I've been constructing apolloServer like this in the past:

const graphQLServer = express();

graphQLServer.use('/graphql', apolloServer({
  graphiql: true,
  pretty: true,
  schema: Schema,
  resolvers: Resolvers,
  //mocks: Mocks,
}));

stolen from http://docs.apollostack.com/graphql-tools/guide.html

When using that constructor the Schema doesn't need to be an executable Schema, it will take just the string version. (And allows you to mix resolvers & mocks.)

I haven't checked out the new constructors (Express, Connect, HAPI, Koa, etc) to see if they support this.

[sebastienbarre]

@rdrey thanks, I understand now. This is now done differently in 0.2.

[helfer]

@sebastienbarre Yes, Apollo Server 0.2 is quite different from 0.1 because it doesn't include graphql-tools any more. If the migration guide doesn't work as expected with mocking, a PR would be greatly appreciated!

[sebastienbarre]

@helfer thanks. I'm still playing around with Apollo, let me push something once I'm a bit more confident I know my way around :)

@rdrey @helfer There might be a bug in preserveResolvers or the way mocks override resolvers though...
Consider that schema:

type Employee {
  first_name: String
  last_name: String
  projects: [Project]
}
type Project {
  name: String
}
type Query {
  employee(first_name: String, last_name: String): Employee
}

and the resolvers:

const resolvers = {
  Query: {
    employee(_, args) {
      return Employee.find({ where: args });
    },
  },
}

where the Query.employee resolver returns a promise that queries a live MySQL database and return an object with the first_name and last_name properties BUT NOT any projects property yet.

Now consider that mock:

import casual from 'casual';
const mocks = {
  Employee: () => ({
    first_name: () => casual.first_name,
    last_name: () => casual.last_name,
    projects: () => [{ name: 'foo' }, { name: 'bar' }],
  }),
  Project: () => ({
    name: casual.title,
  }),
};

if you query:

employee(first_name:"Sebastien") {
    first_name
    last_name
    projects {
      name
    }
  }
}

it will return:

{
  "data": {
    "employee": {
      "first_name": "Sebastien",
      "last_name": "Barre",
      "projects": [
        {
          "name": "Autem omnis officiis"
        },
        {
          "name": "Voluptas consequatur autem"
        }
      ]
    }
  }
}

Assuming the MySQL record for { first_name: 'Sebastien', last_name: 'Barre'} is in the database.

That does not seem correct though. What I'm trying to do here is: "OK, I've the correct MySQL resolver for the employee, but I haven't really nailed down how to return all the projects associated to an employee from the MySQL database, so I want to mock them instead".

However it seems that the mock Employee.projects is ignored. My assumption was that:

• once the Query.employee resolver was called, only the first_name and last_name fields were returned, not the projects field,
• therefore the server, knowing that Query.employee is supposed to return an Employee type, would look for the projects property in the Employee mock,
• which would have returned [{ name: 'foo' }, { name: 'bar' }].

I'm not sure why the Employee.projects mock is being ignored and why the Project mock is invoked instead, creating fake names for an array that always has 2 elements (I assume that's the mock framework picking that length). However, I want to control the number of elements and name in the array returned by Employee.projects...

Thanks
I realize this is more a graphql-tools issue though, to be found in mock.js

[helfer]

@sebastienbarre The mocks aren't always very intuitive to use, especially when mixed with real resolvers. What is happening in your case is that graphql-tools sees that Employee does not need to be mocked because it has a real resolve function. It thus never applies the Employees.project mock function. When the employee returned doesn't have a project, graphql-tools applies the Project mock function, in which you have defined name as casual.title.

If you wanted graphql-tools to apply the Employee.projects mock function that you have defined, you would have to submit a PR that does that (or as a first step, submit a PR with a failing test for your specific case). I don't think it would be too hard, but as it is currently implemented it doesn't do what you expect.

[sebastienbarre]

@helfer Thanks. The mocks are a great feature, thanks for all the good work. I'm pushing a PR with a failing test.