Mocking dependency injection to test resolver

[akexinad]

I have this resolver. It's just a simple query which returns a sensitivity object or an error:

@Service()
@Resolver(Sensitivity)
export class SensitivityResolver {
    constructor(private readonly firestoreService: FirestoreService) {}

    @Query(() => SensitivityResponse, {
        nullable: true,
        description: "Returning a single financial sensitivity."
    })
    async sensitivity(
        @Arg("id", () => String, { description: "Sensitivity Id" }) id: string
    ): Promise<SensitivityResponse> {
        const data = await this.firestoreService.find(id);

        const { errors, sensitivity } = data;

        return {
            sensitivity,
            errors
        };
    }
}

And this service which uses Firestore and is injected into the above resolver. It has a constructor where I configure Firestore and a find method which returns an item from the db or an error:

@Service()
export class FirestoreService {
    service: FirebaseFirestore.CollectionReference<Sensitivity>;

    constructor() {
        const keyFile =
            process.env.GOOGLE_APPLICATION_CREDENTIALS || "./key/GCP-key.json";
        const projectId = process.env.PROJECTID || "elidev";
        const environment = process.env.ENVIRONMENT || "Development";
        const collection = `${environment}-Financial-v2`;

        const firestore = new Firestore({
            keyFile,
            projectId
        });

        this.service = firestore.collection(
            collection
        ) as FirebaseFirestore.CollectionReference<Sensitivity>;
    }

    find = async (id: string) => {
        try {
            const sensitivity = await this.service.doc(id).get();

            if (!sensitivity.data()) {
                return {
                    errors: "Sensitivity not found"
                };
            }

            return {
                sensitivity: sensitivity.data()
            };
        } catch (error) {
            return {
                errors: `SERVICE ERROR: ${error}`
            };
        }
    };
}

And this unit test for the Sensitivity query where I try to mock the above service:

jest.mock("../services/FirestoreService.ts", () => {
    return {
        find: jest.fn((id: string) => {
            return {
                id,
                hello: "world"
            };
        })
    };
});

describe("sensitivity resolver", () => {
    it("should return a sensitivity", async () => {
        const schema = await buildSchema({
            resolvers: [SensitivityResolver],
            container: Container
        });

        const sensitivityQuery = `
            query Sensitivity($id: String!) {
                sensitivity(id: $id) {
                    sensitivity {
                        id
                        name
                        type
                        createdDate
                        updatedDate
                    }
                    errors
                }
            }
        `;

        const sensitivityQueryVariables = {
            id: "18d4e473-4371-4168-bbaa-87ee20286173"
        };

        const response = await graphql({
            schema,
            source: sensitivityQuery,
            variableValues: sensitivityQueryVariables
        })
        console.log(`response`, response);
    });
});

When I run test I get:

 console.log
    response {
      errors: [
        TypeError: Cannot read property 'find' of undefined...

The FirestoreService instance is undefined.

Does anyone know how to correctly mock a dependency injection when using type-graphql?

[MichalLytek]

mock a dependency injection when using type-graphql?

This is a question for DI lib you're using. TypeGraphQL only calls Container.get, that's it. Nothing more on TypeGraphQL side.

Based on @Service() looks like you're using TypeDI. The whole purpose of DI container is to register mock inside it instead of mocking JS module by Jest.

[akexinad]

Thanks @MichalLytek ! I will ask over there.

This had me really stumped.