Licensing plugin

src/core/public/mocks.ts

@@ -117,9 +117,22 @@ function createCoreContext(): CoreContext {
   };
 }
 
+function createStorageMock() {
+  const storageMock: jest.Mocked<Storage> = {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+    clear: jest.fn(),
+    key: jest.fn(),
+    length: 10,
+  };
+  return storageMock;
+}
+
 export const coreMock = {
   createCoreContext,
   createSetup: createCoreSetupMock,
   createStart: createCoreStartMock,
   createPluginInitializerContext: pluginInitializerContextMock,
+  createStorage: createStorageMock,
 };

x-pack/dev-tools/jest/setup/polyfills.js

@@ -16,3 +16,5 @@ Object.defineProperty(window, 'MutationObserver', { value: MutationObserver });
 
 const URL = { createObjectURL: () => '' };
 Object.defineProperty(window, 'URL', { value: URL });
+
+require('jest-localstorage-mock');

x-pack/package.json

@@ -149,6 +149,7 @@
     "hapi": "^17.5.3",
     "jest": "^24.9.0",
     "jest-cli": "^24.9.0",
+    "jest-localstorage-mock": "^2.4.0",
     "jest-styled-components": "^6.3.3",
     "jsdom": "^12.2.0",
     "madge": "3.4.4",

x-pack/plugins/licensing/common/has_license_info_changed.test.ts

@@ -0,0 +1,102 @@
+/*
+ * 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 { License } from './license';
+import { PublicLicense } from '../server/types';
+import { hasLicenseInfoChanged } from './has_license_info_changed';
+
+function license({ error, ...customLicense }: { error?: Error; [key: string]: any } = {}) {
+  const defaultLicense: PublicLicense['license'] = {
+    uid: 'uid-000000001234',
+    status: 'active',
+    type: 'basic',
+    expiryDateInMillis: 1000,
+  };
+
+  return new License({
+    error,
+    license: Object.assign(defaultLicense, customLicense),
+    signature: 'aaaaaaa',
+  });
+}
+
+// Each test should ensure that left-to-right and right-to-left comparisons are captured.
+describe('has license info changed', () => {
+  describe('License', () => {
+    test('undefined <-> License', async () => {
+      expect(hasLicenseInfoChanged(undefined, license())).toBe(true);
+    });
+
+    test('the same License', async () => {
+      const licenseInstance = license();
+      expect(hasLicenseInfoChanged(licenseInstance, licenseInstance)).toBe(false);
+    });
+
+    test('type License <-> type License | mismatched type', async () => {
+      expect(hasLicenseInfoChanged(license({ type: 'basic' }), license({ type: 'gold' }))).toBe(
+        true
+      );
+      expect(hasLicenseInfoChanged(license({ type: 'gold' }), license({ type: 'basic' }))).toBe(
+        true
+      );
+    });
+
+    test('status License <-> status License | mismatched status', async () => {
+      expect(
+        hasLicenseInfoChanged(license({ status: 'active' }), license({ status: 'inactive' }))
+      ).toBe(true);
+      expect(
+        hasLicenseInfoChanged(license({ status: 'inactive' }), license({ status: 'active' }))
+      ).toBe(true);
+    });
+
+    test('expiry License <-> expiry License | mismatched expiry', async () => {
+      expect(
+        hasLicenseInfoChanged(
+          license({ expiryDateInMillis: 100 }),
+          license({ expiryDateInMillis: 200 })
+        )
+      ).toBe(true);
+      expect(
+        hasLicenseInfoChanged(
+          license({ expiryDateInMillis: 200 }),
+          license({ expiryDateInMillis: 100 })
+        )
+      ).toBe(true);
+    });
+  });
+
+  describe('error License', () => {
+    test('License <-> error License', async () => {
+      expect(hasLicenseInfoChanged(license({ error: new Error('reason') }), license())).toBe(true);
+      expect(hasLicenseInfoChanged(license(), license({ error: new Error('reason') }))).toBe(true);
+    });
+
+    test('error License <-> error License | matched messages', async () => {
+      expect(
+        hasLicenseInfoChanged(
+          license({ error: new Error('reason-1') }),
+          license({ error: new Error('reason-1') })
+        )
+      ).toBe(false);
+    });
+
+    test('error License <-> error License | mismatched messages', async () => {
+      expect(
+        hasLicenseInfoChanged(
+          license({ error: new Error('reason-1') }),
+          license({ error: new Error('reason-2') })
+        )
+      ).toBe(true);
+      expect(
+        hasLicenseInfoChanged(
+          license({ error: new Error('reason-2') }),
+          license({ error: new Error('reason-1') })
+        )
+      ).toBe(true);
+    });
+  });
+});

x-pack/plugins/licensing/common/has_license_info_changed.ts

@@ -0,0 +1,32 @@
+/*
+ * 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 { ILicense } from '../server/types';
+
+/**
+ * @internal
+ * Check if 2 potential license instances have changes between them
+ */
+export function hasLicenseInfoChanged(currentLicense: ILicense | undefined, newLicense: ILicense) {
+  if (currentLicense === newLicense) return false;
+  if (!currentLicense) return true;
+
+  if (
+    (currentLicense.error && !newLicense.error) ||
+    (!currentLicense.error && newLicense.error) ||
+    (newLicense.error &&
+      currentLicense.error &&
+      newLicense.error.message !== currentLicense.error.message)
+  ) {
+    return true;
+  }
+  return (
+    newLicense.type !== currentLicense.type ||
+    newLicense.status !== currentLicense.status ||
+    newLicense.expiryDateInMillis !== currentLicense.expiryDateInMillis ||
+    newLicense.isAvailable !== currentLicense.isAvailable
+  );
+}

x-pack/plugins/licensing/common/license.mock.ts

@@ -0,0 +1,44 @@
+/*
+ * 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 { PublicLicense } from '../server/types';
+import { License } from './license';
+
+function createLicense({
+  license = {},
+  features = {},
+  signature = 'xxxxxxxxx',
+}: {
+  license?: Partial<PublicLicense['license']>;
+  features?: PublicLicense['features'];
+  signature?: string;
+} = {}) {
+  const defaultLicense = {
+    uid: 'uid-000000001234',
+    status: 'active',
+    type: 'basic',
+    expiryDateInMillis: 5000,
+  };
+
+  const defaultFeatures = {
+    ccr: {
+      enabled: true,
+      available: true,
+    },
+    ml: {
+      enabled: false,
+      available: true,
+    },
+  };
+  return new License({
+    license: Object.assign(defaultLicense, license),
+    features: Object.assign(defaultFeatures, features),
+    signature,
+  });
+}
+
+export const licenseMock = {
+  create: createLicense,
+};