@backstage/backend-test-utils
Version:
Test helpers library for Backstage backends
331 lines (328 loc) • 13.3 kB
JavaScript
;
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');
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) {
return new config.ConfigReader(options?.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 = {}));
})(exports.mockServices || (exports.mockServices = {}));
//# sourceMappingURL=mockServices.cjs.js.map