Jest Testing Resolvers with Typedi

[kicks321]

I'm a bit puzzled when it comes to unit testing a resolver that utilized injected dependencies. We are currently migrating and our API controllers share services with our GraphQL resolvers.

We have an issue where services are undefined. I've tried naming services by string identifiers ('NAME_SERVICE') then doing Container.set / Container.gets. Went through Ben Awads videos, but he doesn't touch on dependency injection.

We came to a wall with this question asked previously: typestack/typedi#329, that seemed to have been closed due to this not being supported by type-graphql. However, documentation/repository are keen on showing many of examples how to use dependency injection, but no tests around it.

Service

@Service()
class AppService {
    public findById = async (id: ID) => {
        return await queryApp({
            find: {
                id: id,
            },
        });
    };

    public findAll = async () => {
        return await queryApps();
    };
}

Resolver

@Service()
@Resolver(Application)
class AppResolver {
    constructor(private readonly _appService: AppService) {}

    // Queries
    @Query(() => Application)
    public async app(@Arg('id', () => ID) id: string): Promise<Application | null> {
        return await this._appService.findById(id);
    }

    @Query(() => [Application])
    public async apps(): Promise<Application[]> {
        return await this._appService.findAll();
    }
}

Test
This is states that the appservice is undefined

test('Test: app should return app found by id or null', async () => {
        // Mock the gql call
        const response = await mockGql({
            source: appQuery,
            resolvers: [AppResolver],
            variableValues: {
                appId: 1,
            },
        });

        expect(response).toBeDefined();

        return;
    });`

[kicks321]

Actually, I figured it out.

So there's two sets of test you have going on. Unit / Integration.

For Unit testing, you want to test the raw "non-containerized" approach. Bascially just raw ES6. You create a mock version of your service class and just pass it as an instance directly to the constructor.

// Mocks
jest.spyOn(MockService.prototype, 'myFunction').mockReturnValue(() => Promise.resolve({ // Your mock object with Faker or something goes here }))

// Set-up
const mockService = new MockService();
const resolver = new Resolver(mockService);

// Then run your test like so
await resolver.runSomething() ==> this function basically calls your mocked function from the mock Service

For Integration testing, (actual GraphQL testing), this is where when you build your schema, you just inject your container into your executable schema fixture at bootstrap time of test. so like, beforeAll or something.

For integration, in your test file, you need to drop

import { Container } from 'typedi'; // At top of test file

// In your async test
await buildSchema({
 resolvers: [myResolver],
 container: Container
))