Using with Next and ApolloClient

[dabaquita]

I am trying to follow this tutorial to establish integration tests on our web application. Our stack currently includes Nexus, Next, Apollo, Prisma, and PostgreSQL.

I am using ApolloClient in place of GraphQLClient from graphql-request, I opted to use ApolloClient instead, especially since our web application is server less.

This is currently what I have inside the helper.ts, and the ApolloClient does work when I execute mutations. However, after executing a mutation on ApolloClient and checking if the data persists through Prisma, I get a null value.

Did I do these adjustments correctly? I am definitely missing something if Prisma is not querying correctly. Maybe there is a disconnect here between ApolloClient and Prisma or ApolloClient and the database? Any help would be much appreciated.

All of the code is below.

helper.ts

function graphqlTestContext() {
 let serverInstance: ServerInfo | null = null;

 return {
 async before() {
 const rootUrl = getRootUrl();

 const httpLink = createHttpLink({
 uri: rootUrl + "api/graphql",
 credentials: "include",
 fetch
 });
 
 const client = new ApolloClient({
 // ssrMode: typeof window === "undefined",
 link: httpLink,
 cache: new InMemoryCache(),
 });

 return client;
 },
 async after() {
 serverInstance?.server.close()
 },
 }
}

function prismaTestContext() {
 const prismaBinary = join(__dirname, '../../', 'node_modules', '.bin', 'prisma');
 let schema = '';
 let databaseUrl = '';
 let prismaClient: null | PrismaClient = null;

 return {
 async before() {
 // Generate a unique schema identifier for this test context
 schema = `test_${nanoid()}`;
 // Generate the pg connection string for the test schema
 databaseUrl = `${process.env.ROOT_DB_URL}/testing?schema=${schema}`;

 // Set the required environment variable to contain the connection string
 // to our database test schema
 process.env.DATABASE_URL = databaseUrl;

 // Run the migrations to ensure our schema has the required structure
 execSync(`${prismaBinary} migrate dev`, {
 env: {
 ...process.env,
 DATABASE_URL: databaseUrl,
 },
 });

 // Construct a new Prisma Client connected to the generated Postgres schema
 prismaClient = new PrismaClient();

 return prismaClient;
 },
 async after() {
 // Drop the schema after the tests have completed
 const client = new Client({
 connectionString: databaseUrl,
 });
 await client.connect();
 await client.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
 await client.end();

 // Release the Prisma Client connection
 await prismaClient?.$disconnect();
 },
 }

User.int.test.ts

const ctx = createTestContext();

describe("User", () => {
 it("creates a new user with REGISTER_MUTATION", async () => {
 const userResult = await ctx.client.mutate({
 mutation: gql`
 mutation Register(
 $firstName: String!
 $lastName: String!
 $email: String!
 $password: String!
 ) {
 registerUser(
 firstName: $firstName
 lastName: $lastName
 email: $email
 password: $password
 ) {
 user {
 email
 firstName
 }
 }
 }
 `, 
 variables: {
 firstName: "FirstName",
 lastName: "LastName",
 email: "test@email.com",
 password: "password"
 }
 });

 expect(userResult).toMatchInlineSnapshot(`
Object {
 "data": Object {
 "registerUser": Object {
 "__typename": "UserLoginPayload",
 "user": Object {
 "__typename": "User",
 "email": "test@email.com",
 "firstName": "FirstName",
 },
 },
 },
}
`);
 });

 it("verifies that user persists", async () => {
 const persistedData = await ctx.prisma.user.findMany();

 expect(persistedData).toMatchInlineSnapshot(`Array []`);
 });
});