fix(automapper.module.ts): fix test and core

Author: Chau Tran

src/automapper.module.ts

@@ -22,7 +22,7 @@ export class AutomapperModule {
     const mapper = new AutoMapper();
 
     options && options.config && mapper.initialize(options.config);
-    const providers = forRootProviders(options);
+    const providers = forRootProviders(mapper, options);
 
     return {
       module: AutomapperModule,
@@ -38,7 +38,7 @@ export class AutomapperModule {
    * @param {AutomapperModuleFeatureOptions} options
    */
   static forFeature(options: AutomapperModuleFeatureOptions): DynamicModule {
-    if (!options || (options && !options.profiles)) {
+    if (!options || (options && !options.profiles.length)) {
       const message = 'AutomapperModuleFeatureOptions.profiles is empty';
       this.logger.error(message);
       throw new Error(message);

src/automapper.provider.ts

@@ -8,9 +8,9 @@ import { getMapperToken } from './utils/getMapperToken';
 import { MAPPER_MAP, MapperMap } from './utils/mapperMap';
 
 export const forRootProviders = (
+  mapper: AutoMapper,
   options?: AutomapperModuleRootOptions
 ): Provider[] => {
-  const mapper = new AutoMapper();
   const token = getMapperToken(options ? options.name : '');
   !MapperMap.has(token) && MapperMap.set(token, mapper);
 

test/automapper.test.ts

@@ -34,12 +34,69 @@ class MockProfile extends MappingProfileBase {
 })
 class MockModule {}
 
+@Module({
+  imports: [
+    AutomapperModule.forRoot({
+      config: cfg => {
+        cfg.addProfile(new MockProfile());
+      },
+    }),
+  ],
+})
+class MockModuleWithConfig {}
+
 @Module({
   imports: [AutomapperModule.forFeature({ profiles: [new MockProfile()] })],
 })
 class MockSubModule {}
 
-describe('AutoMapper test', () => {
+describe('AutomapperModule - with config', () => {
+  let moduleFixture: TestingModule;
+  let mapper: AutoMapper;
+  let mapperMap: Map<string, AutoMapper>;
+
+  beforeAll(async () => {
+    moduleFixture = await Test.createTestingModule({
+      imports: [MockModuleWithConfig],
+    }).compile();
+    mapperMap = moduleFixture.get<Map<string, AutoMapper>>(MAPPER_MAP);
+    mapper = moduleFixture.get<AutoMapper>(getMapperToken());
+  });
+
+  afterAll(() => {
+    mapper.dispose();
+  });
+
+  it('AutomapperModule has been initialized with config', () => {
+    expect(mapperMap.size).toBeGreaterThan(0);
+    expect(mapper).toBeTruthy();
+    expect(JSON.stringify(mapper)).toEqual(
+      JSON.stringify(mapperMap.get(getMapperToken()))
+    );
+  });
+
+  it('AutomapperModule - map with config', () => {
+    const _mock = new Mock();
+    _mock.foo = 'baz';
+
+    const vm = mapper.map(_mock, MockVm);
+    expect(vm).toBeTruthy();
+    expect(vm.bar).toEqual(_mock.foo);
+    expect(vm).toBeInstanceOf(MockVm);
+  });
+
+  it('AutomapperModule - reverseMap with config', () => {
+    const _mockVm = new MockVm();
+    _mockVm.bar = 'should be foo';
+
+    const _mock = mapper.map(_mockVm, Mock);
+    expect(_mock).toBeTruthy();
+    expect(_mock).toBeInstanceOf(Mock);
+    expect(_mock.foo).toEqual(_mockVm.bar);
+  });
+});
+
+describe('AutoMapperModuke', () => {
   let moduleFixture: TestingModule;
   let mapper: AutoMapper;
   let mapperMap: Map<string, AutoMapper>;