test injected tokenised provider not loaded on constructor

[VictoriqueMoe]

I have no idea why this is happening or how to solve it.

consider thee following 3 injected deps:

export class RecordInfoSocket {
    public constructor(@Inject() private repo: FileRepo) {}
}

and the repo is:

@Service()
export class FileRepo {
    public constructor(@Inject() private fileDao: FileDao) {}
}

and finally the dao is:

@Injectable()
export class FileDao extends AbstractDao<FileUploadModel> {
    public constructor(@Inject(SQLITE_DATA_SOURCE) ds: DataSource) {
        super(ds, FileUploadModel);
    }
}

as you can see, in FileDao i use tokenised injection of SQLITE_DATA_SOURCE.

this works fine when starting the app as i do registerProvider:

registerProvider<DataSource>({
	provide: SQLITE_DATA_SOURCE,
	type: "typeorm:datasource",
	deps: [TsEdLogger],
	async useAsyncFactory(logger: TsEdLogger) {
		await dataSource.initialize();
		logger.info(`Connected with typeorm to database: ${dataSource.options.database}`);
		return dataSource;
	}
});

however, when i go to test the RecordInfoSocket class, i it will ALWAYS say that the SQLITE_DATA_SOURCE in FileDao is undefined.

I have tried this in my PlatformTest.create method:

const mockDS = {
	initialize: vi.fn(),
	getRepository: vi.fn(),
};

await PlatformTest.create({
	...settings,
	imports: [
		{
			token: SQLITE_DATA_SOURCE,
			use: mockDS,
		},
	],
	envs,
});

However, this doesn't work and the injected SQLITE_DATA_SOURCE token is still undefined.

I can't use PlatformTest.injector.addProvider because in order to do that,m the playform context needs to be created, and for that, FileDao needs to not fail, and it does.

For added context, the code actually fails in the constructor of AbstractDao that FileDao extends and passes it the repo.

export abstract class AbstractDao<T extends ObjectLiteral> {
    private readonly dao: Dao<T>;

    protected constructor(
        protected readonly ds: DataSource,
        model: EntityTarget<T>,
    ) {
        this.dao = ds.getRepository(model);
    }
    protected getRepository(transaction?: EntityManager): Dao<T> {
        return transaction ? transaction.getRepository(this.dao.target) : this.dao;
    }
}

tl;dr. how do i get tonekised SQLITE_DATA_SOURCE working in PlatformTest.create ?

[VictoriqueMoe]

it seems the solution is to use registerProvider just like i do in my server loader:

export async function platformCreate(settings?: Partial<TsED.Configuration>): Promise<void> {
    initDotEnv();
    const mockDS = {
        initialize: vi.fn(),
        getRepository: vi.fn(),
    };
    registerProvider<DataSource>({
        provide: SQLITE_DATA_SOURCE,
        type: "typeorm:datasource",
        useValue: mockDS,
    });
    await PlatformTest.create({
        ...settings,
        envs,
    });
}

it's odd, but it works. if this is intentinal or not

[VictoriqueMoe]

you can replicate this issue on my branch here: https://github.com/waifuvault/WaifuVault/tree/broken-di-test (broken-di-test)

all you need to is open src\services\__test__\unit\socket\RecordInfoSocket.spec.ts and run it. you will see it fails with the error:

Injection failed on FileDao
Origin: Cannot read properties of undefined (reading 'getRepository')

you can also see in src\__test__\testUtils.spec.ts where i set up PlatformTest.create

[Romakita]

did your PR actually fix anytthing or did you just try and reproduce the issue with a test?

It don’t fix something. It just try to repro your issue. But all of tests works as expected

[Romakita]

Ok got it.

because you declare the datasource connection only index.ts file this provider isn’t discovered by the DI when it create the container. Imports option doesn’t create necessary provider metadata because in a normal usage, the code import class and registered factory. At this steps all providers have his own metadata. Then the DI apply imports option to override existing provider metadata and finally the DI create instance based on these metadata.

it explain why I’m not able to repro your issue and why you need to use registerProvider before PlatformTest.create() call.

you can keep your solution or create a setup file for vitest and registerProvider with mocked instance. Or follows the tsed convention (aka declare the connection in separated file, import the connection provider each time an injectable class need it and use imports option on PlatformTest.create, when it’s necessary).
All solutions are fine ;)

See you

[VictoriqueMoe]

not sure i understand your message correctly, i expected the context that the platfomr test to be created would use the imported token, cos with or whtout it makes no difference, i need registerProvider.

I declare the datasource connection in index.ts yes, but that is the connection to the real datasource, NOT to the mocked one. here i create a new mocked Datasource and want to try import it, the injection needs to be done via a token. so i will keep what i have i guess then

[Romakita]

Ts.ED need at least the usage of @Injectable or registerProvider with his token to discover and create the Provider metadata. Example:

@Injectable() // create Provider Metadata
class MyClass {

}

// factory
registerProvider({
   provide: "MYTOKEN"   // create Provider Metadata,

   useFactory() {
     // real implementation
   }
})

When you test a code, you import always the real implementation and then you mock the implementation (Or you use vi.mock, jest.mock to mock the module).

In your case, the registerProvider({provide: 'SQL_LITE_DATASOURCE'}) isn't called because you have written that the index.ts - which isn't a good idea in my opinion. I never, prefer to write the provider in a separated file, test it and mock the module in test that consume this provider) -
so you can use the PlatformTest.create({imports:[]}) option.

// my_connection.ts -  at this step the provider metadata will exists
export const MY_CONNECTION = Symbol.for("MY_CONNECTION");
export type MY_CONNECTION = DataSource;

registerProvider({
   provide: "MY_CONNECTION",
   async useAsyncFactory() {
     // real implementation
     console.log('Hello I'm the real implementation
     const connection = await new Connection()

     return connection
   }
})

Then we use the Token provider in another injectable class:

import {MY_CONNECTION} from "./MyConnection";

@Injectable()
class MyRepository {
   @Inject(MY_CONNECTION)
   connection: MY_CONNECTION;

   getRepository() {
     return this.connection.getRepository("Model");
   }
}

The test:

import {MyRepository}  from "./MyRepository";
import {MY_CONNECTION} from "./MyConnection";

describe('MyRepository', () => {
    describe(() => PlatformTest.create({
       imports: [ 
         token: MY_CONNECTION,  // this option works only if registerProvider with the MY_CONNECTION is already called in the code
         use: { 
            getRepository: vi.fn()
         }
       ]
    }))

   it('should do something", () => {})
})

So the important things are:

• PlatformTest.create({imports:[]}) doesn't create Provider metadata. it's registerProvider(),
• imports options can be used to override existing Provider not to declare Provider before the container initialization (while PlatformTest.invoke create a new instance of the Provider from the loaded container and mock dependencies from the given option).

Note: @Injectable call registerProvider ;)

See you :)