Add tests where missing

x-pack/plugins/event_log/server/es/cluster_client_adapter.test.ts

@@ -140,7 +140,28 @@ describe('createIndexTemplate', () => {
   });
 });
 
+describe('updateIndexTemplate', () => {
+  test('should call cluster with given template', async () => {
+    await clusterClientAdapter.updateIndexTemplate('foo', { args: true });
+    expect(clusterClient.callAsInternalUser).toHaveBeenCalledWith('indices.putTemplate', {
+      name: 'foo',
+      body: { args: true },
+    });
+  });
+
+  test('should throw error when call cluster throws', async () => {
+    clusterClient.callAsInternalUser.mockRejectedValue(new Error('Fail'));
+    await expect(
+      clusterClientAdapter.updateIndexTemplate('foo', { args: true })
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`"Fail"`);
+  });
+});
+
 describe('getIndexTemplate', () => {
+  beforeEach(() => {
+    clusterClient.callAsInternalUser.mockResolvedValue({});
+  });
+
   test('should call cluster with given name', async () => {
     await clusterClientAdapter.getIndexTemplate('foo');
     expect(clusterClient.callAsInternalUser).toHaveBeenCalledWith('indices.getTemplate', {
@@ -189,6 +210,7 @@ describe('createIndex', () => {
     await clusterClientAdapter.createIndex('foo');
     expect(clusterClient.callAsInternalUser).toHaveBeenCalledWith('indices.create', {
       index: 'foo',
+      body: {},
     });
   });
 
@@ -210,3 +232,19 @@ describe('createIndex', () => {
     await clusterClientAdapter.createIndex('foo');
   });
 });
+
+describe('rolloverIndex', () => {
+  test('should call cluster with given body', async () => {
+    await clusterClientAdapter.rolloverIndex({ args: true });
+    expect(clusterClient.callAsInternalUser).toHaveBeenCalledWith('indices.rollover', {
+      args: true,
+    });
+  });
+
+  test('should throw error when call cluster throws', async () => {
+    clusterClient.callAsInternalUser.mockRejectedValue(new Error('Fail'));
+    await expect(
+      clusterClientAdapter.rolloverIndex({ args: true })
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`"Fail"`);
+  });
+});

x-pack/plugins/event_log/server/es/documents.test.ts

@@ -23,11 +23,11 @@ describe('getIndexTemplate()', () => {
   test('returns the correct details of the index template', () => {
     const indexTemplate = getIndexTemplate(esNames);
     expect(indexTemplate.index_patterns).toEqual([esNames.indexPattern]);
-    expect(indexTemplate.aliases[esNames.alias]).toEqual({});
     expect(indexTemplate.settings.number_of_shards).toBeGreaterThanOrEqual(0);
     expect(indexTemplate.settings.number_of_replicas).toBeGreaterThanOrEqual(0);
     expect(indexTemplate.settings['index.lifecycle.name']).toBe(esNames.ilmPolicy);
     expect(indexTemplate.settings['index.lifecycle.rollover_alias']).toBe(esNames.alias);
     expect(indexTemplate.mappings).toMatchObject({});
+    expect(indexTemplate.version).toBeGreaterThanOrEqual(0);
   });
 });

x-pack/plugins/event_log/server/es/init.test.ts

@@ -7,6 +7,10 @@
 import { contextMock } from './context.mock';
 import { initializeEs } from './init';
 
+jest.mock('../lib/get_current_version_as_integer', () => ({
+  getCurrentVersionAsInteger: () => 1,
+}));
+
 describe('initializeEs', () => {
   let esContext = contextMock.create();
 
@@ -61,4 +65,37 @@ describe('initializeEs', () => {
     expect(esContext.esAdapter.doesAliasExist).toHaveBeenCalled();
     expect(esContext.esAdapter.createIndex).not.toHaveBeenCalled();
   });
+
+  test('should migrate index template when kibana version is more recent', async () => {
+    esContext.esAdapter.getIndexTemplate.mockResolvedValue({
+      version: 0,
+    });
+
+    await initializeEs(esContext);
+    expect(esContext.esAdapter.getIndexTemplate).toHaveBeenCalled();
+    expect(esContext.esAdapter.updateIndexTemplate).toHaveBeenCalled();
+    expect(esContext.esAdapter.rolloverIndex).toHaveBeenCalled();
+  });
+
+  test(`shouldn't migrate index template when kibana version is the same`, async () => {
+    esContext.esAdapter.getIndexTemplate.mockResolvedValue({
+      version: 1,
+    });
+
+    await initializeEs(esContext);
+    expect(esContext.esAdapter.getIndexTemplate).toHaveBeenCalled();
+    expect(esContext.esAdapter.updateIndexTemplate).not.toHaveBeenCalled();
+    expect(esContext.esAdapter.rolloverIndex).not.toHaveBeenCalled();
+  });
+
+  test('should log error if template version in Elasticsearch is more recent', async () => {
+    esContext.esAdapter.getIndexTemplate.mockResolvedValue({
+      version: 2,
+    });
+
+    await initializeEs(esContext);
+    expect(esContext.logger.error).toHaveBeenLastCalledWith(
+      'error initializing elasticsearch resources: Index template belongs to a more recent version of Kibana (2)'
+    );
+  });
 });

x-pack/plugins/event_log/server/es/init.ts

@@ -74,10 +74,11 @@ class EsInitializationSteps {
   }
 
   async migrateIndexTemplate() {
+    const updatedTemplateBody = getIndexTemplate(this.esContext.esNames);
     const existingTemplate = await this.esContext.esAdapter.getIndexTemplate(
       this.esContext.esNames.indexTemplate
     );
-    const updatedTemplateBody = getIndexTemplate(this.esContext.esNames);
+
     if (updatedTemplateBody.version > existingTemplate.version) {
       await this.esContext.esAdapter.updateIndexTemplate(
         this.esContext.esNames.indexTemplate,
@@ -91,6 +92,10 @@ class EsInitializationSteps {
           },
         },
       });
+    } else if (updatedTemplateBody.version < existingTemplate.version) {
+      throw new Error(
+        `Index template belongs to a more recent version of Kibana (${existingTemplate.version})`
+      );
     }
   }
 }

x-pack/plugins/event_log/server/lib/get_current_version_as_integer.test.ts

@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+describe('getCurrentVersionAsInteger', () => {
+  beforeEach(() => jest.resetModules());
+
+  test('should parse 8.0.0', () => {
+    jest.mock('../../../../package.json', () => ({
+      version: '8.0.0',
+    }));
+    const { getCurrentVersionAsInteger } = jest.requireActual('./get_current_version_as_integer');
+    expect(getCurrentVersionAsInteger()).toEqual(80000);
+  });
+
+  test('should parse 8.1.0', () => {
+    jest.mock('../../../../package.json', () => ({
+      version: '8.1.0',
+    }));
+    const { getCurrentVersionAsInteger } = jest.requireActual('./get_current_version_as_integer');
+    expect(getCurrentVersionAsInteger()).toEqual(80100);
+  });
+
+  test('should parse 8.1.2', () => {
+    jest.mock('../../../../package.json', () => ({
+      version: '8.1.2',
+    }));
+    const { getCurrentVersionAsInteger } = jest.requireActual('./get_current_version_as_integer');
+    expect(getCurrentVersionAsInteger()).toEqual(80102);
+  });
+
+  test('should parse v8.1.2', () => {
+    jest.mock('../../../../package.json', () => ({
+      version: 'v8.1.2',
+    }));
+    const { getCurrentVersionAsInteger } = jest.requireActual('./get_current_version_as_integer');
+    expect(getCurrentVersionAsInteger()).toEqual(80102);
+  });
+});