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/plugins/licensing/common/has_license_info_changed.test.ts

@@ -0,0 +1,93 @@
+/*
+ * 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 './types';
+import { hasLicenseInfoChanged } from './has_license_info_changed';
+
+function license({ error, ...customLicense }: { error?: string; [key: string]: any } = {}) {
+  const defaultLicense: PublicLicense = {
+    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: 'reason' }), license())).toBe(true);
+      expect(hasLicenseInfoChanged(license(), license({ error: 'reason' }))).toBe(true);
+    });
+
+    test('error License <-> error License | matched messages', async () => {
+      expect(
+        hasLicenseInfoChanged(license({ error: 'reason-1' }), license({ error: 'reason-1' }))
+      ).toBe(false);
+    });
+
+    test('error License <-> error License | mismatched messages', async () => {
+      expect(
+        hasLicenseInfoChanged(license({ error: 'reason-1' }), license({ error: 'reason-2' }))
+      ).toBe(true);
+      expect(
+        hasLicenseInfoChanged(license({ error: 'reason-2' }), license({ error: 'reason-1' }))
+      ).toBe(true);
+    });
+  });
+});

x-pack/plugins/licensing/common/has_license_info_changed.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 { ILicense } from './types';
+
+/**
+ * Check if 2 potential license instances have changes between them
+ * @internal
+ */
+export function hasLicenseInfoChanged(currentLicense: ILicense | undefined, newLicense: ILicense) {
+  if (currentLicense === newLicense) return false;
+  if (!currentLicense) return true;
+
+  return (
+    newLicense.error !== currentLicense.error ||
+    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, PublicFeatures } from './types';
+import { License } from './license';
+
+function createLicense({
+  license = {},
+  features = {},
+  signature = 'xxxxxxxxx',
+}: {
+  license?: Partial<PublicLicense>;
+  features?: PublicFeatures;
+  signature?: string;
+} = {}) {
+  const defaultLicense = {
+    uid: 'uid-000000001234',
+    status: 'active',
+    type: 'basic',
+    expiryDateInMillis: 5000,
+  };
+
+  const defaultFeatures = {
+    ccr: {
+      isEnabled: true,
+      isAvailable: true,
+    },
+    ml: {
+      isEnabled: false,
+      isAvailable: true,
+    },
+  };
+  return new License({
+    license: Object.assign(defaultLicense, license),
+    features: Object.assign(defaultFeatures, features),
+    signature,
+  });
+}
+
+export const licenseMock = {
+  create: createLicense,
+};