@backstage/backend-test-utils/dist/services/mockServices.cjs.js

Test helpers library for Backstage backends

'use strict';

var auditor = require('@backstage/backend-defaults/auditor');
var cache = require('@backstage/backend-defaults/cache');
var database = require('@backstage/backend-defaults/database');
var discovery = require('@backstage/backend-defaults/discovery');
var httpRouter = require('@backstage/backend-defaults/httpRouter');
var lifecycle = require('@backstage/backend-defaults/lifecycle');
var logger = require('@backstage/backend-defaults/logger');
var permissions = require('@backstage/backend-defaults/permissions');
var permissionsRegistry = require('@backstage/backend-defaults/permissionsRegistry');
var rootHealth = require('@backstage/backend-defaults/rootHealth');
var rootHttpRouter = require('@backstage/backend-defaults/rootHttpRouter');
var rootLifecycle = require('@backstage/backend-defaults/rootLifecycle');
var urlReader = require('@backstage/backend-defaults/urlReader');
var backendPluginApi = require('@backstage/backend-plugin-api');
var config = require('@backstage/config');
var pluginEventsNode = require('@backstage/plugin-events-node');
var MockAuthService = require('./MockAuthService.cjs.js');
var MockHttpAuthService = require('./MockHttpAuthService.cjs.js');
var MockRootLoggerService = require('./MockRootLoggerService.cjs.js');
var MockUserInfoService = require('./MockUserInfoService.cjs.js');
var mockCredentials = require('./mockCredentials.cjs.js');
var MockEventsService = require('./MockEventsService.cjs.js');
var MockPermissionsService = require('./MockPermissionsService.cjs.js');
var simpleMock = require('./simpleMock.cjs.js');
var MockSchedulerService = require('./MockSchedulerService.cjs.js');
var ObservableConfigProxy = require('../config-loader/src/sources/ObservableConfigProxy.cjs.js');

