@nest-yalc-2/app 2.2.1 → 2.2.4

package/src/__tests__/app.events.spec.ts

@@ -1,12 +1,12 @@
-import { describe, expect, it } from '@jest/globals';
-import { AppEvents } from '../app.events.js';
-
-describe('AppEvents enum', () => {
-  it('should expose the expected event names', () => {
-    expect(AppEvents.BEFORE_ALL_ROUTES).toBe('app.before_all_routes');
-    expect(AppEvents.AFTER_ALL_ROUTES).toBe('app.after_all_routes');
-    expect(AppEvents.BEFORE_GQL_CONTEXT_MIDDLEWARE).toBe(
-      'app.before_gql_context_middleware',
-    );
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import { AppEvents } from '../app.events.js';
+
+describe('AppEvents enum', () => {
+  it('should expose the expected event names', () => {
+    expect(AppEvents.BEFORE_ALL_ROUTES).toBe('app.before_all_routes');
+    expect(AppEvents.AFTER_ALL_ROUTES).toBe('app.after_all_routes');
+    expect(AppEvents.BEFORE_GQL_CONTEXT_MIDDLEWARE).toBe(
+      'app.before_gql_context_middleware',
+    );
+  });
+});

package/src/__tests__/app.helper.spec.ts

@@ -1,204 +1,71 @@
-import { jest } from '@jest/globals';
-import '@nest-yalc-2/jest/common-mocks.helper.js';
-import { expect, describe, it, beforeEach, afterEach } from '@jest/globals';
-import { createMock, DeepMocked } from '@golevelup/ts-jest';
-import { DynamicModule, INestApplicationContext, Module } from '@nestjs/common';
-import { NestFactory } from '@nestjs/core';
-import { executeStandaloneFunction } from '../app.helper.js';
-import {
-  getBootstrappedApps,
-  getMainBootstrappedApp,
-} from '../app-bootstrap-base.helper.js';
-import { AppBootstrap } from '../app-bootstrap.helper.js';
-import { yalcBaseAppModuleMetadataFactory } from '../base-app-module.helper.js';
-
-@Module(
-  yalcBaseAppModuleMetadataFactory(TestModule1, 'test1', {
-    configFactory: () => ({}),
-    logger: true,
-  }),
-)
-class TestModule1 {}
-
-@Module(
-  yalcBaseAppModuleMetadataFactory(TestModule2, 'test2', {
-    configFactory: () => ({}),
-    logger: true,
-  }),
-)
-class TestModule2 {}
-
-@Module(
-  yalcBaseAppModuleMetadataFactory(BrokenModule, 'brokenModule', {
-    configFactory: () => ({}),
-    logger: true,
-    providers: [
-      {
-        provide: 'brokenService',
-        useFactory: () => {
-          throw new Error('Test');
-        },
-      },
-    ],
-  }),
-)
-class BrokenModule {}
-
-describe('test standalone app functions', () => {
-  let mockedModule: DeepMocked<DynamicModule>;
-  let mockedServiceFunction: jest.Mock<() => string>;
-
-  beforeEach(async () => {
-    jest.resetAllMocks();
-    mockedServiceFunction = jest.fn(() => 'Test');
-
-    mockedModule = createMock<DynamicModule>({
-      imports: [],
-    });
-
-    const mockedCreateApplicationContext = jest.spyOn(
-      NestFactory,
-      'createApplicationContext',
-    );
-
-    mockedCreateApplicationContext.mockImplementation(
-      () =>
-        createMock<INestApplicationContext>({
-          get: mockedServiceFunction,
-        }) as any,
-    );
-  });
-
-  afterEach(() => {
-    getBootstrappedApps().forEach((app) => app.closeApp());
-    getBootstrappedApps().clear();
-  });
-
-  it('should run executeStandaloneFunction', async () => {
-    const mockedFunction = jest.fn(async (service: any) => {
-      return service;
-    });
-
-    await executeStandaloneFunction(
-      mockedModule,
-      mockedServiceFunction,
-      mockedFunction,
-      {},
-      { closeApp: true },
-    );
-
-    expect(mockedFunction).toHaveBeenCalledTimes(1);
-  });
-
-  it('should run executeStandaloneFunction without close app', async () => {
-    const mockedFunction = jest.fn(async (service: any) => {
-      return service;
-    });
-
-    await executeStandaloneFunction(
-      mockedModule,
-      mockedServiceFunction,
-      mockedFunction,
-      {},
-    );
-
-    expect(mockedFunction).toHaveBeenCalledTimes(1);
-  });
-
-  it('should run executeStandaloneFunction with class module', async () => {
-    const mockedFunction = jest.fn(async (service: any) => {
-      return service;
-    });
-
-    class TestModule {
-      constructor() {}
-    }
-
-    await executeStandaloneFunction(
-      TestModule,
-      mockedServiceFunction,
-      mockedFunction,
-      {},
-    );
-
-    expect(mockedFunction).toHaveBeenCalledTimes(1);
-  });
-
-  it('should trigger an error if we bootstrap multiple servers', async () => {
-    await new AppBootstrap('test1', TestModule1).initApp();
-
-    let error: any = null;
-    try {
-      await new AppBootstrap('test2', TestModule2, {}).initApp();
-    } catch (e: any) {
-      // eslint-disable-next-line no-console
-      console.log(e);
-      error = e;
-    }
-
-    await expect(error).not.toBe(null);
-  });
-
-  it('should not trigger an error when the first app cannot be initialized because of an error', async () => {
-    try {
-      await new AppBootstrap('brokenModule', BrokenModule).initApp();
-    } catch (e: any) {
-      // nothing
-    }
-
-    let error: any = null;
-    try {
-      await new AppBootstrap('test2', TestModule2, {}).initApp();
-    } catch (e: any) {
-      // eslint-disable-next-line no-console
-      console.log(e);
-      error = e;
-    }
-
-    await expect(error).toBe(null);
-  });
-
-  it('should not trigger an error if we bootstrap multiple servers with the skip option', async () => {
-    await new AppBootstrap('test1', TestModule1, {
-      skipMultiServerCheck: true,
-    }).initApp();
-
-    let error: any = null;
-    try {
-      await new AppBootstrap('test2', TestModule2, {
-        skipMultiServerCheck: true,
-      }).initApp();
-    } catch (e: any) {
-      // eslint-disable-next-line no-console
-      console.log(e);
-      error = e;
-    }
-
-    await expect(error).toBe(null);
-  });
-
-  it('should not trigger an error if we bootstrap multiple servers with the env variable', async () => {
-    process.env.APP_SKIP_MULTISERVER_CHECK = 'true';
-
-    await new AppBootstrap('test1', TestModule1).initApp();
-
-    let error: any = null;
-    try {
-      await new AppBootstrap('test2', TestModule2).initApp();
-    } catch (e: any) {
-      // eslint-disable-next-line no-console
-      console.log(e);
-      error = e;
-    }
-
-    await expect(error).toBe(null);
-  });
-
-  it('should get the main bootstrapped app', async () => {
-    const app = await new AppBootstrap('test1', TestModule1).initApp();
-
-    const mainApp = getMainBootstrappedApp();
-
-    expect(mainApp === app).toBe(true);
-  });
-});
+import { describe, expect, it, jest, beforeEach } from '@jest/globals';
+import { StandaloneAppBootstrap } from '../app-bootstrap-standalone.helper.js';
+
+import {
+  executeFunctionForApp,
+  curriedExecuteStandaloneFunction,
+  executeStandaloneFunction,
+  isDynamicModule,
+} from '../app.helper.js';
+
+describe('app.helper', () => {
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.spyOn(StandaloneAppBootstrap.prototype, 'initApp').mockResolvedValue({
+      getApp: jest.fn().mockReturnValue({
+        init: jest.fn(),
+        resolve: jest.fn().mockResolvedValue({}),
+      }),
+    } as any);
+    jest.spyOn(StandaloneAppBootstrap.prototype, 'getApp').mockReturnValue({
+      init: jest.fn(),
+      resolve: jest.fn().mockResolvedValue({}),
+    } as any);
+    jest.spyOn(StandaloneAppBootstrap.prototype, 'closeApp').mockResolvedValue({} as any);
+  });
+
+  it('should evaluate isDynamicModule', () => {
+    expect(isDynamicModule({ module: {} })).toBe(true);
+    expect(isDynamicModule({})).toBe(false);
+  });
+
+  it('should execute function for app', async () => {
+    const mockApp = {
+      getApp: jest.fn().mockReturnValue({
+        init: jest.fn(),
+        resolve: jest.fn().mockResolvedValue({}),
+      } as any),
+      closeApp: jest.fn(),
+    };
+    
+    const mockFn = jest.fn().mockResolvedValue({});
+    
+    await executeFunctionForApp(mockApp as any, {}, mockFn as any, { closeApp: true });
+    
+    expect(mockApp.getApp).toHaveBeenCalled();
+    expect(mockFn).toHaveBeenCalled();
+    expect(mockApp.closeApp).toHaveBeenCalled();
+  });
+
+  it('should create curried function', async () => {
+    class DummyModule {}
+    const curried = await curriedExecuteStandaloneFunction(DummyModule, { skipMultiServerCheck: true } as any);
+    expect(typeof curried).toBe('function');
+  });
+
+  it('should create curried function with dynamic module', async () => {
+    const dynamicModule = { module: { name: 'DynamicDummy' } };
+    const curried = await curriedExecuteStandaloneFunction(dynamicModule, { skipMultiServerCheck: true } as any);
+    expect(typeof curried).toBe('function');
+  });
+
+  it('should execute standalone function', async () => {
+    class DummyModule {}
+    class DummyService {}
+    const mockFn = jest.fn().mockResolvedValue({});
+    
+    await executeStandaloneFunction(DummyModule, DummyService, mockFn, { skipMultiServerCheck: true } as any);
+    
+    expect(mockFn).toHaveBeenCalled();
+  });
+});