From 4edfbd0c2da40ccb5936c83b5f1050d4675fc66f Mon Sep 17 00:00:00 2001 From: Sergi Massaneda Date: Wed, 24 Jan 2024 15:46:32 +0100 Subject: [PATCH] skip test --- .../server/routes/results/get_results.test.ts | 266 +++++++++--------- .../routes/results/post_results.test.ts | 242 ++++++++-------- 2 files changed, 261 insertions(+), 247 deletions(-) diff --git a/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/get_results.test.ts b/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/get_results.test.ts index 24982ddff52613..44f7a97abf0d08 100644 --- a/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/get_results.test.ts +++ b/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/get_results.test.ts @@ -37,171 +37,175 @@ const searchResponse = { // TODO: https://github.com/elastic/kibana/pull/173185#issuecomment-1908034302 describe.skip('getResultsRoute route', () => { - let server: ReturnType; - let { context } = requestContextMock.createTools(); - let logger: MockedLogger; - - const req = requestMock.create({ - method: 'get', - path: RESULTS_ROUTE_PATH, - query: { patterns: 'logs-*,alerts-*' }, - }); + describe('querying', () => { + let server: ReturnType; + let { context } = requestContextMock.createTools(); + let logger: MockedLogger; - beforeEach(() => { - jest.clearAllMocks(); + const req = requestMock.create({ + method: 'get', + path: RESULTS_ROUTE_PATH, + query: { patterns: 'logs-*,alerts-*' }, + }); - server = serverMock.create(); - logger = loggerMock.create(); + beforeEach(() => { + jest.clearAllMocks(); - ({ context } = requestContextMock.createTools()); + server = serverMock.create(); + logger = loggerMock.create(); - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges.mockResolvedValue({ - index: { 'logs-*': { all: true }, 'alerts-*': { all: true } }, - } as unknown as SecurityHasPrivilegesResponse); + ({ context } = requestContextMock.createTools()); - getResultsRoute(server.router, logger); - }); + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges.mockResolvedValue({ + index: { 'logs-*': { all: true }, 'alerts-*': { all: true } }, + } as unknown as SecurityHasPrivilegesResponse); - it('gets result', async () => { - const mockSearch = context.core.elasticsearch.client.asInternalUser.search; - mockSearch.mockResolvedValueOnce(searchResponse); + getResultsRoute(server.router, logger); + }); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(mockSearch).toHaveBeenCalled(); + it('gets result', async () => { + const mockSearch = context.core.elasticsearch.client.asInternalUser.search; + mockSearch.mockResolvedValueOnce(searchResponse); - expect(response.status).toEqual(200); - expect(response.body).toEqual([{ '@timestamp': expect.any(Number), ...resultBody }]); - }); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(mockSearch).toHaveBeenCalled(); - it('handles results data stream error', async () => { - const errorMessage = 'Installation Error!'; - context.dataQualityDashboard.getResultsIndexName.mockRejectedValueOnce(new Error(errorMessage)); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(response.status).toEqual(503); - expect(response.body).toEqual({ - message: expect.stringContaining(errorMessage), - status_code: 503, + expect(response.status).toEqual(200); + expect(response.body).toEqual([{ '@timestamp': expect.any(Number), ...resultBody }]); }); - expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(errorMessage)); - }); - it('handles error', async () => { - const errorMessage = 'Error!'; - const mockSearch = context.core.elasticsearch.client.asInternalUser.search; - mockSearch.mockRejectedValueOnce({ message: errorMessage }); - - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(response.status).toEqual(500); - expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); - }); -}); + it('handles results data stream error', async () => { + const errorMessage = 'Installation Error!'; + context.dataQualityDashboard.getResultsIndexName.mockRejectedValueOnce( + new Error(errorMessage) + ); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(response.status).toEqual(503); + expect(response.body).toEqual({ + message: expect.stringContaining(errorMessage), + status_code: 503, + }); + expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(errorMessage)); + }); -describe('request pattern authorization', () => { - let server: ReturnType; - let { context } = requestContextMock.createTools(); - let logger: MockedLogger; + it('handles error', async () => { + const errorMessage = 'Error!'; + const mockSearch = context.core.elasticsearch.client.asInternalUser.search; + mockSearch.mockRejectedValueOnce({ message: errorMessage }); - const req = requestMock.create({ - method: 'get', - path: RESULTS_ROUTE_PATH, - query: { patterns: 'logs-*,alerts-*' }, + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(response.status).toEqual(500); + expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); + }); }); - beforeEach(() => { - jest.clearAllMocks(); + describe('request pattern authorization', () => { + let server: ReturnType; + let { context } = requestContextMock.createTools(); + let logger: MockedLogger; + + const req = requestMock.create({ + method: 'get', + path: RESULTS_ROUTE_PATH, + query: { patterns: 'logs-*,alerts-*' }, + }); - server = serverMock.create(); - logger = loggerMock.create(); + beforeEach(() => { + jest.clearAllMocks(); - ({ context } = requestContextMock.createTools()); + server = serverMock.create(); + logger = loggerMock.create(); - context.core.elasticsearch.client.asInternalUser.search.mockResolvedValue(searchResponse); + ({ context } = requestContextMock.createTools()); - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges.mockResolvedValue({ - index: { 'logs-*': { all: true }, 'alerts-*': { all: true } }, - } as unknown as SecurityHasPrivilegesResponse); + context.core.elasticsearch.client.asInternalUser.search.mockResolvedValue(searchResponse); - getResultsRoute(server.router, logger); - }); + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges.mockResolvedValue({ + index: { 'logs-*': { all: true }, 'alerts-*': { all: true } }, + } as unknown as SecurityHasPrivilegesResponse); - it('should authorize pattern', async () => { - const mockHasPrivileges = - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; - mockHasPrivileges.mockResolvedValueOnce({ - index: { 'logs-*': { all: true }, 'alerts-*': { all: true } }, - } as unknown as SecurityHasPrivilegesResponse); - - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(mockHasPrivileges).toHaveBeenCalledWith({ - index: [ - { names: ['logs-*', 'alerts-*'], privileges: ['all', 'read', 'view_index_metadata'] }, - ], + getResultsRoute(server.router, logger); }); - expect(context.core.elasticsearch.client.asInternalUser.search).toHaveBeenCalled(); - - expect(response.status).toEqual(200); - expect(response.body).toEqual([{ '@timestamp': expect.any(Number), ...resultBody }]); - }); - it('should search authorized patterns only', async () => { - const mockHasPrivileges = - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; - mockHasPrivileges.mockResolvedValueOnce({ - index: { 'logs-*': { all: false }, 'alerts-*': { all: true } }, - } as unknown as SecurityHasPrivilegesResponse); - - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(context.core.elasticsearch.client.asInternalUser.search).toHaveBeenCalledWith({ - index: expect.any(String), - ...getQuery(['alerts-*']), + it('should authorize pattern', async () => { + const mockHasPrivileges = + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; + mockHasPrivileges.mockResolvedValueOnce({ + index: { 'logs-*': { all: true }, 'alerts-*': { all: true } }, + } as unknown as SecurityHasPrivilegesResponse); + + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(mockHasPrivileges).toHaveBeenCalledWith({ + index: [ + { names: ['logs-*', 'alerts-*'], privileges: ['all', 'read', 'view_index_metadata'] }, + ], + }); + expect(context.core.elasticsearch.client.asInternalUser.search).toHaveBeenCalled(); + + expect(response.status).toEqual(200); + expect(response.body).toEqual([{ '@timestamp': expect.any(Number), ...resultBody }]); }); - expect(response.status).toEqual(200); - }); + it('should search authorized patterns only', async () => { + const mockHasPrivileges = + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; + mockHasPrivileges.mockResolvedValueOnce({ + index: { 'logs-*': { all: false }, 'alerts-*': { all: true } }, + } as unknown as SecurityHasPrivilegesResponse); - it('should not search unauthorized patterns', async () => { - const mockHasPrivileges = - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; - mockHasPrivileges.mockResolvedValueOnce({ - index: { 'logs-*': { all: false }, 'alerts-*': { all: false } }, - } as unknown as SecurityHasPrivilegesResponse); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(context.core.elasticsearch.client.asInternalUser.search).toHaveBeenCalledWith({ + index: expect.any(String), + ...getQuery(['alerts-*']), + }); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(context.core.elasticsearch.client.asInternalUser.search).not.toHaveBeenCalled(); + expect(response.status).toEqual(200); + }); - expect(response.status).toEqual(200); - expect(response.body).toEqual([]); - }); + it('should not search unauthorized patterns', async () => { + const mockHasPrivileges = + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; + mockHasPrivileges.mockResolvedValueOnce({ + index: { 'logs-*': { all: false }, 'alerts-*': { all: false } }, + } as unknown as SecurityHasPrivilegesResponse); - it('handles pattern authorization error', async () => { - const errorMessage = 'Error!'; - const mockHasPrivileges = - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; - mockHasPrivileges.mockRejectedValueOnce({ message: errorMessage }); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(context.core.elasticsearch.client.asInternalUser.search).not.toHaveBeenCalled(); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(response.status).toEqual(500); - expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); - }); -}); + expect(response.status).toEqual(200); + expect(response.body).toEqual([]); + }); + + it('handles pattern authorization error', async () => { + const errorMessage = 'Error!'; + const mockHasPrivileges = + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; + mockHasPrivileges.mockRejectedValueOnce({ message: errorMessage }); -describe('request validation', () => { - let server: ReturnType; - let logger: MockedLogger; - beforeEach(() => { - server = serverMock.create(); - logger = loggerMock.create(); - getResultsRoute(server.router, logger); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(response.status).toEqual(500); + expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); + }); }); - test('disallows invalid query param', () => { - const req = requestMock.create({ - method: 'get', - path: RESULTS_ROUTE_PATH, - query: {}, + describe('request validation', () => { + let server: ReturnType; + let logger: MockedLogger; + beforeEach(() => { + server = serverMock.create(); + logger = loggerMock.create(); + getResultsRoute(server.router, logger); }); - const result = server.validate(req); - expect(result.badRequest).toHaveBeenCalled(); + test('disallows invalid query param', () => { + const req = requestMock.create({ + method: 'get', + path: RESULTS_ROUTE_PATH, + query: {}, + }); + const result = server.validate(req); + + expect(result.badRequest).toHaveBeenCalled(); + }); }); }); diff --git a/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/post_results.test.ts b/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/post_results.test.ts index 606dd853fa567a..98eb67ecbaaa88 100644 --- a/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/post_results.test.ts +++ b/x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/post_results.test.ts @@ -19,152 +19,162 @@ import { resultBody, resultDocument } from './results.mock'; // TODO: https://github.com/elastic/kibana/pull/173185#issuecomment-1908034302 describe.skip('postResultsRoute route', () => { - let server: ReturnType; - let { context } = requestContextMock.createTools(); - let logger: MockedLogger; + describe('indexation', () => { + let server: ReturnType; + let { context } = requestContextMock.createTools(); + let logger: MockedLogger; - const req = requestMock.create({ method: 'post', path: RESULTS_ROUTE_PATH, body: resultBody }); + const req = requestMock.create({ method: 'post', path: RESULTS_ROUTE_PATH, body: resultBody }); - beforeEach(() => { - jest.clearAllMocks(); + beforeEach(() => { + jest.clearAllMocks(); - server = serverMock.create(); - logger = loggerMock.create(); + server = serverMock.create(); + logger = loggerMock.create(); - ({ context } = requestContextMock.createTools()); + ({ context } = requestContextMock.createTools()); - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges.mockResolvedValue({ - has_all_requested: true, - } as unknown as SecurityHasPrivilegesResponse); + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges.mockResolvedValue({ + has_all_requested: true, + } as unknown as SecurityHasPrivilegesResponse); - postResultsRoute(server.router, logger); - }); + postResultsRoute(server.router, logger); + }); - it('indexes result', async () => { - const mockIndex = context.core.elasticsearch.client.asInternalUser.index; - mockIndex.mockResolvedValueOnce({ result: 'created' } as WriteResponseBase); + it('indexes result', async () => { + const mockIndex = context.core.elasticsearch.client.asInternalUser.index; + mockIndex.mockResolvedValueOnce({ result: 'created' } as WriteResponseBase); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(mockIndex).toHaveBeenCalledWith({ - body: { ...resultDocument, '@timestamp': expect.any(Number) }, - index: await context.dataQualityDashboard.getResultsIndexName(), - }); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(mockIndex).toHaveBeenCalledWith({ + body: { ...resultDocument, '@timestamp': expect.any(Number) }, + index: await context.dataQualityDashboard.getResultsIndexName(), + }); - expect(response.status).toEqual(200); - expect(response.body).toEqual({ result: 'created' }); - }); + expect(response.status).toEqual(200); + expect(response.body).toEqual({ result: 'created' }); + }); - it('handles results data stream error', async () => { - const errorMessage = 'Installation Error!'; - context.dataQualityDashboard.getResultsIndexName.mockRejectedValueOnce(new Error(errorMessage)); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(response.status).toEqual(503); - expect(response.body).toEqual({ - message: expect.stringContaining(errorMessage), - status_code: 503, + it('handles results data stream error', async () => { + const errorMessage = 'Installation Error!'; + context.dataQualityDashboard.getResultsIndexName.mockRejectedValueOnce( + new Error(errorMessage) + ); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(response.status).toEqual(503); + expect(response.body).toEqual({ + message: expect.stringContaining(errorMessage), + status_code: 503, + }); + expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(errorMessage)); }); - expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(errorMessage)); - }); - it('handles index error', async () => { - const errorMessage = 'Error!'; - const mockIndex = context.core.elasticsearch.client.asInternalUser.index; - mockIndex.mockRejectedValueOnce({ message: errorMessage }); + it('handles index error', async () => { + const errorMessage = 'Error!'; + const mockIndex = context.core.elasticsearch.client.asInternalUser.index; + mockIndex.mockRejectedValueOnce({ message: errorMessage }); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(response.status).toEqual(500); - expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(response.status).toEqual(500); + expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); + }); }); -}); -describe('request pattern authorization', () => { - let server: ReturnType; - let { context } = requestContextMock.createTools(); - let logger: MockedLogger; + describe('request pattern authorization', () => { + let server: ReturnType; + let { context } = requestContextMock.createTools(); + let logger: MockedLogger; - const req = requestMock.create({ method: 'post', path: RESULTS_ROUTE_PATH, body: resultBody }); + const req = requestMock.create({ method: 'post', path: RESULTS_ROUTE_PATH, body: resultBody }); - beforeEach(() => { - jest.clearAllMocks(); + beforeEach(() => { + jest.clearAllMocks(); - server = serverMock.create(); - logger = loggerMock.create(); + server = serverMock.create(); + logger = loggerMock.create(); - ({ context } = requestContextMock.createTools()); + ({ context } = requestContextMock.createTools()); - context.core.elasticsearch.client.asInternalUser.index.mockResolvedValueOnce({ - result: 'created', - } as WriteResponseBase); - - postResultsRoute(server.router, logger); - }); + context.core.elasticsearch.client.asInternalUser.index.mockResolvedValueOnce({ + result: 'created', + } as WriteResponseBase); - it('should authorize pattern', async () => { - const mockHasPrivileges = - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; - mockHasPrivileges.mockResolvedValueOnce({ - has_all_requested: true, - } as unknown as SecurityHasPrivilegesResponse); - - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(mockHasPrivileges).toHaveBeenCalledWith({ - index: [ - { names: [resultBody.rollup.pattern], privileges: ['all', 'read', 'view_index_metadata'] }, - ], + postResultsRoute(server.router, logger); }); - expect(context.core.elasticsearch.client.asInternalUser.index).toHaveBeenCalled(); - expect(response.status).toEqual(200); - expect(response.body).toEqual({ result: 'created' }); - }); - it('should not index unauthorized pattern', async () => { - const mockHasPrivileges = - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; - mockHasPrivileges.mockResolvedValueOnce({ - has_all_requested: false, - } as unknown as SecurityHasPrivilegesResponse); - - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(mockHasPrivileges).toHaveBeenCalledWith({ - index: [ - { names: [resultBody.rollup.pattern], privileges: ['all', 'read', 'view_index_metadata'] }, - ], + it('should authorize pattern', async () => { + const mockHasPrivileges = + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; + mockHasPrivileges.mockResolvedValueOnce({ + has_all_requested: true, + } as unknown as SecurityHasPrivilegesResponse); + + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(mockHasPrivileges).toHaveBeenCalledWith({ + index: [ + { + names: [resultBody.rollup.pattern], + privileges: ['all', 'read', 'view_index_metadata'], + }, + ], + }); + expect(context.core.elasticsearch.client.asInternalUser.index).toHaveBeenCalled(); + expect(response.status).toEqual(200); + expect(response.body).toEqual({ result: 'created' }); }); - expect(context.core.elasticsearch.client.asInternalUser.index).not.toHaveBeenCalled(); - expect(response.status).toEqual(200); - expect(response.body).toEqual({ result: 'noop' }); - }); + it('should not index unauthorized pattern', async () => { + const mockHasPrivileges = + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; + mockHasPrivileges.mockResolvedValueOnce({ + has_all_requested: false, + } as unknown as SecurityHasPrivilegesResponse); + + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(mockHasPrivileges).toHaveBeenCalledWith({ + index: [ + { + names: [resultBody.rollup.pattern], + privileges: ['all', 'read', 'view_index_metadata'], + }, + ], + }); + expect(context.core.elasticsearch.client.asInternalUser.index).not.toHaveBeenCalled(); + + expect(response.status).toEqual(200); + expect(response.body).toEqual({ result: 'noop' }); + }); - it('handles pattern authorization error', async () => { - const errorMessage = 'Error!'; - const mockHasPrivileges = - context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; - mockHasPrivileges.mockRejectedValueOnce({ message: errorMessage }); + it('handles pattern authorization error', async () => { + const errorMessage = 'Error!'; + const mockHasPrivileges = + context.core.elasticsearch.client.asCurrentUser.security.hasPrivileges; + mockHasPrivileges.mockRejectedValueOnce({ message: errorMessage }); - const response = await server.inject(req, requestContextMock.convertContext(context)); - expect(response.status).toEqual(500); - expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); - }); -}); - -describe('request validation', () => { - let server: ReturnType; - let logger: MockedLogger; - beforeEach(() => { - server = serverMock.create(); - logger = loggerMock.create(); - postResultsRoute(server.router, logger); + const response = await server.inject(req, requestContextMock.convertContext(context)); + expect(response.status).toEqual(500); + expect(response.body).toEqual({ message: errorMessage, status_code: 500 }); + }); }); - test('disallows invalid pattern', () => { - const req = requestMock.create({ - method: 'post', - path: RESULTS_ROUTE_PATH, - body: { rollup: resultBody.rollup }, + describe('request validation', () => { + let server: ReturnType; + let logger: MockedLogger; + beforeEach(() => { + server = serverMock.create(); + logger = loggerMock.create(); + postResultsRoute(server.router, logger); }); - const result = server.validate(req); - expect(result.badRequest).toHaveBeenCalled(); + test('disallows invalid pattern', () => { + const req = requestMock.create({ + method: 'post', + path: RESULTS_ROUTE_PATH, + body: { rollup: resultBody.rollup }, + }); + const result = server.validate(req); + + expect(result.badRequest).toHaveBeenCalled(); + }); }); });