function createLoggerMock() {
  return {
    child: jest.fn().mockImplementation(createLoggerMock),
    debug: jest.fn(),
    error: jest.fn(),
    info: jest.fn(),
    warn: jest.fn()
  };
}
function simpleFactoryWithOptions(ref, factory) {
  const factoryWithOptions = (...options) => backendPluginApi.createServiceFactory({
    service: ref,
    deps: {},
    async factory() {
      return factory(...options);
    }
  });
  return Object.assign(
    factoryWithOptions,
    factoryWithOptions(...[void 0])
  );
}
exports.mockServices = void 0;
((mockServices2) => {
  function rootConfig(options) {
    const config$1 = ObservableConfigProxy.ObservableConfigProxy.create(new AbortController());
    config$1.setConfig(new config.ConfigReader(options?.data ?? {}, "mock-config"));
    return Object.assign(config$1, {
      update({ data }) {
        config$1.setConfig(new config.ConfigReader(data, "mock-config"));
      }
    });
  }
  mockServices2.rootConfig = rootConfig;
  ((rootConfig2) => {
    rootConfig2.factory = simpleFactoryWithOptions(
      backendPluginApi.coreServices.rootConfig,
      rootConfig2
    );
    rootConfig2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.rootConfig, () => ({
      get: jest.fn(),
      getBoolean: jest.fn(),
      getConfig: jest.fn(),
      getConfigArray: jest.fn(),
      getNumber: jest.fn(),
      getOptional: jest.fn(),
      getOptionalBoolean: jest.fn(),
      getOptionalConfig: jest.fn(),
      getOptionalConfigArray: jest.fn(),
      getOptionalNumber: jest.fn(),
      getOptionalString: jest.fn(),
      getOptionalStringArray: jest.fn(),
      getString: jest.fn(),
      getStringArray: jest.fn(),
      has: jest.fn(),
      keys: jest.fn()
    }));
  })(rootConfig = mockServices2.rootConfig || (mockServices2.rootConfig = {}));
  function rootLogger(options) {
    return MockRootLoggerService.MockRootLoggerService.create(options);
  }
  mockServices2.rootLogger = rootLogger;
  ((rootLogger2) => {
    rootLogger2.factory = simpleFactoryWithOptions(
      backendPluginApi.coreServices.rootLogger,
      rootLogger2
    );
    rootLogger2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.rootLogger, () => ({
      child: jest.fn(),
      debug: jest.fn(),
      error: jest.fn(),
      info: jest.fn(),
      warn: jest.fn()
    }));
  })(rootLogger = mockServices2.rootLogger || (mockServices2.rootLogger = {}));
  ((auditor2) => {
    auditor2.factory = () => auditor.auditorServiceFactory;
    auditor2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.auditor, () => ({
      createEvent: jest.fn(async (_) => {
        return {
          success: jest.fn(),
          fail: jest.fn()
        };
      })
    }));
  })(mockServices2.auditor || (mockServices2.auditor = {}));
  function auth(options) {
    return new MockAuthService.MockAuthService({
      pluginId: options?.pluginId ?? "test",
      disableDefaultAuthPolicy: Boolean(options?.disableDefaultAuthPolicy)
    });
  }
  mockServices2.auth = auth;
  ((auth2) => {
    auth2.factory = () => backendPluginApi.createServiceFactory({
      service: backendPluginApi.coreServices.auth,
      deps: {
        plugin: backendPluginApi.coreServices.pluginMetadata,
        config: backendPluginApi.coreServices.rootConfig
      },
      factory({ plugin, config }) {
        const disableDefaultAuthPolicy = Boolean(
          config.getOptionalBoolean(
            "backend.auth.dangerouslyDisableDefaultAuthPolicy"
          )
        );
        return new MockAuthService.MockAuthService({
          pluginId: plugin.getId(),
          disableDefaultAuthPolicy
        });
      }
    });
    auth2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.auth, () => ({
      authenticate: jest.fn(),
      getNoneCredentials: jest.fn(),
      getOwnServiceCredentials: jest.fn(),
      isPrincipal: jest.fn(),
      getPluginRequestToken: jest.fn(),
      getLimitedUserToken: jest.fn(),
      listPublicServiceKeys: jest.fn()
    }));
  })(auth = mockServices2.auth || (mockServices2.auth = {}));
  function discovery$1() {
    return discovery.HostDiscovery.fromConfig(
      new config.ConfigReader({
        backend: {
          // Invalid port to make sure that requests are always mocked
          baseUrl: "http://localhost:0",
          listen: { port: 0 }
        }
      })
    );
  }
  mockServices2.discovery = discovery$1;
  ((discovery2) => {
    discovery2.factory = () => backendPluginApi.createServiceFactory({
      service: backendPluginApi.coreServices.discovery,
      deps: {},
      factory: () => discovery2()
    });
    discovery2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.discovery, () => ({
      getBaseUrl: jest.fn(),
      getExternalBaseUrl: jest.fn()
    }));
  })(discovery$1 = mockServices2.discovery || (mockServices2.discovery = {}));
  function httpAuth(options) {
    return new MockHttpAuthService.MockHttpAuthService(
      options?.pluginId ?? "test",
      options?.defaultCredentials ?? mockCredentials.mockCredentials.user()
    );
  }
  mockServices2.httpAuth = httpAuth;
  ((httpAuth2) => {
    httpAuth2.factory = (options) => backendPluginApi.createServiceFactory({
      service: backendPluginApi.coreServices.httpAuth,
      deps: { plugin: backendPluginApi.coreServices.pluginMetadata },
      factory: ({ plugin }) => new MockHttpAuthService.MockHttpAuthService(
        plugin.getId(),
        options?.defaultCredentials ?? mockCredentials.mockCredentials.user()
      )
    });
    httpAuth2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.httpAuth, () => ({
      credentials: jest.fn(),
      issueUserCookie: jest.fn()
    }));
  })(httpAuth = mockServices2.httpAuth || (mockServices2.httpAuth = {}));
  function userInfo(customInfo) {
    return new MockUserInfoService.MockUserInfoService(customInfo);
  }
  mockServices2.userInfo = userInfo;
  ((userInfo2) => {
    userInfo2.factory = () => backendPluginApi.createServiceFactory({
      service: backendPluginApi.coreServices.userInfo,
      deps: {},
      factory() {
        return new MockUserInfoService.MockUserInfoService();
      }
    });
    userInfo2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.userInfo, () => ({
      getUserInfo: jest.fn()
    }));
  })(userInfo = mockServices2.userInfo || (mockServices2.userInfo = {}));
  ((cache2) => {
    cache2.factory = () => cache.cacheServiceFactory;
    cache2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.cache, () => ({
      delete: jest.fn(),
      get: jest.fn(),
      set: jest.fn(),
      withOptions: jest.fn()
    }));
  })(mockServices2.cache || (mockServices2.cache = {}));
  function database$1(options) {
    return {
      getClient: async () => options.knex,
      migrations: options.migrations
    };
  }
  mockServices2.database = database$1;
  ((database2) => {
    database2.factory = (options) => options ? backendPluginApi.createServiceFactory({
      service: backendPluginApi.coreServices.database,
      deps: {},
      factory: () => database2(options)
    }) : database.databaseServiceFactory;
    database2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.database, () => ({
      getClient: jest.fn()
    }));
  })(database$1 = mockServices2.database || (mockServices2.database = {}));
  ((rootHealth2) => {
    rootHealth2.factory = () => rootHealth.rootHealthServiceFactory;
    rootHealth2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.rootHealth, () => ({
      getLiveness: jest.fn(),
      getReadiness: jest.fn()
    }));
  })(mockServices2.rootHealth || (mockServices2.rootHealth = {}));
  ((httpRouter2) => {
    httpRouter2.factory = () => httpRouter.httpRouterServiceFactory;
    httpRouter2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.httpRouter, () => ({
      use: jest.fn(),
      addAuthPolicy: jest.fn()
    }));
  })(mockServices2.httpRouter || (mockServices2.httpRouter = {}));
  ((rootHttpRouter2) => {
    rootHttpRouter2.factory = () => rootHttpRouter.rootHttpRouterServiceFactory();
    rootHttpRouter2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.rootHttpRouter, () => ({
      use: jest.fn()
    }));
  })(mockServices2.rootHttpRouter || (mockServices2.rootHttpRouter = {}));
  ((lifecycle2) => {
    lifecycle2.factory = () => lifecycle.lifecycleServiceFactory;
    lifecycle2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.lifecycle, () => ({
      addShutdownHook: jest.fn(),
      addStartupHook: jest.fn()
    }));
  })(mockServices2.lifecycle || (mockServices2.lifecycle = {}));
  ((logger2) => {
    logger2.factory = () => logger.loggerServiceFactory;
    logger2.mock = simpleMock.simpleMock(
      backendPluginApi.coreServices.logger,
      () => createLoggerMock()
    );
  })(mockServices2.logger || (mockServices2.logger = {}));
  function permissions$1(options) {
    return new MockPermissionsService.MockPermissionsService(options);
  }
  mockServices2.permissions = permissions$1;
  ((permissions2) => {
    permissions2.factory = (options) => options?.result ? backendPluginApi.createServiceFactory({
      service: backendPluginApi.coreServices.permissions,
      deps: {},
      factory: () => new MockPermissionsService.MockPermissionsService(options)
    }) : permissions.permissionsServiceFactory;
    permissions2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.permissions, () => ({
      authorize: jest.fn(),
      authorizeConditional: jest.fn()
    }));
  })(permissions$1 = mockServices2.permissions || (mockServices2.permissions = {}));
  ((permissionsRegistry2) => {
    permissionsRegistry2.factory = () => permissionsRegistry.permissionsRegistryServiceFactory;
    permissionsRegistry2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.permissionsRegistry, () => ({
      addPermissionRules: jest.fn(),
      addPermissions: jest.fn(),
      addResourceType: jest.fn(),
      getPermissionRuleset: jest.fn()
    }));
  })(mockServices2.permissionsRegistry || (mockServices2.permissionsRegistry = {}));
  ((rootLifecycle2) => {
    rootLifecycle2.factory = () => rootLifecycle.rootLifecycleServiceFactory;
    rootLifecycle2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.rootLifecycle, () => ({
      addShutdownHook: jest.fn(),
      addBeforeShutdownHook: jest.fn(),
      addStartupHook: jest.fn()
    }));
  })(mockServices2.rootLifecycle || (mockServices2.rootLifecycle = {}));
  function scheduler() {
    return new MockSchedulerService.MockSchedulerService();
  }
  mockServices2.scheduler = scheduler;
  ((scheduler2) => {
    scheduler2.factory = (options) => new MockSchedulerService.MockSchedulerService().factory(options);
    scheduler2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.scheduler, () => ({
      createScheduledTaskRunner: jest.fn(),
      getScheduledTasks: jest.fn(),
      scheduleTask: jest.fn(),
      triggerTask: jest.fn()
    }));
  })(scheduler = mockServices2.scheduler || (mockServices2.scheduler = {}));
  ((urlReader2) => {
    urlReader2.factory = () => urlReader.urlReaderServiceFactory;
    urlReader2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.urlReader, () => ({
      readTree: jest.fn(),
      readUrl: jest.fn(),
      search: jest.fn()
    }));
  })(mockServices2.urlReader || (mockServices2.urlReader = {}));
  function events() {
    return new MockEventsService.MockEventsService();
  }
  mockServices2.events = events;
  ((events2) => {
    events2.factory = simpleFactoryWithOptions(pluginEventsNode.eventsServiceRef, events2);
    events2.mock = simpleMock.simpleMock(pluginEventsNode.eventsServiceRef, () => ({
      publish: jest.fn(),
      subscribe: jest.fn()
    }));
  })(events = mockServices2.events || (mockServices2.events = {}));
  function rootInstanceMetadata() {
    return {
      getInstalledPlugins: () => Promise.resolve([])
    };
  }
  mockServices2.rootInstanceMetadata = rootInstanceMetadata;
  ((rootInstanceMetadata2) => {
    rootInstanceMetadata2.mock = simpleMock.simpleMock(backendPluginApi.coreServices.rootInstanceMetadata, () => ({
      getInstalledPlugins: jest.fn()
    }));
    rootInstanceMetadata2.factory = simpleFactoryWithOptions(
      backendPluginApi.coreServices.rootInstanceMetadata,
      rootInstanceMetadata2
    );
  })(rootInstanceMetadata = mockServices2.rootInstanceMetadata || (mockServices2.rootInstanceMetadata = {}));
})(exports.mockServices || (exports.mockServices = {}));
//# sourceMappingURL=mockServices.cjs.js.map