@nest-yalc-2/app 2.2.2 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-yalc-2/app",
-  "version": "2.2.2",
+  "version": "2.2.4",
   "type": "module",
   "description": "",
   "main": "./src/index.js",
@@ -16,13 +16,15 @@
     "src"
   ],
   "dependencies": {
-    "tslib": "^2.6.3"
+    "tslib": "^2.8.1"
   },
   "keywords": [
     "nestjs",
+    "nestjs-yalc",
     "yalc",
+    "app",
     "framework",
-    "app"
+    "utility"
   ],
   "repository": {
     "type": "git",

package/src/__tests__/app-bootstrap-base.helper.spec.ts

@@ -1,38 +1,86 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import { BaseAppBootstrap } from '../app-bootstrap-base.helper.js';
-
-class DummyModule {}
-
-class TestBootstrap extends BaseAppBootstrap<any> {
-  constructor() {
-    super('test-app', DummyModule as any, {
-      globalsOptions: { skipMultiServerCheck: true },
-    });
-  }
-}
-
-describe('BaseAppBootstrap', () => {
-  it('should monkey patch app init/close and update flags', async () => {
-    const bootstrap = new TestBootstrap();
-
-    const closeFn = jest.fn().mockResolvedValue(undefined);
-    const initFn = jest.fn().mockResolvedValue(undefined);
-
-    const fakeApp: any = {
-      close: closeFn,
-      init: initFn,
-      get: jest.fn(),
-      useLogger: jest.fn(),
-    };
-
-    bootstrap.setApp(fakeApp);
-
-    expect(bootstrap.isAppClosed()).toBe(false);
-    await fakeApp.init();
-    expect(bootstrap.isAppClosed()).toBe(false);
-
-    await bootstrap.closeApp();
-    expect(closeFn).toHaveBeenCalled();
-    expect(bootstrap.isAppClosed()).toBe(true);
-  });
-});
+import { describe, expect, it, jest } from '@jest/globals';
+import { BaseAppBootstrap } from '../app-bootstrap-base.helper.js';
+
+class DummyModule {}
+
+class TestBootstrap extends BaseAppBootstrap<any> {
+  constructor() {
+    super('test-app', DummyModule as any, {
+      globalsOptions: { skipMultiServerCheck: true },
+    });
+  }
+}
+
+describe('BaseAppBootstrap', () => {
+  it('should monkey patch app init/close and update flags', async () => {
+    const bootstrap = new TestBootstrap();
+
+    const closeFn = jest.fn().mockResolvedValue(undefined);
+    const initFn = jest.fn().mockResolvedValue(undefined);
+
+    const fakeApp: any = {
+      close: closeFn,
+      init: initFn,
+      get: jest.fn(),
+      useLogger: jest.fn(),
+    };
+
+    bootstrap.setApp(fakeApp);
+
+    expect(bootstrap.isAppClosed()).toBe(false);
+    await fakeApp.init();
+    expect(bootstrap.isAppClosed()).toBe(false);
+
+    await bootstrap.closeApp();
+    expect(closeFn).toHaveBeenCalled();
+    expect(bootstrap.isAppClosed()).toBe(true);
+  });
+
+  it('should getConf and getModule correctly', () => {
+    const bootstrap = new TestBootstrap();
+    const mockConfig = { get: jest.fn().mockReturnValue('mock-conf') };
+    const fakeApp: any = {
+      close: jest.fn(),
+      init: jest.fn(),
+      get: jest.fn().mockReturnValue(mockConfig),
+      useLogger: jest.fn(),
+    };
+    bootstrap.setApp(fakeApp);
+    
+    expect(bootstrap.getConf()).toEqual('mock-conf');
+    expect(bootstrap.getModule()).toBeDefined();
+    expect(mockConfig.get).toHaveBeenCalledWith('test-app');
+  });
+
+  it('should throw error when bootstrapping multiple servers without skip flag', () => {
+    // We already bootstrapped TestBootstrap in the previous tests.
+    // It is in getBootstrappedApps() unless we clear it.
+    // But since we want to trigger line 81, we can just instantiate another one without skip flag.
+    class TestBootstrapNoSkip extends BaseAppBootstrap<any> {
+      constructor() {
+        super('test-app-2', DummyModule as any, {
+          globalsOptions: { skipMultiServerCheck: false },
+        });
+      }
+    }
+    
+    // Set env to not skip
+    const oldEnv = process.env.APP_SKIP_MULTISERVER_CHECK;
+    process.env.APP_SKIP_MULTISERVER_CHECK = 'false';
+    
+    expect(() => new TestBootstrapNoSkip()).toThrow('You are trying to bootstrap multiple servers');
+    
+    process.env.APP_SKIP_MULTISERVER_CHECK = oldEnv;
+  });
+
+  it('getMainBootstrappedApp should return the first app', () => {
+    const { getMainBootstrappedApp } = require('../app-bootstrap-base.helper.js');
+    const mainApp = getMainBootstrappedApp();
+    expect(mainApp).toBeDefined();
+  });
+
+  it('should return bootstrapped apps', () => {
+    const apps = require('../app-bootstrap-base.helper.js').getBootstrappedApps();
+    expect(apps).toBeDefined();
+  });
+});

package/src/__tests__/app-bootstrap-standalone.helper.spec.ts

@@ -1,35 +1,35 @@
-import { describe, expect, it, jest, beforeEach } from '@jest/globals';
-import { StandaloneAppBootstrap } from '../app-bootstrap-standalone.helper.js';
-import { NestFactory } from '@nestjs/core';
-
-describe('StandaloneAppBootstrap', () => {
-  const logger = { log: jest.fn(), debug: jest.fn() };
-  const initMock = jest.fn().mockResolvedValue(undefined);
-  const fakeApp = {
-    init: initMock,
-    close: jest.fn().mockResolvedValue(undefined),
-    get: jest.fn().mockReturnValue(logger),
-    useLogger: jest.fn(),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest
-      .spyOn(NestFactory, 'createApplicationContext')
-      .mockResolvedValue(fakeApp as any);
-  });
-
-  it('should create application context and initialize', async () => {
-    const bootstrap = new StandaloneAppBootstrap(
-      'standalone',
-      class Dummy {},
-      { skipMultiServerCheck: true } as any,
-    );
-
-    await bootstrap.initApp();
-
-    expect(NestFactory.createApplicationContext).toHaveBeenCalled();
-    expect(initMock).toHaveBeenCalled();
-    expect(bootstrap.getApp()).toBe(fakeApp);
-  });
-});
+import { describe, expect, it, jest, beforeEach } from '@jest/globals';
+import { StandaloneAppBootstrap } from '../app-bootstrap-standalone.helper.js';
+import { NestFactory } from '@nestjs/core';
+
+describe('StandaloneAppBootstrap', () => {
+  const logger = { log: jest.fn(), debug: jest.fn() };
+  const initMock = jest.fn().mockResolvedValue(undefined);
+  const fakeApp = {
+    init: initMock,
+    close: jest.fn().mockResolvedValue(undefined),
+    get: jest.fn().mockReturnValue(logger),
+    useLogger: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest
+      .spyOn(NestFactory, 'createApplicationContext')
+      .mockResolvedValue(fakeApp as any);
+  });
+
+  it('should create application context and initialize', async () => {
+    const bootstrap = new StandaloneAppBootstrap(
+      'standalone',
+      class Dummy {},
+      { skipMultiServerCheck: true } as any,
+    );
+
+    await bootstrap.initApp();
+
+    expect(NestFactory.createApplicationContext).toHaveBeenCalled();
+    expect(initMock).toHaveBeenCalled();
+    expect(bootstrap.getApp()).toBe(fakeApp);
+  });
+});

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

