make test requiring db access pass

package.json

@@ -14,13 +14,18 @@
         "apollo-server": "^2.6.2",
         "graphql": "^14.3.1",
         "reflect-metadata": "^0.1.13",
-        "type-graphql": "^0.17.4"
+        "type-graphql": "^0.17.4",
+        "typeorm": "^0.2.18"
     },
     "devDependencies": {
+        "@types/faker": "^4.1.5",
         "@types/graphql": "^14.2.0",
         "@types/jest": "^24.0.13",
+        "@types/node": "^12.0.12",
         "class-transformer": "^0.2.3",
+        "faker": "^4.1.0",
         "jest": "^24.8.0",
+        "sqlite3": "^4.0.9",
         "ts-jest": "^24.0.2",
         "ts-node-dev": "^1.0.0-pre.39",
         "typescript": "^3.5.1"

src/modules/User.ts

@@ -1,7 +1,14 @@
+import "reflect-metadata";
 import { Field, ObjectType } from "type-graphql";
+import { BaseEntity, Column, Entity, PrimaryGeneratedColumn } from "typeorm";
 
 @ObjectType()
-export class User {
+@Entity()
+export class User extends BaseEntity {
+    @PrimaryGeneratedColumn()
+    id!: number 
+
     @Field()
-    id: string
+    @Column()
+    email: string = ""
 }

src/modules/User/UserResolver.spec.ts

@@ -1,22 +1,59 @@
+import faker from "faker";
+import { createConnection, getConnection } from "typeorm";
 import { callSchema } from "../../utils/callSchema";
+import { User } from "../User";
 
 const usersQuery = `
 query {
     users {
-        id
+        email
     }
 }`
 
-describe("user resolver", () => {
+beforeEach(() => {
-    it("should return an empty array when no users are created", async () => {
+    return createConnection({
-        const response = await callSchema({
+        type: "sqlite",
-            source: usersQuery,
+        database: ":memory:",
+        dropSchema: true,
+        entities: [User],
+        synchronize: true,
+        logging: false
+    });
+});
+
+afterEach(() => {
+    let conn = getConnection();
+    return conn.close();
+});
+
+describe("resolver of", () => {
+    describe("users query", () => {
+        it("should return an empty array when no users are created", async () => {
+            const response = await callSchema({
+                source: usersQuery,
+            })
+
+            expect(response).toMatchObject({
+                data: {
+                    users: [],
+                },
+            })
         })
 
-        expect(response).toMatchObject({
+        it("should return a populated array when an user is created", async () => {
-            data: {
+            const user = await User.create({
-                users: [],
+                email: faker.internet.email(),
-            },
+            }).save()
+
+            const response = await callSchema({
+                source: usersQuery,
+            })
+
+            expect(response).toMatchObject({
+                data: {
+                    users: [{ email: user.email }],
+                },
+            })
         })
     })
 })

src/modules/User/UserResolver.ts

@@ -1,13 +1,14 @@
 import "reflect-metadata";
 import { Query, Resolver } from "type-graphql";
+import { getRepository } from "typeorm";
 import { User } from "../User";
 
-@Resolver()
+@Resolver(of => User)
 export class UserResolver {
-    private usersCollection: User[] = []
 
     @Query(returns => [User])
     async users() {
-        return await this.usersCollection
+        const userRepository = getRepository(User)
+        return userRepository.find()
     }
 }

tsconfig.json

@@ -3,7 +3,15 @@
         "target": "es2016",
         "module": "commonjs",
         "lib": ["es2016", "esnext.asynciterable"],
+        "esModuleInterop": true,
+        // "allowSyntheticDefaultImports": true
         "experimentalDecorators": true,
-        "emitDecoratorMetadata": true
+        "emitDecoratorMetadata": true,
+        "strict": true,
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noUnusedLocals": true
+        // "noUnusedParameters": true,
     }
 }