Spaces - NP updates for usage collection and capabilities

src/core/server/http/http_server.mocks.ts

@@ -42,6 +42,7 @@ interface RequestFixtureOptions {
   method?: RouteMethod;
   socket?: Socket;
   routeTags?: string[];
+  routeAuthRequired?: false;
 }
 
 function createKibanaRequestMock({
@@ -53,6 +54,7 @@ function createKibanaRequestMock({
   method = 'get',
   socket = new Socket(),
   routeTags,
+  routeAuthRequired,
 }: RequestFixtureOptions = {}) {
   const queryString = stringify(query, { sort: false });
 
@@ -70,7 +72,9 @@ function createKibanaRequestMock({
         query: queryString,
         search: queryString ? `?${queryString}` : queryString,
       },
-      route: { settings: { tags: routeTags } },
+      route: {
+        settings: { tags: routeTags, auth: routeAuthRequired },
+      },
       raw: {
         req: { socket },
       },

src/plugins/usage_collection/server/mocks.ts

@@ -0,0 +1,41 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// eslint-disable-next-line @kbn/eslint/no-restricted-paths
+import { loggingServiceMock } from 'src/core/server/mocks';
+import { UsageCollectionSetup } from './plugin';
+import { CollectorSet } from './collector';
+
+const createSetupContract = () => {
+  const setupContract = {
+    ...new CollectorSet({
+      logger: loggingServiceMock.createLogger(),
+      maximumWaitTimeForAllCollectorsInS: 1,
+    }),
+    registerLegacySavedObjects: jest.fn() as jest.Mocked<
+      UsageCollectionSetup['registerLegacySavedObjects']
+    >,
+  } as UsageCollectionSetup;
+
+  return setupContract;
+};
+
+export const usageCollectionPluginMock = {
+  createSetupContract,
+};

x-pack/legacy/plugins/spaces/index.ts

@@ -34,19 +34,6 @@ export const spaces = (kibana: Record<string, any>) =>
     publicDir: resolve(__dirname, 'public'),
     require: ['kibana', 'elasticsearch', 'xpack_main'],
 
-    uiCapabilities() {
-      return {
-        spaces: {
-          manage: true,
-        },
-        management: {
-          kibana: {
-            spaces: true,
-          },
-        },
-      };
-    },
-
     uiExports: {
       styleSheetPaths: resolve(__dirname, 'public/index.scss'),
       managementSections: [],
@@ -110,14 +97,9 @@ export const spaces = (kibana: Record<string, any>) =>
         throw new Error('New Platform XPack Spaces plugin is not available.');
       }
 
-      const config = server.config();
-
       const { registerLegacyAPI, createDefaultSpace } = spacesPlugin.__legacyCompat;
 
       registerLegacyAPI({
-        legacyConfig: {
-          kibanaIndex: config.get('kibana.index'),
-        },
         savedObjects: server.savedObjects,
         auditLogger: {
           create: (pluginId: string) =>

x-pack/plugins/features/server/mocks.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { PluginSetupContract, PluginStartContract } from './plugin';
+
+const createSetup = (): jest.Mocked<PluginSetupContract> => {
+  return {
+    getFeatures: jest.fn(),
+    getFeaturesUICapabilities: jest.fn(),
+    registerFeature: jest.fn(),
+    registerLegacyAPI: jest.fn(),
+  };
+};
+
+const createStart = (): jest.Mocked<PluginStartContract> => {
+  return {
+    getFeatures: jest.fn(),
+  };
+};
+
+export const featuresPluginMock = {
+  createSetup,
+  createStart,
+};

x-pack/plugins/features/server/plugin.ts

@@ -30,6 +30,10 @@ export interface PluginSetupContract {
   registerLegacyAPI: (legacyAPI: LegacyAPI) => void;
 }
 
+export interface PluginStartContract {
+  getFeatures(): Feature[];
+}
+
 /**
  * Describes a set of APIs that are available in the legacy platform only and required by this plugin
  * to function properly.
@@ -45,6 +49,8 @@ export interface LegacyAPI {
 export class Plugin {
   private readonly logger: Logger;
 
+  private featureRegistry!: FeatureRegistry;
+
   private legacyAPI?: LegacyAPI;
   private readonly getLegacyAPI = () => {
     if (!this.legacyAPI) {
@@ -61,18 +67,18 @@ export class Plugin {
     core: CoreSetup,
     { timelion }: { timelion?: TimelionSetupContract }
   ): Promise<RecursiveReadonly<PluginSetupContract>> {
-    const featureRegistry = new FeatureRegistry();
+    this.featureRegistry = new FeatureRegistry();
 
     defineRoutes({
       router: core.http.createRouter(),
-      featureRegistry,
+      featureRegistry: this.featureRegistry,
       getLegacyAPI: this.getLegacyAPI,
     });
 
     return deepFreeze({
-      registerFeature: featureRegistry.register.bind(featureRegistry),
-      getFeatures: featureRegistry.getAll.bind(featureRegistry),
-      getFeaturesUICapabilities: () => uiCapabilitiesForFeatures(featureRegistry.getAll()),
+      registerFeature: this.featureRegistry.register.bind(this.featureRegistry),
+      getFeatures: this.featureRegistry.getAll.bind(this.featureRegistry),
+      getFeaturesUICapabilities: () => uiCapabilitiesForFeatures(this.featureRegistry.getAll()),
 
       registerLegacyAPI: (legacyAPI: LegacyAPI) => {
         this.legacyAPI = legacyAPI;
@@ -82,14 +88,17 @@ export class Plugin {
           savedObjectTypes: this.legacyAPI.savedObjectTypes,
           includeTimelion: timelion !== undefined && timelion.uiEnabled,
         })) {
-          featureRegistry.register(feature);
+          this.featureRegistry.register(feature);
         }
       },
     });
   }
 
-  public start() {
+  public start(): RecursiveReadonly<PluginStartContract> {
     this.logger.debug('Starting plugin');
+    return {
+      getFeatures: this.featureRegistry.getAll.bind(this.featureRegistry),
+    };
   }
 
   public stop() {

x-pack/plugins/spaces/server/capabilities/capabilities_provider.test.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { capabilitiesProvider } from './capabilities_provider';
+
+describe('Capabilities provider', () => {
+  it('provides the expected capabilities', () => {
+    expect(capabilitiesProvider()).toMatchInlineSnapshot(`
+      Object {
+        "management": Object {
+          "kibana": Object {
+            "spaces": true,
+          },
+        },
+        "spaces": Object {
+          "manage": true,
+        },
+      }
+    `);
+  });
+});

x-pack/plugins/spaces/server/capabilities/capabilities_provider.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+export const capabilitiesProvider = () => ({
+  spaces: {
+    manage: true,
+  },
+  management: {
+    kibana: {
+      spaces: true,
+    },
+  },
+});

x-pack/plugins/spaces/server/lib/toggle_ui_capabilities.test.ts → x-pack/plugins/spaces/server/capabilities/capabilities_switcher.test.ts

@@ -6,8 +6,12 @@
 
 import { Feature } from '../../../../plugins/features/server';
 import { Space } from '../../common/model/space';
-import { toggleUICapabilities } from './toggle_ui_capabilities';
-import { Capabilities } from 'src/core/public';
+import { setupCapabilitiesSwitcher } from './capabilities_switcher';
+import { Capabilities, CoreSetup } from 'src/core/server';
+import { coreMock, httpServerMock, loggingServiceMock } from 'src/core/server/mocks';
+import { featuresPluginMock } from '../../../features/server/mocks';
+import { spacesServiceMock } from '../spaces_service/spaces_service.mock';
+import { PluginsSetup } from '../plugin';
 
 const features: Feature[] = [
   {
@@ -91,40 +95,115 @@ const buildCapabilities = () =>
     },
   }) as Capabilities;
 
-describe('toggleUiCapabilities', () => {
-  it('does not toggle capabilities when the space has no disabled features', () => {
+const setup = (space: Space) => {
+  const coreSetup = coreMock.createSetup();
+
+  const featuresStart = featuresPluginMock.createStart();
+  featuresStart.getFeatures.mockReturnValue(features);
+
+  coreSetup.getStartServices.mockResolvedValue([
+    coreMock.createStart(),
+    { features: featuresStart },
+  ]);
+
+  const spacesService = spacesServiceMock.createSetupContract();
+  spacesService.getActiveSpace.mockResolvedValue(space);
+
+  const logger = loggingServiceMock.createLogger();
+
+  const switcher = setupCapabilitiesSwitcher(
+    (coreSetup as unknown) as CoreSetup<PluginsSetup>,
+    spacesService,
+    logger
+  );
+
+  return { switcher, logger, spacesService };
+};
+
+describe('capabilitiesSwitcher', () => {
+  it('does not toggle capabilities when the space has no disabled features', async () => {
     const space: Space = {
       id: 'space',
       name: '',
       disabledFeatures: [],
     };
 
     const capabilities = buildCapabilities();
-    const result = toggleUICapabilities(features, capabilities, space);
+
+    const { switcher } = setup(space);
+    const request = httpServerMock.createKibanaRequest();
+    const result = await switcher(request, capabilities);
+
+    expect(result).toEqual(buildCapabilities());
+  });
+
+  it('does not toggle capabilities when the request is not authenticated', async () => {
+    const space: Space = {
+      id: 'space',
+      name: '',
+      disabledFeatures: ['feature_1', 'feature_2', 'feature_3'],
+    };
+
+    const capabilities = buildCapabilities();
+
+    const { switcher } = setup(space);
+    const request = httpServerMock.createKibanaRequest({ routeAuthRequired: false });
+
+    const result = await switcher(request, capabilities);
+
+    expect(result).toEqual(buildCapabilities());
+  });
+
+  it('logs a warning, and does not toggle capabilities if an error is encountered', async () => {
+    const space: Space = {
+      id: 'space',
+      name: '',
+      disabledFeatures: ['feature_1', 'feature_2', 'feature_3'],
+    };
+
+    const capabilities = buildCapabilities();
+
+    const { switcher, logger, spacesService } = setup(space);
+    const request = httpServerMock.createKibanaRequest();
+
+    spacesService.getActiveSpace.mockRejectedValue(new Error('Something terrible happened'));
+
+    const result = await switcher(request, capabilities);
+
     expect(result).toEqual(buildCapabilities());
+    expect(logger.warn).toHaveBeenCalledWith(
+      `Error toggling capabilities for request to /path: Error: Something terrible happened`
+    );
   });
 
-  it('ignores unknown disabledFeatures', () => {
+  it('ignores unknown disabledFeatures', async () => {
     const space: Space = {
       id: 'space',
       name: '',
       disabledFeatures: ['i-do-not-exist'],
     };
 
     const capabilities = buildCapabilities();
-    const result = toggleUICapabilities(features, capabilities, space);
+
+    const { switcher } = setup(space);
+    const request = httpServerMock.createKibanaRequest();
+    const result = await switcher(request, capabilities);
+
     expect(result).toEqual(buildCapabilities());
   });
 
-  it('disables the corresponding navLink, catalogue, management sections, and all capability flags for disabled features', () => {
+  it('disables the corresponding navLink, catalogue, management sections, and all capability flags for disabled features', async () => {
     const space: Space = {
       id: 'space',
       name: '',
       disabledFeatures: ['feature_2'],
     };
 
     const capabilities = buildCapabilities();
-    const result = toggleUICapabilities(features, capabilities, space);
+
+    const { switcher } = setup(space);
+    const request = httpServerMock.createKibanaRequest();
+    const result = await switcher(request, capabilities);
 
     const expectedCapabilities = buildCapabilities();
 
@@ -137,15 +216,18 @@ describe('toggleUiCapabilities', () => {
     expect(result).toEqual(expectedCapabilities);
   });
 
-  it('can disable everything', () => {
+  it('can disable everything', async () => {
     const space: Space = {
       id: 'space',
       name: '',
       disabledFeatures: ['feature_1', 'feature_2', 'feature_3'],
     };
 
     const capabilities = buildCapabilities();
-    const result = toggleUICapabilities(features, capabilities, space);
+
+    const { switcher } = setup(space);
+    const request = httpServerMock.createKibanaRequest();
+    const result = await switcher(request, capabilities);
 
     const expectedCapabilities = buildCapabilities();