AdvancedSearch.spec.ts

/*
 *  Copyright 2024 Collate.
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *  http://www.apache.org/licenses/LICENSE-2.0
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

import { expect } from '@playwright/test';
import { EntityStatus } from '../../../src/generated/entity/data/searchIndex';
import { COMMON_TIER_TAG } from '../../constant/common';
import { SidebarItem } from '../../constant/sidebar';
import { DataProduct } from '../../support/domain/DataProduct';
import { EntityDataClass } from '../../support/entity/EntityDataClass';
import { MlModelClass } from '../../support/entity/MlModelClass';
import { TableClass } from '../../support/entity/TableClass';
import { TopicClass } from '../../support/entity/TopicClass';
import { Glossary } from '../../support/glossary/Glossary';
import { GlossaryTerm } from '../../support/glossary/GlossaryTerm';
import { UserClass } from '../../support/user/UserClass';
import { performAdminLogin } from '../../utils/admin';
import {
  FIELDS,
  fillRule,
  fillStaticListRule,
  OPERATOR,
  runRuleGroupTests,
  runRuleGroupTestsWithNonExistingValue,
  selectOption,
  showAdvancedSearchDialog,
  verifyAllConditions,
} from '../../utils/advancedSearch';
import { redirectToHomePage } from '../../utils/common';
import { waitForAllLoadersToDisappear } from '../../utils/entity';
import { sidebarClick } from '../../utils/sidebar';
import { test } from '../fixtures/pages';

let user: UserClass;
let table: TableClass;
let glossaryEntity: Glossary;
let table1: TableClass;
let table2: TableClass;
let topic1: TopicClass;
let topic2: TopicClass;

test.describe('Advanced Search', { tag: ['@advanced-search'] }, () => {
  let searchCriteria: Record<string, Array<string>> = {};

  test.beforeAll('Setup pre-requests', async ({ browser }) => {
    test.slow(true);

    user = new UserClass();
    table = new TableClass(undefined, 'Regular');
    table1 = new TableClass();
    table2 = new TableClass();
    topic1 = new TopicClass();
    topic2 = new TopicClass();

    const { apiContext, afterAction } = await performAdminLogin(browser);
    await user.create(apiContext);
    await Promise.allSettled([
      table1.create(apiContext),
      table2.create(apiContext),
      topic1.create(apiContext),
      topic2.create(apiContext),
    ]);
    glossaryEntity = new Glossary(undefined, [
      {
        id: user.responseData.id,
        type: 'user',
        name: user.responseData.name,
        displayName: user.responseData.displayName,
      },
    ]);
    const glossaryTermEntity = new GlossaryTerm(glossaryEntity);

    await glossaryEntity.create(apiContext);
    await glossaryTermEntity.create(apiContext);
    await table.create(apiContext);

    // Add Owner & Tag and domain to the table
    await table1.patch({
      apiContext,
      patchData: [
        {
          op: 'add',
          value: {
            type: 'user',
            id: EntityDataClass.user1.responseData.id,
          },
          path: '/owners/0',
        },
        {
          op: 'add',
          value: {
            tagFQN: 'PersonalData.Personal',
          },
          path: '/tags/0',
        },
        {
          op: 'add',
          path: '/domains/0',
          value: {
            id: EntityDataClass.domain1.responseData.id,
            type: 'domain',
            name: EntityDataClass.domain1.responseData.name,
            displayName: EntityDataClass.domain1.responseData.displayName,
          },
        },
      ],
    });

    // Add data product to the table 1
    await table1.patch({
      apiContext,
      patchData: [
        {
          op: 'add',
          path: '/dataProducts/0',
          value: {
            id: EntityDataClass.dataProduct1.responseData.id,
            type: 'dataProduct',
            name: EntityDataClass.dataProduct1.responseData.name,
            displayName: EntityDataClass.dataProduct1.responseData.displayName,
          },
        },
      ],
    });

    await table2.patch({
      apiContext,
      patchData: [
        {
          op: 'add',
          value: {
            type: 'user',
            id: EntityDataClass.user2.responseData.id,
          },
          path: '/owners/0',
        },
        {
          op: 'add',
          value: {
            tagFQN: 'PII.None',
          },
          path: '/tags/0',
        },
        {
          op: 'add',
          path: '/domains/0',
          value: {
            id: EntityDataClass.domain2.responseData.id,
            type: 'domain',
            name: EntityDataClass.domain2.responseData.name,
            displayName: EntityDataClass.domain2.responseData.displayName,
          },
        },
      ],
    });

    // Add data product to the table 2
    await table2.patch({
      apiContext,
      patchData: [
        {
          op: 'add',
          path: '/dataProducts/0',
          value: {
            id: EntityDataClass.dataProduct3.responseData.id,
            type: 'dataProduct',
            name: EntityDataClass.dataProduct3.responseData.name,
            displayName: EntityDataClass.dataProduct3.responseData.displayName,
          },
        },
      ],
    });

    // Add Tier To the topic 1
    await topic1.patch({
      apiContext,
      patchData: [
        {
          op: 'add',
          path: '/tags/0',
          value: {
            name: COMMON_TIER_TAG[0].name,
            tagFQN: COMMON_TIER_TAG[0].fullyQualifiedName,
            labelType: 'Manual',
            state: 'Confirmed',
          },
        },
      ],
    });

    // Add Tier To the topic 2
    await topic2.patch({
      apiContext,
      patchData: [
        {
          op: 'add',
          path: '/tags/0',
          value: {
            name: COMMON_TIER_TAG[1].name,
            tagFQN: COMMON_TIER_TAG[1].fullyQualifiedName,
            labelType: 'Manual',
            state: 'Confirmed',
          },
        },
      ],
    });

    // Update Search Criteria here
    searchCriteria = {
      ownerDisplayName: [
        EntityDataClass.user1.getUserDisplayName(),
        EntityDataClass.user2.getUserDisplayName(),
      ],
      'tags.tagFQN': ['PersonalData.Personal', 'PII.None'],
      'tier.tagFQN': [
        COMMON_TIER_TAG[0].fullyQualifiedName,
        COMMON_TIER_TAG[1].fullyQualifiedName,
      ],
      'service.displayName.keyword': [
        table1.serviceResponseData.name,
        table2.serviceResponseData.name,
      ],
      'database.displayName.keyword': [
        table1.databaseResponseData.name,
        table2.databaseResponseData.name,
      ],
      'databaseSchema.displayName.keyword': [
        table1.schemaResponseData.name,
        table2.schemaResponseData.name,
      ],
      'columns.name.keyword': [
        table1.entityResponseData.columns[2].name,
        table2.entityResponseData.columns[3].name,
      ],
      'displayName.keyword': [
        table1.entityResponseData.displayName ?? '',
        table2.entityResponseData.displayName ?? '',
      ],
      serviceType: [
        table1.serviceResponseData.serviceType ?? '',
        topic1.serviceResponseData.serviceType ?? '',
      ],
      'messageSchema.schemaFields.name.keyword': [
        topic1.entityResponseData?.messageSchema?.schemaFields?.[0].name ?? '',
        topic2.entityResponseData?.messageSchema?.schemaFields?.[1].name ?? '',
      ],
      'dataModel.columns.name.keyword': [
        EntityDataClass.container1.entityResponseData?.dataModel?.columns?.[0]
          .name ?? '',
        EntityDataClass.container2.entityResponseData?.dataModel?.columns?.[1]
          .name ?? '',
      ],
      dataModelType: [
        EntityDataClass.dashboard1.dataModelResponseData.dataModelType ?? '',
        EntityDataClass.dashboard2.dataModelResponseData.dataModelType ?? '',
      ],
      'fields.name.keyword': [
        EntityDataClass.searchIndex1.entityResponseData?.fields?.[1].name ?? '',
        EntityDataClass.searchIndex2.entityResponseData?.fields?.[3].name ?? '',
      ],
      'tasks.displayName.keyword': [
        EntityDataClass.pipeline1.entityResponseData?.tasks?.[0]?.displayName ??
          '',
        EntityDataClass.pipeline2.entityResponseData?.tasks?.[1]?.displayName ??
          '',
      ],
      'domains.displayName.keyword': [
        EntityDataClass.domain1.responseData.displayName,
        EntityDataClass.domain2.responseData.displayName,
      ],
      'responseSchema.schemaFields.name.keyword': [
        EntityDataClass.apiCollection1.apiEndpointResponseData.responseSchema
          ?.schemaFields[0].name ?? '',
        EntityDataClass.apiCollection2.apiEndpointResponseData.responseSchema
          ?.schemaFields[1].name ?? '',
      ],
      'requestSchema.schemaFields.name.keyword': [
        EntityDataClass.apiCollection1.apiEndpointResponseData.requestSchema
          ?.schemaFields[0].name ?? '',
        EntityDataClass.apiCollection2.apiEndpointResponseData.requestSchema
          ?.schemaFields[1].name ?? '',
      ],
      'name.keyword': [
        table1.entityResponseData.name,
        table2.entityResponseData.name,
      ],
      'project.keyword': [
        EntityDataClass.dashboardDataModel1.entityResponseData.project || '',
        EntityDataClass.dashboardDataModel2.entityResponseData.project || '',
      ],
      'charts.displayName.keyword': [
        EntityDataClass.dashboard1.chartsResponseData.displayName,
        EntityDataClass.dashboard2.chartsResponseData.displayName,
      ],
      'dataProducts.displayName.keyword': [
        EntityDataClass.dataProduct1.responseData.displayName,
        EntityDataClass.dataProduct3.responseData.displayName,
      ],
    };

    await afterAction();
  });

  test.beforeEach(async ({ page }) => {
    await redirectToHomePage(page);
    await sidebarClick(page, SidebarItem.EXPLORE);
  });

  FIELDS.forEach((field) => {
    test(`Verify All conditions for ${field.id} field`, async ({ page }) => {
      test.slow(true);

      await verifyAllConditions(page, field, searchCriteria[field.name][0]);
    });
  });

  Object.values(OPERATOR).forEach(({ name: operator }) => {
    FIELDS.forEach((field) => {
      // Rule based search
      test(`Verify Rule functionality for field ${field.id} with ${operator} operator`, async ({
        page,
      }) => {
        test.slow(true);

        await runRuleGroupTests(page, field, operator, false, searchCriteria);
      });

      // Group based search
      test(`Verify Group functionality for field ${field.id} with ${operator} operator`, async ({
        page,
      }) => {
        test.slow(true);

        await runRuleGroupTests(page, field, operator, true, searchCriteria);
      });
    });
  });

  test('Verify search with non existing value do not result in infinite search', async ({
    page,
  }) => {
    test.slow(true);

    await runRuleGroupTestsWithNonExistingValue(page);
  });
});

const ENTITY_STATUSES = Object.values(EntityStatus);

test.describe(
  'Advanced Search - Entity Status Filter',
  { tag: ['@advanced-search', '@Discovery'] },
  () => {
    // One distinct entity type per status to prove the filter works across entity types
    const glossaryForStatus = new Glossary();
    const glossaryTermApproved = new GlossaryTerm(glossaryForStatus);
    const mlModelDraft = new MlModelClass();
    const dataProductInReview = new DataProduct();

    type StatusEntry = {
      status: EntityStatus;
      endpoint: string;
      id: () => string;
      displayName: () => string;
      fqn: () => string;
    };

    let statusEntries: StatusEntry[];

    test.beforeAll(
      'Create mixed entity types with distinct entity statuses',
      async ({ browser }) => {
        const { apiContext, afterAction } = await performAdminLogin(browser);

        await glossaryForStatus.create(apiContext);
        await Promise.all([
          glossaryTermApproved.create(apiContext),
          mlModelDraft.create(apiContext),
          dataProductInReview.create(apiContext),
        ]);

        statusEntries = [
          {
            status: EntityStatus.Approved,
            endpoint: 'glossaryTerms',
            id: () => glossaryTermApproved.responseData.id,
            displayName: () => glossaryTermApproved.data.displayName,
            fqn: () => glossaryTermApproved.responseData.fullyQualifiedName,
          },
          {
            status: EntityStatus.Draft,
            endpoint: 'mlmodels',
            id: () => mlModelDraft.entityResponseData.id,
            displayName: () => mlModelDraft.entity.displayName,
            fqn: () => mlModelDraft.entityResponseData.fullyQualifiedName,
          },
          {
            status: EntityStatus.InReview,
            endpoint: 'dataProducts',
            id: () => dataProductInReview.responseData.id ?? '',
            displayName: () => dataProductInReview.data.displayName,
            fqn: () =>
              dataProductInReview.responseData.fullyQualifiedName ?? '',
          },
        ];

        // Patch entityStatus on each entity
        await Promise.all(
          statusEntries.map(({ id, status, endpoint }) =>
            apiContext.patch(`/api/v1/${endpoint}/${id()}`, {
              data: [{ op: 'add', path: '/entityStatus', value: status }],
              headers: { 'Content-Type': 'application/json-patch+json' },
            })
          )
        );

        await afterAction();
      }
    );

    test.beforeEach(async ({ page }) => {
      await redirectToHomePage(page);
      await sidebarClick(page, SidebarItem.EXPLORE);
    });

    test('All entity status options are visible in the Status dropdown', async ({
      page,
    }) => {
      test.slow();

      await test.step('Open advanced search dialog', async () => {
        await showAdvancedSearchDialog(page);
      });

      await test.step('Select Status field and == operator', async () => {
        const ruleLocator = page.locator('.rule').nth(0);
        await selectOption(
          page,
          ruleLocator.locator('.rule--field .ant-select'),
          'Status',
          true
        );
        await selectOption(
          page,
          ruleLocator.locator('.rule--operator .ant-select'),
          '=='
        );
      });

      await test.step('Open Status value dropdown and verify all hard-coded options appear', async () => {
        const ruleLocator = page.locator('.rule').nth(0);
        await ruleLocator.locator('.widget--widget > .ant-select').click();

        const dropdown = page
          .locator('.ant-select-dropdown')
          .filter({ hasText: EntityStatus.Approved })
          .last();

        await expect(dropdown).toBeVisible();

        for (const status of ENTITY_STATUSES) {
          await expect(
            dropdown
              .locator('.ant-select-item-option')
              .filter({ hasText: new RegExp(`^${status}$`, 'i') })
              .first()
          ).toBeVisible();
        }
      });
    });

    test('Filtering by status "==" shows matching entity and hides others across entity types', async ({
      page,
    }) => {
      test.slow();

      for (const entry of statusEntries) {
        const { status } = entry;
        const matchedName = entry.displayName();

        await test.step(`Apply Status == "${status}" AND Name == "${matchedName}"`, async () => {
          await showAdvancedSearchDialog(page);

          await fillStaticListRule(page, {
            fieldLabel: 'Status',
            condition: '==',
            value: status,
            ruleIndex: 1,
          });

          await page.getByTestId('advanced-search-add-rule').nth(1).click();

          await fillRule(page, {
            condition: '==',
            field: { id: 'Display Name', name: 'displayName.keyword' },
            searchCriteria: matchedName,
            index: 2,
          });

          const searchRes = page.waitForResponse(
            '/api/v1/search/query?*index=dataAsset*'
          );
          await page.getByTestId('apply-btn').click();
          await searchRes;
          await waitForAllLoadersToDisappear(page);
        });

        await test.step('Filter chip shows the applied status', async () => {
          await expect(
            page.getByTestId('advance-search-filter-container')
          ).toContainText(`'${status}'`);
        });

        await test.step(`"${matchedName}" (${entry.endpoint}) is visible`, async () => {
          await expect(
            page.getByTestId(`table-data-card_${entry.fqn()}`)
          ).toBeVisible();
        });

        await test.step('Entities with other statuses are not in results', async () => {
          const otherEntries = statusEntries.filter((e) => e.status !== status);

          for (const other of otherEntries) {
            await expect(
              page.getByTestId(`table-data-card_${other.fqn()}`)
            ).not.toBeVisible();
          }
        });

        await page.getByTestId('clear-filters').click();
      }
    });

    test('Filtering by status "!=" excludes matched entity but shows all other entity types', async ({
      page,
    }) => {
      test.slow();

      const targetEntry = statusEntries.find(
        (e) => e.status === EntityStatus.Approved
      )!;
      const approvedName = targetEntry.displayName();
      const otherEntries = statusEntries.filter(
        (e) => e.status !== EntityStatus.Approved
      );

      await test.step('Apply Status != "Approved" AND Name == approved entity name', async () => {
        await showAdvancedSearchDialog(page);

        await fillStaticListRule(page, {
          fieldLabel: 'Status',
          condition: '!=',
          value: EntityStatus.Approved,
          ruleIndex: 1,
        });

        await page.getByTestId('advanced-search-add-rule').nth(1).click();

        await fillRule(page, {
          condition: '==',
          field: { id: 'Display Name', name: 'displayName.keyword' },
          searchCriteria: approvedName,
          index: 2,
        });

        const searchRes = page.waitForResponse(
          '/api/v1/search/query?*index=dataAsset*'
        );
        await page.getByTestId('apply-btn').click();
        await searchRes;
        await waitForAllLoadersToDisappear(page);
      });

      await test.step('Filter chip reflects the != condition', async () => {
        await expect(
          page.getByTestId('advance-search-filter-container')
        ).toContainText(`'${EntityStatus.Approved}'`);
      });

      await test.step('GlossaryTerm with Approved status is not visible', async () => {
        await expect(
          page.getByTestId(`table-data-card_${targetEntry.fqn()}`)
        ).not.toBeVisible();
      });

      await test.step('Draft and In Review entities appear when searched by their name and non-Approved status', async () => {
        for (const entry of otherEntries) {
          await page.getByTestId('clear-filters').click();
          await showAdvancedSearchDialog(page);

          await fillStaticListRule(page, {
            fieldLabel: 'Status',
            condition: '!=',
            value: EntityStatus.Approved,
            ruleIndex: 1,
          });

          await page.getByTestId('advanced-search-add-rule').nth(1).click();

          await fillRule(page, {
            condition: '==',
            field: { id: 'Display Name', name: 'displayName.keyword' },
            searchCriteria: entry.displayName(),
            index: 2,
          });

          const searchRes = page.waitForResponse(
            '/api/v1/search/query?*index=dataAsset*'
          );
          await page.getByTestId('apply-btn').click();
          await searchRes;
          await waitForAllLoadersToDisappear(page);

          await expect(
            page.getByTestId(`table-data-card_${entry.fqn()}`)
          ).toBeVisible();
        }
      });

      await page.getByTestId('clear-filters').click();
    });
  }
);