test: add tests for operators (exists, regex, nested operators)

Author: nodkz

src/__mocks__/userModel.ts

@@ -16,12 +16,12 @@ const UserSchema = new Schema(
 
     user: {
       type: Schema.Types.ObjectId,
-      ref: 'UserModel',
+      ref: 'User',
     },
 
     users: {
       type: [Schema.Types.ObjectId],
-      ref: 'UserModel',
+      ref: 'User',
     },
 
     n: {
@@ -144,6 +144,7 @@ export interface IUser extends Document {
   relocation?: boolean;
   contacts: {
     email: string;
+    skype?: string;
   };
 }
 

src/__tests__/github_issues/250-test.ts

@@ -0,0 +1,105 @@
+/* eslint-disable no-param-reassign */
+
+import { schemaComposer, graphql } from 'graphql-compose';
+import { composeWithMongoose } from '../../index';
+import { UserModel } from '../../__mocks__/userModel';
+
+beforeAll(async () => {
+  await UserModel.base.createConnection();
+  await UserModel.create({
+    name: 'AAAAA',
+    age: 10,
+    contacts: { email: '[email protected]' },
+  });
+  await UserModel.create({
+    name: 'BBBBB',
+    age: 20,
+    gender: 'male',
+    contacts: { email: '[email protected]', skype: 'aaa' },
+  });
+  await UserModel.create({
+    name: 'CCCCC',
+    age: 30,
+    contacts: { email: '[email protected]' },
+  });
+});
+afterAll(() => UserModel.base.disconnect());
+
+const UserTC = composeWithMongoose(UserModel);
+schemaComposer.Query.addFields({
+  findMany: UserTC.getResolver('findMany'),
+});
+const schema = schemaComposer.buildSchema();
+
+describe('issue #250 - Adds support for nested `_operators`, add `exists`, `regex` operators', () => {
+  it('check `exist` operator', async () => {
+    expect(
+      await graphql.graphql(
+        schema,
+        `query {
+          findMany(filter: { _operators: { gender: { exists: true } } }) {
+            name
+            gender
+          }
+        }`
+      )
+    ).toEqual({ data: { findMany: [{ gender: 'male', name: 'BBBBB' }] } });
+  });
+
+  it('check nested `exist` operator', async () => {
+    expect(
+      await graphql.graphql(
+        schema,
+        `query {
+          findMany(filter: { _operators: { contacts: { skype: { exists: true } } } }) {
+            name
+          }
+        }`
+      )
+    ).toEqual({ data: { findMany: [{ name: 'BBBBB' }] } });
+  });
+
+  it('check `regex` operator', async () => {
+    expect(
+      await graphql.graphql(
+        schema,
+        `query {
+          findMany(filter: { _operators: { name: { regex: "^AA|CC.*" } } }) {
+            name
+          }
+        }`
+      )
+    ).toEqual({ data: { findMany: [{ name: 'AAAAA' }, { name: 'CCCCC' }] } });
+  });
+
+  it('check nested `regex` operator', async () => {
+    expect(
+      await graphql.graphql(
+        schema,
+        `query {
+          findMany(filter: { _operators: { contacts: { email: { regex: "/3.COM/i" } } } }) {
+            name
+          }
+        }`
+      )
+    ).toEqual({ data: { findMany: [{ name: 'CCCCC' }] } });
+  });
+
+  it('check combined nested `regex` operator', async () => {
+    expect(
+      await graphql.graphql(
+        schema,
+        `query {
+          findMany(
+            filter: { OR: [
+              { _operators: { contacts: { email: { regex: "/3.COM/i" } } } },
+              { _operators: { contacts: { skype: { exists: true } } } }
+            ]}
+          ) {
+            name
+          }
+        }`
+      )
+    ).toEqual({ data: { findMany: [{ name: 'BBBBB' }, { name: 'CCCCC' }] } });
+  });
+});