@@ -1,98 +1,162 @@
-import { describe, expect, it, jest, beforeEach } from '@jest/globals';
-import '@nest-yalc-2/jest/common-mocks.helper.js';
-
-import { AppBootstrap } from '../app-bootstrap.helper.js';
-import { SYSTEM_LOGGER_SERVICE } from '../def.const.js';
-import { UnwrapResultInterceptor } from '../unwrap-result.interceptor.js';
-import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
-
-jest.mock('class-validator', () => ({
-  useContainer: jest.fn(),
-}));
-
-jest.mock('@fastify/cookie', () => jest.fn());
-
-describe('AppBootstrap.applyBootstrapGlobals', () => {
-  const logger = { log: jest.fn(), debug: jest.fn() };
-  const customFilter = { handle: jest.fn() };
-  const createDocumentMock = jest.fn().mockReturnValue({ doc: true });
-  const setupSwaggerMock = jest.fn();
-  const setTitleMock = jest.fn().mockReturnThis();
-  const setDescriptionMock = jest.fn().mockReturnThis();
-  const buildMock = jest.fn().mockReturnValue({ swagger: true });
-
-  const fakeApp = {
-    useGlobalPipes: jest.fn(),
-    setGlobalPrefix: jest.fn(),
-    register: jest.fn(),
-    useGlobalInterceptors: jest.fn(),
-    useGlobalFilters: jest.fn(),
-    useLogger: jest.fn(),
-    get: jest.fn().mockImplementation((token) =>
-      token === SYSTEM_LOGGER_SERVICE ? logger : undefined,
-    ),
-    select: jest.fn().mockReturnValue({}),
-  };
-
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    jest.clearAllMocks();
-    jest.spyOn(SwaggerModule, 'createDocument').mockImplementation((...args: any[]) =>
-      createDocumentMock(...args),
-    );
-    jest.spyOn(SwaggerModule, 'setup').mockImplementation((...args: any[]) =>
-      setupSwaggerMock(...args),
-    );
-    jest
-      .spyOn(DocumentBuilder.prototype, 'setTitle')
-      .mockImplementation(function (...args: any[]) {
-        setTitleMock(...args);
-        return this;
-      });
-    jest
-      .spyOn(DocumentBuilder.prototype, 'setDescription')
-      .mockImplementation(function (...args: any[]) {
-        setDescriptionMock(...args);
-        return this;
-      });
-    jest.spyOn(DocumentBuilder.prototype, 'build').mockImplementation((...args: any[]) =>
-      buildMock(...args),
-    );
-  });
-
-  it('should set up pipes, filters, interceptors and swagger', async () => {
-    const bootstrap = new AppBootstrap(
-      'app',
-      class Dummy {},
-      { skipMultiServerCheck: true } as any,
-    );
-
-    bootstrap['app'] = fakeApp as any;
-    bootstrap['loggerService'] = logger as any;
-    bootstrap.getConf = jest.fn().mockReturnValue({
-      apiPrefix: 'api',
-      host: 'localhost',
-      port: 3000,
-    }) as any;
-    bootstrap.getModule = jest.fn().mockReturnValue({}) as any;
-
-    await bootstrap.applyBootstrapGlobals({
-      enableSwagger: true,
-      apiPrefix: 'api',
-      filters: [customFilter as any],
-      validationPipeOptions: { transformOptions: { enableImplicitConversion: true } },
-    });
-
-    expect(fakeApp.useGlobalPipes).toHaveBeenCalled();
-    expect(fakeApp.setGlobalPrefix).toHaveBeenCalledWith('api');
-    expect(fakeApp.register).toHaveBeenCalled();
-    expect(fakeApp.useGlobalInterceptors).toHaveBeenCalledWith(
-      expect.any(UnwrapResultInterceptor),
-    );
-    expect(fakeApp.useGlobalFilters).toHaveBeenCalled();
-    expect(createDocumentMock).toHaveBeenCalled();
-    expect(setTitleMock).toHaveBeenCalled();
-    expect(setDescriptionMock).toHaveBeenCalled();
-    expect(setupSwaggerMock).toHaveBeenCalled();
-  });
-});
+import { describe, expect, it, jest, beforeEach } from '@jest/globals';
+import '@nest-yalc-2/jest/common-mocks.helper.js';
+
+import { AppBootstrap } from '../app-bootstrap.helper.js';
+import { SYSTEM_LOGGER_SERVICE } from '../def.const.js';
+import { UnwrapResultInterceptor } from '../unwrap-result.interceptor.js';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+
+jest.mock('class-validator', () => ({
+  useContainer: jest.fn(),
+}));
+
+jest.mock('@fastify/cookie', () => jest.fn());
+
+describe('AppBootstrap.applyBootstrapGlobals', () => {
+  const logger = { log: jest.fn(), debug: jest.fn() };
+  const customFilter = { handle: jest.fn() };
+  const createDocumentMock = jest.fn().mockReturnValue({ doc: true });
+  const setupSwaggerMock = jest.fn();
+  const setTitleMock = jest.fn().mockReturnThis();
+  const setDescriptionMock = jest.fn().mockReturnThis();
+  const buildMock = jest.fn().mockReturnValue({ swagger: true });
+
+  const fakeApp = {
+    useGlobalPipes: jest.fn(),
+    setGlobalPrefix: jest.fn(),
+    register: jest.fn(),
+    useGlobalInterceptors: jest.fn(),
+    useGlobalFilters: jest.fn(),
+    useLogger: jest.fn(),
+    get: jest.fn().mockImplementation((token) =>
+      token === SYSTEM_LOGGER_SERVICE ? logger : undefined,
+    ),
+    select: jest.fn().mockReturnValue({}),
+  };
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+    jest.spyOn(SwaggerModule, 'createDocument').mockImplementation((...args: any[]) =>
+      createDocumentMock(...args),
+    );
+    jest.spyOn(SwaggerModule, 'setup').mockImplementation((...args: any[]) =>
+      setupSwaggerMock(...args),
+    );
+    jest
+      .spyOn(DocumentBuilder.prototype, 'setTitle')
+      .mockImplementation(function (...args: any[]) {
+        setTitleMock(...args);
+        return this;
+      });
+    jest
+      .spyOn(DocumentBuilder.prototype, 'setDescription')
+      .mockImplementation(function (...args: any[]) {
+        setDescriptionMock(...args);
+        return this;
+      });
+    jest.spyOn(DocumentBuilder.prototype, 'build').mockImplementation((...args: any[]) =>
+      buildMock(...args),
+    );
+  });
+
+  it('should set up pipes, filters, interceptors and swagger', async () => {
+    const bootstrap = new AppBootstrap(
+      'app',
+      class Dummy {},
+      { skipMultiServerCheck: true } as any,
+    );
+
+    bootstrap['app'] = fakeApp as any;
+    bootstrap['loggerService'] = logger as any;
+    bootstrap.getConf = jest.fn().mockReturnValue({
+      apiPrefix: 'api',
+      host: 'localhost',
+      port: 3000,
+    }) as any;
+    bootstrap.getModule = jest.fn().mockReturnValue({}) as any;
+
+    await bootstrap.applyBootstrapGlobals({
+      enableSwagger: true,
+      apiPrefix: 'api',
+      filters: [customFilter as any],
+      validationPipeOptions: { transformOptions: { enableImplicitConversion: true } },
+    });
+
+    expect(fakeApp.useGlobalPipes).toHaveBeenCalled();
+    expect(fakeApp.setGlobalPrefix).toHaveBeenCalledWith('api');
+    expect(fakeApp.register).toHaveBeenCalled();
+    expect(fakeApp.useGlobalInterceptors).toHaveBeenCalledWith(
+      expect.any(UnwrapResultInterceptor),
+    );
+    expect(fakeApp.useGlobalFilters).toHaveBeenCalled();
+    expect(createDocumentMock).toHaveBeenCalled();
+    expect(setTitleMock).toHaveBeenCalled();
+    expect(setDescriptionMock).toHaveBeenCalled();
+    expect(setupSwaggerMock).toHaveBeenCalled();
+  });
+});
+
+describe('AppBootstrap - additional coverage', () => {
+  it('initApp should call createApp and initSetup', async () => {
+    const bootstrap = new AppBootstrap('app', class Dummy {}, { skipMultiServerCheck: true } as any);
+    bootstrap.createApp = jest.fn().mockResolvedValue(bootstrap as any);
+    bootstrap.initSetup = jest.fn().mockResolvedValue(bootstrap as any);
+    await bootstrap.initApp();
+    expect(bootstrap.createApp).toHaveBeenCalled();
+    expect(bootstrap.initSetup).toHaveBeenCalled();
+  });
+
+  it('initSetup should call applyBootstrapGlobals and init', async () => {
+    const bootstrap = new AppBootstrap('app', class Dummy {}, { skipMultiServerCheck: true } as any);
+    bootstrap.applyBootstrapGlobals = jest.fn();
+    const mockApp = { init: jest.fn() };
+    bootstrap.getApp = jest.fn().mockReturnValue(mockApp as any);
+    await bootstrap.initSetup();
+    expect(bootstrap.applyBootstrapGlobals).toHaveBeenCalled();
+    expect(mockApp.init).toHaveBeenCalled();
+  });
+
+  it('createApp should call NestFactory.create and setApp', async () => {
+    const bootstrap = new AppBootstrap('app', class Dummy {}, { skipMultiServerCheck: true } as any);
+    bootstrap.setApp = jest.fn().mockReturnValue(bootstrap as any);
+    const mockNestApp = {};
+    const NestFactory = require('@nestjs/core').NestFactory;
+    jest.spyOn(NestFactory, 'create').mockResolvedValue(mockNestApp as any);
+    await bootstrap.createApp();
+    expect(NestFactory.create).toHaveBeenCalled();
+    expect(bootstrap.setApp).toHaveBeenCalledWith(mockNestApp);
+  });
+
+  it('createApp should handle errors during createApp', async () => {
+    const bootstrap = new AppBootstrap('app', class Dummy {}, { skipMultiServerCheck: true } as any);
+    const NestFactory = require('@nestjs/core').NestFactory;
+    jest.spyOn(NestFactory, 'create').mockRejectedValue(new Error('test error') as never);
+    bootstrap.closeCleanup = jest.fn() as any;
+    // mock console.error
+    const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    await expect(bootstrap.createApp()).rejects.toThrow('Process aborted');
+    expect(bootstrap.closeCleanup).toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+});
+describe('AppBootstrap.applyBootstrapGlobals - no options', () => {
+  it('should handle undefined options', async () => {
+    const bootstrap = new AppBootstrap('app', class Dummy {}, { skipMultiServerCheck: true } as any);
+    const fakeApp = {
+      useGlobalPipes: jest.fn(),
+      setGlobalPrefix: jest.fn(),
+      register: jest.fn(),
+      useGlobalInterceptors: jest.fn(),
+      useGlobalFilters: jest.fn(),
+      get: jest.fn().mockReturnValue({ log: jest.fn(), debug: jest.fn() }),
+      useLogger: jest.fn(),
+      select: jest.fn().mockReturnValue({}),
+    };
+    bootstrap['app'] = fakeApp as any;
+    bootstrap.getConf = jest.fn().mockReturnValue({}) as any;
+    bootstrap.getModule = jest.fn().mockReturnValue({}) as any;
+    await bootstrap.applyBootstrapGlobals();
+    expect(fakeApp.useGlobalPipes).toHaveBeenCalled();
+  });
+});

package/src/__tests__/app-config.service.spec.ts

@@ -1,55 +1,55 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import { ConfigService } from '@nestjs/config';
-import {
-  AppConfigService,
-  createAppConfigProvider,
-  getAppConfigToken,
-  getAppEventToken,
-  getAppLoggerToken,
-} from '../app-config.service.js';
-
-describe('AppConfigService', () => {
-  it('should expose config values', () => {
-    const config = { appName: 'demo' };
-    const configService = {
-      get: jest.fn().mockReturnValue(config),
-    } as unknown as ConfigService;
-
-    const service = new AppConfigService(configService, 'demoAlias');
-
-    expect(service.values).toBe(config);
-    expect(service.get()).toBe(config);
-    expect(configService.get).toHaveBeenCalledWith('demoAlias');
-  });
-
-  it('should throw when config is missing', () => {
-    const configService = {
-      get: jest.fn().mockReturnValue(undefined),
-    } as unknown as ConfigService;
-
-    expect(() => new AppConfigService(configService, 'missing')).toThrow(
-      "AppConfigService: No config found for app alias 'missing'",
-    );
-  });
-});
-
-describe('AppConfigService tokens', () => {
-  it('should generate token names', () => {
-    expect(getAppConfigToken('alias')).toBe('aliasConfig');
-    expect(getAppEventToken('alias')).toBe('aliasEvent');
-    expect(getAppLoggerToken('alias')).toBe('aliasLogger');
-  });
-
-  it('should build a provider that resolves AppConfigService', () => {
-    const provider = createAppConfigProvider('alias');
-    const config = { foo: 'bar' };
-    const configService = { get: jest.fn().mockReturnValue(config) };
-
-    const instance = (provider as any).useFactory(
-      configService as ConfigService,
-    ) as AppConfigService;
-
-    expect(provider.inject).toEqual([ConfigService]);
-    expect(instance.values).toBe(config);
-  });
-});
+import { describe, expect, it, jest } from '@jest/globals';
+import { ConfigService } from '@nestjs/config';
+import {
+  AppConfigService,
+  createAppConfigProvider,
+  getAppConfigToken,
+  getAppEventToken,
+  getAppLoggerToken,
+} from '../app-config.service.js';
+
+describe('AppConfigService', () => {
+  it('should expose config values', () => {
+    const config = { appName: 'demo' };
+    const configService = {
+      get: jest.fn().mockReturnValue(config),
+    } as unknown as ConfigService;
+
+    const service = new AppConfigService(configService, 'demoAlias');
+
+    expect(service.values).toBe(config);
+    expect(service.get()).toBe(config);
+    expect(configService.get).toHaveBeenCalledWith('demoAlias');
+  });
+
+  it('should throw when config is missing', () => {
+    const configService = {
+      get: jest.fn().mockReturnValue(undefined),
+    } as unknown as ConfigService;
+
+    expect(() => new AppConfigService(configService, 'missing')).toThrow(
+      "AppConfigService: No config found for app alias 'missing'",
+    );
+  });
+});
+
+describe('AppConfigService tokens', () => {
+  it('should generate token names', () => {
+    expect(getAppConfigToken('alias')).toBe('aliasConfig');
+    expect(getAppEventToken('alias')).toBe('aliasEvent');
+    expect(getAppLoggerToken('alias')).toBe('aliasLogger');
+  });
+
+  it('should build a provider that resolves AppConfigService', () => {
+    const provider = createAppConfigProvider('alias');
+    const config = { foo: 'bar' };
+    const configService = { get: jest.fn().mockReturnValue(config) };
+
+    const instance = (provider as any).useFactory(
+      configService as ConfigService,
+    ) as AppConfigService;
+
+    expect(provider.inject).toEqual([ConfigService]);
+    expect(instance.values).toBe(config);
+  });
+});

package/src/__tests__/app-context.service.spec.ts

@@ -1,28 +1,28 @@
-import { describe, expect, it } from '@jest/globals';
-import {
-  GraphQLObjectType,
-  GraphQLSchema,
-  GraphQLString,
-} from 'graphql';
-import { AppContextService } from '../app-context.service.js';
-
-describe('AppContextService', () => {
-  it('should store initialized apps and schema', () => {
-    const service = new AppContextService();
-    service.initializedApps.add('app1');
-
-    const schema = new GraphQLSchema({
-      query: new GraphQLObjectType({
-        name: 'Query',
-        fields: {
-          hello: { type: GraphQLString },
-        },
-      }),
-    });
-
-    service.setSchema(schema);
-
-    expect(service.initializedApps.has('app1')).toBe(true);
-    expect(service.schema).toBe(schema);
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import {
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLString,
+} from 'graphql';
+import { AppContextService } from '../app-context.service.js';
+
+describe('AppContextService', () => {
+  it('should store initialized apps and schema', () => {
+    const service = new AppContextService();
+    service.initializedApps.add('app1');
+
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          hello: { type: GraphQLString },
+        },
+      }),
+    });
+
+    service.setSchema(schema);
+
+    expect(service.initializedApps.has('app1')).toBe(true);
+    expect(service.schema).toBe(schema);
+  });
+});