Skip to content

Commit

Permalink
skip test
Browse files Browse the repository at this point in the history
  • Loading branch information
@semd
semd committed Jan 24, 2024
1 parent cca0dfe commit 4edfbd0
Show file tree
Hide file tree
Showing 2 changed files with 261 additions and 247 deletions.
266 changes: 135 additions & 131 deletions x-pack/plugins/ecs_data_quality_dashboard/server/routes/results/get_results.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,171 +37,175 @@ const searchResponse = {

// TODO: https://github.com/elastic/kibana/pull/173185#issuecomment-1908034302
describe.skip('getResultsRoute route', () => {
let server: ReturnType<typeof serverMock.create>;
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<typeof serverMock.create>;
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<typeof serverMock.create>;
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<typeof serverMock.create>;
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<typeof serverMock.create>;
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<typeof serverMock.create>;
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();
});
});
});
Loading

0 comments on commit 4edfbd0

Please sign in to comment.