Mirrors/unleash.unleash
1
0
Fork 0
mirror of https://github.com/Unleash/unleash.git synced 2025-02-23 00:22:19 +01:00
Code Issues Projects Releases Wiki Activity

feat: event search e2e tests (#7755)

Browse Source 
This covers the e2e cases for event search.
This commit is contained in:
Jaanus Sellin 2024-08-05 15:02:35 +03:00 committed by GitHub
parent ecdae7fee7
commit 1a97515adf
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 305 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/lib/features/events/event-service.ts
View File

@ -147,20 +147,32 @@ export default class EventService {
const queryParams: IQueryParam[] = [];
if (params.createdAtFrom) {
const parsed = parseSearchOperatorValue(
'created_at',
params.createdAtFrom,
);
if (parsed) {
queryParams.push({
field: 'created_at',
field: parsed.field,
operator: 'IS_ON_OR_AFTER',
values: [params.createdAtFrom],
values: parsed.values,
});
}
}
if (params.createdAtTo) {
const parsed = parseSearchOperatorValue(
'created_at',
params.createdAtTo,
);
if (parsed) {
queryParams.push({
field: 'created_at',
field: parsed.field,
operator: 'IS_BEFORE',
values: [params.createdAtTo],
values: parsed.values,
});
}
}
if (params.createdBy) {
const parsed = parseSearchOperatorValue(
@ -170,12 +182,15 @@ export default class EventService {
if (parsed) queryParams.push(parsed);
}
if (params.type) {
const parsed = parseSearchOperatorValue('type', params.type);
if (params.feature) {
const parsed = parseSearchOperatorValue(
'feature_name',
params.feature,
);
if (parsed) queryParams.push(parsed);
}
['feature', 'project'].forEach((field) => {
['project', 'type'].forEach((field) => {
if (params[field]) {
const parsed = parseSearchOperatorValue(field, params[field]);
if (parsed) queryParams.push(parsed);

1
src/lib/types/stores/event-store.ts
View File

@ -8,6 +8,7 @@ import type { IQueryParam } from '../../features/feature-toggle/types/feature-to
export interface IEventSearchParams {
project?: string;
query?: string;
feature?: string;
createdAtFrom?: string;
createdAtTo?: string;
createdBy?: string;

276
src/test/e2e/api/admin/event-search.e2e.test.ts
View File

@ -87,3 +87,279 @@ test('should search events by query', async () => {
total: 1,
});
});
test('should filter events by feature', async () => {
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
featureName: 'my_feature_a',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
featureName: 'my_feature_b',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
const { body } = await searchEvents({ feature: 'IS:my_feature_b' });
expect(body).toMatchObject({
events: [
{
type: 'feature-created',
featureName: 'my_feature_b',
},
],
total: 1,
});
});
test('should filter events by project', async () => {
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'another_project',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
const { body } = await searchEvents({ project: 'IS:another_project' });
expect(body).toMatchObject({
events: [
{
type: 'feature-created',
project: 'another_project',
},
],
total: 1,
});
});
test('should filter events by type', async () => {
await eventService.storeEvent({
type: 'change-added',
project: 'default',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: 'feature-created',
project: 'default',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
const { body } = await searchEvents({ type: 'IS:change-added' });
expect(body).toMatchObject({
events: [
{
type: 'change-added',
},
],
total: 1,
});
});
test('should filter events by created by', async () => {
await eventService.storeEvent({
type: FEATURE_CREATED,
createdBy: 'admin1@example.com',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
createdBy: 'admin2@example.com',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
const { body } = await searchEvents({ createdBy: 'IS:admin2@example.com' });
expect(body).toMatchObject({
events: [
{
createdBy: 'admin2@example.com',
},
],
total: 1,
});
});
test('should filter events by created date range', async () => {
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
data: { featureName: 'my_feature_a' },
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
data: { featureName: 'my_feature_b' },
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
const today = new Date();
const { body } = await searchEvents({
createdAtFrom: `IS:${today.toISOString().split('T')[0]}`,
});
expect(body).toMatchObject({
events: [
{
type: FEATURE_CREATED,
data: { featureName: 'my_feature_b' },
},
{
type: FEATURE_CREATED,
data: { featureName: 'my_feature_a' },
},
],
total: 2,
});
});
test('should paginate with offset and limit', async () => {
for (let i = 0; i < 5; i++) {
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
data: { featureName: `my_feature_${i}` },
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
}
const { body: secondPage } = await searchEvents({
offset: '2',
limit: '2',
});
expect(secondPage.events).toMatchObject([
{
data: { featureName: `my_feature_2` },
},
{
data: { featureName: `my_feature_1` },
},
]);
});
test('should filter events by feature using IS_ANY_OF', async () => {
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
featureName: 'my_feature_a',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
featureName: 'my_feature_b',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'default',
featureName: 'my_feature_c',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
const { body } = await searchEvents({
feature: 'IS_ANY_OF:my_feature_a,my_feature_b',
});
expect(body).toMatchObject({
events: [
{
type: 'feature-created',
featureName: 'my_feature_b',
},
{
type: 'feature-created',
featureName: 'my_feature_a',
},
],
total: 2,
});
});
test('should filter events by project using IS_ANY_OF', async () => {
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'project_a',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'project_b',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
await eventService.storeEvent({
type: FEATURE_CREATED,
project: 'project_c',
createdBy: 'test-user',
createdByUserId: TEST_USER_ID,
ip: '127.0.0.1',
});
const { body } = await searchEvents({
project: 'IS_ANY_OF:project_a,project_b',
});
expect(body).toMatchObject({
events: [
{
type: 'feature-created',
project: 'project_b',
},
{
type: 'feature-created',
project: 'project_a',
},
],
total: 2,
});
});