Backstage
    Preparing search index...

    Interface MockServices

    The type of (mockServices:variable), with mock implementations of the core services.

    interface MockServices {
        auditor: {
            factory: () => ServiceFactory<AuditorService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<AuditorService>,
            ) => ServiceMock<AuditorService>;
        };
        auth: {
            factory: () => ServiceFactory<AuthService, "plugin", "singleton">;
            mock: (partialImpl?: Partial<AuthService>) => ServiceMock<AuthService>;
            (
                options?: { disableDefaultAuthPolicy?: boolean; pluginId?: string },
            ): AuthService;
        };
        cache: {
            factory: () => ServiceFactory<CacheService, "plugin", "singleton">;
            mock: (partialImpl?: Partial<CacheService>) => ServiceMock<CacheService>;
        };
        database: {
            factory: (
                options?: { knex: Knex; migrations?: { skip?: boolean } },
            ) => ServiceFactory<DatabaseService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<DatabaseService>,
            ) => ServiceMock<DatabaseService>;
            (
                options: { knex: Knex; migrations?: { skip?: boolean } },
            ): DatabaseService;
        };
        discovery: {
            factory: () => ServiceFactory<DiscoveryService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<DiscoveryService>,
            ) => ServiceMock<DiscoveryService>;
            (): DiscoveryService;
        };
        events: {
            factory: () => ServiceFactory<EventsService, "plugin", "singleton">;
            mock: (partialImpl?: Partial<EventsService>) => ServiceMock<EventsService>;
            (): EventsService;
        };
        httpAuth: {
            factory: (
                options?: { defaultCredentials?: BackstageCredentials },
            ) => ServiceFactory<HttpAuthService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<HttpAuthService>,
            ) => ServiceMock<HttpAuthService>;
            (
                options?: {
                    defaultCredentials?: BackstageCredentials;
                    pluginId?: string;
                },
            ): HttpAuthService;
        };
        httpRouter: {
            factory: () => ServiceFactory<HttpRouterService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<HttpRouterService>,
            ) => ServiceMock<HttpRouterService>;
        };
        lifecycle: {
            factory: () => ServiceFactory<LifecycleService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<LifecycleService>,
            ) => ServiceMock<LifecycleService>;
        };
        logger: {
            factory: () => ServiceFactory<LoggerService, "plugin", "singleton">;
            mock: (partialImpl?: Partial<LoggerService>) => ServiceMock<LoggerService>;
        };
        permissions: {
            factory: (
                options?: { result: "DENY" | "ALLOW" },
            ) => ServiceFactory<PermissionsService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<PermissionsService>,
            ) => ServiceMock<PermissionsService>;
            (options?: { result: "DENY" | "ALLOW" }): PermissionsService;
        };
        permissionsRegistry: {
            factory: () => ServiceFactory<
                PermissionsRegistryService,
                "plugin",
                "singleton",
            >;
            mock: (
                partialImpl?: Partial<PermissionsRegistryService>,
            ) => ServiceMock<PermissionsRegistryService>;
        };
        rootConfig: {
            factory: (
                options?: mockServices.rootConfig.Options,
            ) => ServiceFactory<RootConfigService, "root", "singleton">;
            mock: (
                partialImpl?: Partial<RootConfigService>,
            ) => ServiceMock<RootConfigService>;
            (
                options?: mockServices.rootConfig.Options,
            ): RootConfigService & { update(options: { data: JsonObject }): void };
        };
        rootHealth: {
            factory: () => ServiceFactory<RootHealthService, "root", "singleton">;
            mock: (
                partialImpl?: Partial<RootHealthService>,
            ) => ServiceMock<RootHealthService>;
        };
        rootHttpRouter: {
            factory: () => ServiceFactory<
                RootHttpRouterService,
                "root",
                "singleton",
            >;
            mock: (
                partialImpl?: Partial<RootHttpRouterService>,
            ) => ServiceMock<RootHttpRouterService>;
        };
        rootInstanceMetadata: {
            factory: () => ServiceFactory<
                RootInstanceMetadataService,
                "root",
                "singleton",
            >;
            mock: (
                partialImpl?: Partial<RootInstanceMetadataService>,
            ) => ServiceMock<RootInstanceMetadataService>;
            (): RootInstanceMetadataService;
        };
        rootLifecycle: {
            factory: () => ServiceFactory<
                RootLifecycleService,
                "root",
                "singleton",
            >;
            mock: (
                partialImpl?: Partial<RootLifecycleService>,
            ) => ServiceMock<RootLifecycleService>;
        };
        rootLogger: {
            factory: (
                options?: mockServices.rootLogger.Options,
            ) => ServiceFactory<RootLoggerService, "root", "singleton">;
            mock: (
                partialImpl?: Partial<RootLoggerService>,
            ) => ServiceMock<RootLoggerService>;
            (options?: mockServices.rootLogger.Options): RootLoggerService;
        };
        rootSystemMetadata: {
            factory: () => ServiceFactory<
                RootSystemMetadataService,
                "root",
                "singleton",
            >;
            mock: (
                partialImpl?: Partial<RootSystemMetadataService>,
            ) => ServiceMock<RootSystemMetadataService>;
            (): RootSystemMetadataService;
        };
        scheduler: {
            factory: (
                options?: {
                    includeInitialDelayedTasksOnStartup?: boolean;
                    includeManualTasksOnStartup?: boolean;
                    skipTaskRunOnStartup?: boolean;
                },
            ) => ServiceFactory<SchedulerService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<SchedulerService>,
            ) => ServiceMock<SchedulerService>;
            (): SchedulerService;
        };
        urlReader: {
            factory: () => ServiceFactory<UrlReaderService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<UrlReaderService>,
            ) => ServiceMock<UrlReaderService>;
        };
        userInfo: {
            factory: () => ServiceFactory<UserInfoService, "plugin", "singleton">;
            mock: (
                partialImpl?: Partial<UserInfoService>,
            ) => ServiceMock<UserInfoService>;
            (customInfo?: Partial<BackstageUserInfo>): UserInfoService;
        };
    }
    Index
    auditor auth cache database discovery events httpAuth httpRouter lifecycle logger permissions permissionsRegistry rootConfig rootHealth rootHttpRouter rootInstanceMetadata rootLifecycle rootLogger rootSystemMetadata scheduler urlReader userInfo
    auditor: {
        factory: () => ServiceFactory<AuditorService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<AuditorService>,
        ) => ServiceMock<AuditorService>;
    }

    Mocks for the auditor service.

    auth: {
        factory: () => ServiceFactory<AuthService, "plugin", "singleton">;
        mock: (partialImpl?: Partial<AuthService>) => ServiceMock<AuthService>;
        (
            options?: { disableDefaultAuthPolicy?: boolean; pluginId?: string },
        ): AuthService;
    }

    Mocks for the auth service. Calling it creates a functional mock auth service.

    cache: {
        factory: () => ServiceFactory<CacheService, "plugin", "singleton">;
        mock: (partialImpl?: Partial<CacheService>) => ServiceMock<CacheService>;
    }

    Mocks for the cache service.

    database: {
        factory: (
            options?: { knex: Knex; migrations?: { skip?: boolean } },
        ) => ServiceFactory<DatabaseService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<DatabaseService>,
        ) => ServiceMock<DatabaseService>;
        (options: { knex: Knex; migrations?: { skip?: boolean } }): DatabaseService;
    }

    Mocks for the @backstage/backend-plugin-api#CoreServices.database | database service.

    Calling it, or its factory with a knex instance, uses that instance, which is useful in combination with the TestDatabases facility. Calling factory without options returns the regular default database factory, which reads config settings.

    discovery: {
        factory: () => ServiceFactory<DiscoveryService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<DiscoveryService>,
        ) => ServiceMock<DiscoveryService>;
        (): DiscoveryService;
    }

    Mocks for the discovery service. Calling it creates a discovery service that points to an unreachable local address.

    events: {
        factory: () => ServiceFactory<EventsService, "plugin", "singleton">;
        mock: (partialImpl?: Partial<EventsService>) => ServiceMock<EventsService>;
        (): EventsService;
    }

    Mocks for the @backstage/plugin-events-node#eventsServiceRef | events service. Calling it, or using its factory, creates a functional mock implementation.

    httpAuth: {
        factory: (
            options?: { defaultCredentials?: BackstageCredentials },
        ) => ServiceFactory<HttpAuthService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<HttpAuthService>,
        ) => ServiceMock<HttpAuthService>;
        (
            options?: {
                defaultCredentials?: BackstageCredentials;
                pluginId?: string;
            },
        ): HttpAuthService;
    }

    Mocks for the HttpAuthService.

    By default all requests without credentials are treated as requests from the default mock user principal. This behavior can be configured with the defaultCredentials option.

    httpRouter: {
        factory: () => ServiceFactory<HttpRouterService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<HttpRouterService>,
        ) => ServiceMock<HttpRouterService>;
    }

    Mocks for the HTTP router service.

    lifecycle: {
        factory: () => ServiceFactory<LifecycleService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<LifecycleService>,
        ) => ServiceMock<LifecycleService>;
    }

    Mocks for the lifecycle service.

    logger: {
        factory: () => ServiceFactory<LoggerService, "plugin", "singleton">;
        mock: (partialImpl?: Partial<LoggerService>) => ServiceMock<LoggerService>;
    }

    Mocks for the logger service.

    permissions: {
        factory: (
            options?: { result: "DENY" | "ALLOW" },
        ) => ServiceFactory<PermissionsService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<PermissionsService>,
        ) => ServiceMock<PermissionsService>;
        (options?: { result: "DENY" | "ALLOW" }): PermissionsService;
    }

    Mocks for the @backstage/backend-plugin-api#CoreServices.permissions | permissions service.

    Calling it creates a functional mock implementation. Its factory returns the given result for all requests if you supply one, and otherwise the regular default permissions factory.

    permissionsRegistry: {
        factory: () => ServiceFactory<
            PermissionsRegistryService,
            "plugin",
            "singleton",
        >;
        mock: (
            partialImpl?: Partial<PermissionsRegistryService>,
        ) => ServiceMock<PermissionsRegistryService>;
    }

    Mocks for the permissions registry service.

    rootConfig: {
        factory: (
            options?: mockServices.rootConfig.Options,
        ) => ServiceFactory<RootConfigService, "root", "singleton">;
        mock: (
            partialImpl?: Partial<RootConfigService>,
        ) => ServiceMock<RootConfigService>;
        (
            options?: mockServices.rootConfig.Options,
        ): RootConfigService & { update(options: { data: JsonObject }): void };
    }

    Mocks for the root config service. Calling it creates a functional config service with the given data, which can be updated later.

    rootHealth: {
        factory: () => ServiceFactory<RootHealthService, "root", "singleton">;
        mock: (
            partialImpl?: Partial<RootHealthService>,
        ) => ServiceMock<RootHealthService>;
    }

    Mocks for the root health service.

    rootHttpRouter: {
        factory: () => ServiceFactory<
            RootHttpRouterService,
            "root",
            "singleton",
        >;
        mock: (
            partialImpl?: Partial<RootHttpRouterService>,
        ) => ServiceMock<RootHttpRouterService>;
    }

    Mocks for the root HTTP router service.

    rootInstanceMetadata: {
        factory: () => ServiceFactory<
            RootInstanceMetadataService,
            "root",
            "singleton",
        >;
        mock: (
            partialImpl?: Partial<RootInstanceMetadataService>,
        ) => ServiceMock<RootInstanceMetadataService>;
        (): RootInstanceMetadataService;
    }

    Mocks for the root instance metadata service.

    rootLifecycle: {
        factory: () => ServiceFactory<RootLifecycleService, "root", "singleton">;
        mock: (
            partialImpl?: Partial<RootLifecycleService>,
        ) => ServiceMock<RootLifecycleService>;
    }

    Mocks for the root lifecycle service.

    rootLogger: {
        factory: (
            options?: mockServices.rootLogger.Options,
        ) => ServiceFactory<RootLoggerService, "root", "singleton">;
        mock: (
            partialImpl?: Partial<RootLoggerService>,
        ) => ServiceMock<RootLoggerService>;
        (options?: mockServices.rootLogger.Options): RootLoggerService;
    }

    Mocks for the root logger service. Calling it creates a functional logger that is silent by default.

    rootSystemMetadata: {
        factory: () => ServiceFactory<
            RootSystemMetadataService,
            "root",
            "singleton",
        >;
        mock: (
            partialImpl?: Partial<RootSystemMetadataService>,
        ) => ServiceMock<RootSystemMetadataService>;
        (): RootSystemMetadataService;
    }

    Mocks for the root system metadata service.

    scheduler: {
        factory: (
            options?: {
                includeInitialDelayedTasksOnStartup?: boolean;
                includeManualTasksOnStartup?: boolean;
                skipTaskRunOnStartup?: boolean;
            },
        ) => ServiceFactory<SchedulerService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<SchedulerService>,
        ) => ServiceMock<SchedulerService>;
        (): SchedulerService;
    }

    Mocks for the scheduler service. Calling it creates a functional mock scheduler.

    urlReader: {
        factory: () => ServiceFactory<UrlReaderService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<UrlReaderService>,
        ) => ServiceMock<UrlReaderService>;
    }

    Mocks for the URL reader service.

    userInfo: {
        factory: () => ServiceFactory<UserInfoService, "plugin", "singleton">;
        mock: (
            partialImpl?: Partial<UserInfoService>,
        ) => ServiceMock<UserInfoService>;
        (customInfo?: Partial<BackstageUserInfo>): UserInfoService;
    }

    Mocks for the UserInfoService.

    By default it extracts the user's entity ref from a user principal and returns that as the only ownership entity ref, but calling it lets you pass in a custom set of user info.

    Settings
    Member Visibility

    On This Page
    Properties