Refactor files 61-70 in tests/resolvers/Mutation [Fixes #989]

tests/directives/authDirective.spec.ts

@@ -0,0 +1,175 @@
+import { AuthenticationDirective } from "../../src/directives/authDirective";
+import { beforeAll, afterAll, it, expect } from "vitest";
+import { connect, disconnect } from "../../src/db";
+import { ApolloServer, gql } from "apollo-server-express";
+import { errors } from "../../src/libraries";
+import "dotenv/config";
+import i18n from "i18n";
+import express from "express";
+import { appConfig } from "../../src/config";
+import { testUserType } from "../helpers/userAndOrg";
+import { createTestUserFunc } from "../helpers/user";
+
+const app = express();
+i18n.configure({
+  directory: `${__dirname}/locales`,
+  staticCatalog: {
+    en: require("../../locales/en.json"),
+    hi: require("../../locales/hi.json"),
+    zh: require("../../locales/zh.json"),
+    sp: require("../../locales/sp.json"),
+    fr: require("../../locales/fr.json"),
+  },
+  queryParameter: "lang",
+  defaultLocale: appConfig.defaultLocale,
+  locales: appConfig.supportedLocales,
+  autoReload: process.env.NODE_ENV !== "production",
+  updateFiles: process.env.NODE_ENV !== "production",
+  syncFiles: process.env.NODE_ENV !== "production",
+});
+app.use(i18n.init);
+
+let testUser: testUserType;
+
+const typeDefs = gql`
+  directive @auth on FIELD_DEFINITION
+
+  type Query {
+    hello: String @auth
+  }
+`;
+
+const resolvers = {
+  Query: {
+    hello: async () => "hi",
+  },
+};
+
+beforeAll(async () => {
+  await connect();
+  testUser = await createTestUserFunc();
+});
+
+afterAll(async () => {
+  await testUser!.remove();
+  await disconnect();
+});
+
+it("throws UnauthenticatedError when context is expired", async () => {
+  const query = `
+    query {
+      hello
+    }
+  `;
+  const authenticatedContext = {
+    expired: true,
+  };
+  const apolloServer = new ApolloServer({
+    typeDefs,
+    resolvers,
+    schemaDirectives: {
+      auth: AuthenticationDirective,
+    },
+    context: authenticatedContext,
+  });
+  apolloServer.applyMiddleware({
+    app,
+  });
+  try {
+    await apolloServer.executeOperation({
+      query,
+      variables: {},
+    });
+  } catch (err) {
+    if (err instanceof errors.UnauthenticatedError) {
+      expect(err.message).toEqual("user.notAuthenticated");
+    }
+  }
+});
+
+it("throws UnauthenticatedError when context: isAuth == false", async () => {
+  const query = `
+    query {
+      hello
+    }
+  `;
+  const authenticatedContext = {
+    isAuth: false,
+  };
+  const apolloServer = new ApolloServer({
+    typeDefs,
+    resolvers,
+    schemaDirectives: {
+      auth: AuthenticationDirective,
+    },
+    context: authenticatedContext,
+  });
+  apolloServer.applyMiddleware({
+    app,
+  });
+  try {
+    await apolloServer.executeOperation({
+      query,
+      variables: {},
+    });
+  } catch (err) {
+    if (err instanceof errors.UnauthenticatedError) {
+      expect(err.message).toEqual("user.notAuthenticated");
+    }
+  }
+});
+
+it("checks if the resolver is supplied, and return null data, if not", async () => {
+  const query = `
+      query {
+        hello
+      }
+    `;
+  const authenticatedContext = {
+    expired: true,
+    isAuth: false,
+  };
+  const apolloServer = new ApolloServer({
+    typeDefs,
+    schemaDirectives: {
+      auth: AuthenticationDirective,
+    },
+    context: authenticatedContext,
+  });
+  apolloServer.applyMiddleware({
+    app,
+  });
+  const result = await apolloServer.executeOperation({
+    query,
+    variables: {},
+  });
+  expect(result.data).toEqual({ hello: null });
+});
+
+it("returns data if isAuth == true and expire == false", async () => {
+  const query = `
+    query {
+      hello
+    }
+  `;
+  const authenticatedContext = {
+    expired: false,
+    isAuth: true,
+  };
+  const apolloServer = new ApolloServer({
+    typeDefs,
+    resolvers,
+    schemaDirectives: {
+      auth: AuthenticationDirective,
+    },
+    context: authenticatedContext,
+  });
+  apolloServer.applyMiddleware({
+    app,
+  });
+  const result = await apolloServer.executeOperation({
+    query,
+    variables: {},
+  });
+  expect(result.data).toEqual({ hello: "hi" });
+});

tests/helpers/eventsWithRegistrants.ts

@@ -10,9 +10,9 @@ export type testEventType =
   | (Interface_Event & Document<any, any, Interface_Event>)
   | null;
 
-export const createTestEventWithRegistrants = async (): Promise<
-  [testUserType, testOrganizationType, testEventType]
-> => {
+export const createTestEventWithRegistrants = async (
+  isAdmin = true
+): Promise<[testUserType, testOrganizationType, testEventType]> => {
   const resultsArray = await createTestUserAndOrganization();
   const testUser = resultsArray[0];
   const testOrganization = resultsArray[1];
@@ -42,7 +42,7 @@ export const createTestEventWithRegistrants = async (): Promise<
     },
     {
       $push: {
-        eventAdmin: testEvent._id,
+        eventAdmin: isAdmin ? testEvent._id : [],
         createdEvents: testEvent._id,
         registeredEvents: testEvent._id,
       },

tests/resolvers/Mutation/unregisterForEventByUser.spec.ts

@@ -1,12 +1,6 @@
 import "dotenv/config";
-import { Document, Types } from "mongoose";
-import {
-  Interface_User,
-  User,
-  Organization,
-  Event,
-  Interface_Event,
-} from "../../../src/models";
+import { Types } from "mongoose";
+import { User, Event } from "../../../src/models";
 import { MutationUnregisterForEventByUserArgs } from "../../../src/types/generatedGraphQLTypes";
 import { connect, disconnect } from "../../../src/db";
 import { unregisterForEventByUser as unregisterForEventByUserResolver } from "../../../src/resolvers/Mutation/unregisterForEventByUser";
@@ -15,65 +9,18 @@ import {
   USER_ALREADY_UNREGISTERED,
   USER_NOT_FOUND,
 } from "../../../src/constants";
-import { nanoid } from "nanoid";
 import { beforeAll, afterAll, describe, it, expect } from "vitest";
+import { testUserType } from "../../helpers/userAndOrg";
+import { createTestEvent, testEventType } from "../../helpers/events";
 
-let testUser: Interface_User & Document<any, any, Interface_User>;
-let testEvent: Interface_Event & Document<any, any, Interface_Event>;
+let testUser: testUserType;
+let testEvent: testEventType;
 
 beforeAll(async () => {
   await connect();
-
-  testUser = await User.create({
-    email: `email${nanoid().toLowerCase()}@gmail.com`,
-    password: "password",
-    firstName: "firstName",
-    lastName: "lastName",
-    appLanguageCode: "en",
-  });
-
-  const testOrganization = await Organization.create({
-    name: "name",
-    description: "description",
-    isPublic: true,
-    creator: testUser._id,
-    members: [testUser._id],
-    visibleInSearch: true,
-  });
-
-  await User.updateOne(
-    {
-      _id: testUser._id,
-    },
-    {
-      $set: {
-        createdOrganizations: [testOrganization._id],
-        joinedOrganizations: [testOrganization._id],
-      },
-    }
-  );
-
-  testEvent = await Event.create({
-    creator: testUser._id,
-    organization: testOrganization._id,
-    isRegisterable: true,
-    isPublic: true,
-    title: "title",
-    description: "description",
-    allDay: true,
-    startDate: new Date().toString(),
-  });
-
-  await User.updateOne(
-    {
-      _id: testUser._id,
-    },
-    {
-      $set: {
-        createdEvents: [testEvent._id],
-      },
-    }
-  );
+  const temp = await createTestEvent();
+  testUser = temp[0];
+  testEvent = temp[2];
 });
 
 afterAll(async () => {
@@ -104,7 +51,7 @@ describe("resolvers -> Mutation -> unregisterForEventByUser", () => {
       };
 
       const context = {
-        userId: testUser._id,
+        userId: testUser!._id,
       };
 
       await unregisterForEventByUserResolver?.({}, args, context);
@@ -117,11 +64,11 @@ describe("resolvers -> Mutation -> unregisterForEventByUser", () => {
   not a registrant of event with _id === args.id`, async () => {
     try {
       const args: MutationUnregisterForEventByUserArgs = {
-        id: testEvent._id,
+        id: testEvent!._id,
       };
 
       const context = {
-        userId: testUser._id,
+        userId: testUser!._id,
       };
 
       await unregisterForEventByUserResolver?.({}, args, context);
@@ -134,13 +81,13 @@ describe("resolvers -> Mutation -> unregisterForEventByUser", () => {
   _id === args.id`, async () => {
     await Event.updateOne(
       {
-        _id: testEvent._id,
+        _id: testEvent!._id,
       },
       {
         $push: {
           registrants: {
-            userId: testUser._id,
-            user: testUser._id,
+            userId: testUser!._id,
+            user: testUser!._id,
             status: "ACTIVE",
           },
         },
@@ -149,28 +96,28 @@ describe("resolvers -> Mutation -> unregisterForEventByUser", () => {
 
     await User.updateOne(
       {
-        _id: testUser._id,
+        _id: testUser!._id,
       },
       {
         $push: {
-          registeredEvents: testEvent._id,
+          registeredEvents: testEvent!._id,
         },
       }
     );
 
     const args: MutationUnregisterForEventByUserArgs = {
-      id: testEvent._id,
+      id: testEvent!._id,
     };
 
     const context = {
-      userId: testUser._id,
+      userId: testUser!._id,
     };
 
     const unregisterForEventByUserPayload =
       await unregisterForEventByUserResolver?.({}, args, context);
 
     const testUnregisterForEventByUserPayload = await Event.findOne({
-      _id: testEvent._id,
+      _id: testEvent!._id,
     }).lean();
 
     expect(unregisterForEventByUserPayload).toEqual(
@@ -182,11 +129,11 @@ describe("resolvers -> Mutation -> unregisterForEventByUser", () => {
   already unregistered from the event with _id === args.id`, async () => {
     try {
       const args: MutationUnregisterForEventByUserArgs = {
-        id: testEvent._id,
+        id: testEvent!._id,
       };
 
       const context = {
-        userId: testUser._id,
+        userId: testUser!._id,
       };
 
       await unregisterForEventByUserResolver?.({}, args, context);