Data Asset rule enforcement on ui (#24049)

* data asset rule enforcement on ui

* added multi user and multi team support at same time

* fix the multi user case which wasn't working correctly and clean the ui as well

* fix the rule condition for glossary

* fix the glossary dropdown getting closed on select select after selection where we should wait for footer dropdown button action

* added playwright test for data asset rules table

* fix unit test and supported playwright test for table entity

* change the method and variable name for better readability

* naming convention fix around the glossary validation rule

* supported playwright test for all the entities

* supported in service entities

* spearate the test of rules enable and disable state and added supported in glossaryand teams page of rules owner

* Update generated TypeScript types

* fix the unit test and supported rule in tags page

* fix the generated type issue

* fix he domain single select where de-selecting throwing error and fix type

* modify the playwrigth config so dataAssetRules should be run after the chromium is finish executing so the global run changes won't interrupt other test

* fix all unit test

* fix the test failing in dataAssetHeader

* trying the chromium parallel test running

* modifyed yaml files to run the data asset rules after all machine runs is completed

* change the test running order in playwright config

* reverted the playwright config

* run the data asset rules in only one runner

* added support for multiple user and team combination in ownerLabel compoennt

* fix the placemnet issue, reduce the team font to 12 and minor cleanup

* modify many owner component cases as per ui

* clear ruleEnforcementProvider and useEntityRules hooks

* change the dropdown on owner user to mui component

* fix unit test and make chnages in playwright postgress around test running

* fix unit test failing

* fix some playwright test due to rule enforcement and made changes in CI playeright config to only run dataasset on container 6

* reverted the baseurl

* fix the version view for owner, fix some failing playwright test and re-modify the postgress script to run test

* supported the placement option for owner in case of user and team both and postgress e2e change

* remove the other e2e file changes and fix playwright around rules changes

* fix the e2e command

* fix the failing test around disabled rule and based on comments made fix

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: Ashish Gupta

.github/workflows/mysql-nightly-e2e.yml

@@ -189,4 +189,4 @@ jobs:
           SLACK_BOT_USER_OAUTH_TOKEN: ${{ secrets.E2E_SLACK_BOT_OAUTH_TOKEN }}
         run: |
           npx playwright merge-reports --reporter json ./blob-reports > merged_tests_results.json
-          npx playwright-slack-report -c playwright/slack-cli.config.json -j merged_tests_results.json > slack_report.json
+          npx playwright-slack-report -c playwright/slack-cli.config.json -j merged_tests_results.json > slack_report.json

.github/workflows/playwright-postgresql-e2e.yml

@@ -27,7 +27,7 @@ on:
       - 'openmetadata-dist/**'
       - 'docker/**'
       - '!docker/development/docker-compose.yml'
-      - '!docker/development/docker-compose-postgres.yml' 
+      - '!docker/development/docker-compose-postgres.yml'
 
 permissions:
   contents: read
@@ -109,11 +109,35 @@ jobs:
       - name: Run Playwright tests
         working-directory: openmetadata-ui/src/main/resources/ui/
         run: |
-          if [[ "${{ contains(github.event.pull_request.changed_files, 'ingestion/') }}" == "true" ]]; then
-            npx playwright test --grep @ingestion --shard=${{ matrix.shardIndex }}/${{ matrix.shardTotal }}
+          if [ "${{ matrix.shardIndex }}" -eq "1" ]; then
+            echo "🔹 Running DataAssetRules-only tests on shard 1"
+
+            # The testMatch pattern ensures only DataAssetRules*.spec.ts files run
+            npx playwright test \
+              --project=setup \
+              --project=DataAssetRulesEnabled \
+              --project=DataAssetRulesDisabled
+
           else
-            npx playwright test --shard=${{ matrix.shardIndex }}/${{ matrix.shardTotal }}
+            # Shards 2-6 handle chromium tests (5 workers total)
+            CHROMIUM_SHARD=$(( ${{ matrix.shardIndex }} - 1 ))
+            if [[ "${{ contains(github.event.pull_request.changed_files, 'ingestion/') }}" == "true" ]]; then
+              echo "🔹 Running ingestion tests on chromium shard ${CHROMIUM_SHARD}/5"
+              npx playwright test \
+                --project=chromium \
+                --grep @ingestion \
+                --grep-invert @dataAssetRules \
+                --shard=${CHROMIUM_SHARD}/5
+
+            else
+              echo "🔹 Running all other tests (excluding DataAssetRules) on chromium shard ${CHROMIUM_SHARD}/5"
+              npx playwright test \
+                --project=chromium \
+                --grep-invert @dataAssetRules \
+                --shard=${CHROMIUM_SHARD}/5
+            fi
           fi
+
         env:
           PLAYWRIGHT_IS_OSS: true
           PLAYWRIGHT_SNOWFLAKE_USERNAME: ${{ secrets.TEST_SNOWFLAKE_USERNAME }}

.github/workflows/postgresql-nightly-e2e.yml

@@ -189,4 +189,4 @@ jobs:
           SLACK_BOT_USER_OAUTH_TOKEN: ${{ secrets.E2E_SLACK_BOT_OAUTH_TOKEN }}
         run: |
           npx playwright merge-reports --reporter json ./blob-reports > merged_tests_results.json
-          npx playwright-slack-report -c playwright/slack-cli.config.json -j merged_tests_results.json > slack_report.json
+          npx playwright-slack-report -c playwright/slack-cli.config.json -j merged_tests_results.json > slack_report.json

openmetadata-ui/src/main/resources/ui/playwright.config.ts

@@ -76,8 +76,12 @@ export default defineConfig({
       // Added admin setup as a dependency. This will authorize the page with an admin user before running the test. doc: https://playwright.dev/docs/auth#multiple-signed-in-roles
       dependencies: ['setup', 'entity-data-setup'],
       grepInvert: /data-insight/,
-      testIgnore: ['**/nightly/**'],
       teardown: 'entity-data-teardown',
+      testIgnore: [
+        '**/nightly/**',
+        '**/DataAssetRulesEnabled.spec.ts',
+        '**/DataAssetRulesDisabled.spec.ts',
+      ],
     },
     {
       name: 'entity-data-teardown',
@@ -95,6 +99,20 @@ export default defineConfig({
       grep: /data-insight/,
       teardown: 'entity-data-teardown',
     },
+    {
+      name: 'DataAssetRulesEnabled',
+      testMatch: '**/DataAssetRulesEnabled.spec.ts',
+      use: { ...devices['Desktop Chrome'] },
+      dependencies: ['setup'],
+      fullyParallel: true,
+    },
+    {
+      name: 'DataAssetRulesDisabled',
+      testMatch: '**/DataAssetRulesDisabled.spec.ts',
+      use: { ...devices['Desktop Chrome'] },
+      dependencies: ['DataAssetRulesEnabled'],
+      fullyParallel: true,
+    },
   ],
 
   // Increase timeout for the test

openmetadata-ui/src/main/resources/ui/playwright/constant/settings.ts

@@ -91,6 +91,7 @@ export enum GlobalSettingOptions {
   LINEAGE_CONFIG = 'lineageConfig',
   OM_URL_CONFIG = 'om-url-config',
   SEARCH_SETTINGS = 'search-settings',
+  DATA_ASSET_RULES = 'dataAssetRules',
   DOMAINS = 'domains',
   ONLINE_USERS = 'online-users',
   CHARTS = 'charts',
@@ -238,6 +239,10 @@ export const SETTINGS_OPTIONS_PATH = {
     GlobalSettingsMenuCategory.PREFERENCES,
     `${GlobalSettingsMenuCategory.PREFERENCES}.${GlobalSettingOptions.SEARCH_SETTINGS}`,
   ],
+  [GlobalSettingOptions.DATA_ASSET_RULES]: [
+    GlobalSettingsMenuCategory.PREFERENCES,
+    `${GlobalSettingsMenuCategory.PREFERENCES}.${GlobalSettingOptions.DATA_ASSET_RULES}`,
+  ],
   [GlobalSettingOptions.SSO]: [GlobalSettingsMenuCategory.SSO],
 };
 

openmetadata-ui/src/main/resources/ui/playwright/e2e/Features/DataAssetRulesDisabled.spec.ts

@@ -0,0 +1,279 @@
+/*
+ *  Copyright 2025 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 { DataProduct } from '../../support/domain/DataProduct';
+import { Domain } from '../../support/domain/Domain';
+import { ApiCollectionClass } from '../../support/entity/ApiCollectionClass';
+import { ApiEndpointClass } from '../../support/entity/ApiEndpointClass';
+import { ChartClass } from '../../support/entity/ChartClass';
+import { ContainerClass } from '../../support/entity/ContainerClass';
+import { DashboardClass } from '../../support/entity/DashboardClass';
+import { DashboardDataModelClass } from '../../support/entity/DashboardDataModelClass';
+import { DatabaseClass } from '../../support/entity/DatabaseClass';
+import { DatabaseSchemaClass } from '../../support/entity/DatabaseSchemaClass';
+import { DirectoryClass } from '../../support/entity/DirectoryClass';
+import { FileClass } from '../../support/entity/FileClass';
+import { MetricClass } from '../../support/entity/MetricClass';
+import { MlModelClass } from '../../support/entity/MlModelClass';
+import { PipelineClass } from '../../support/entity/PipelineClass';
+import { SearchIndexClass } from '../../support/entity/SearchIndexClass';
+import { ApiServiceClass } from '../../support/entity/service/ApiServiceClass';
+import { DashboardServiceClass } from '../../support/entity/service/DashboardServiceClass';
+import { DatabaseServiceClass } from '../../support/entity/service/DatabaseServiceClass';
+import { DriveServiceClass } from '../../support/entity/service/DriveServiceClass';
+import { MessagingServiceClass } from '../../support/entity/service/MessagingServiceClass';
+import { MlmodelServiceClass } from '../../support/entity/service/MlmodelServiceClass';
+import { PipelineServiceClass } from '../../support/entity/service/PipelineServiceClass';
+import { SearchIndexServiceClass } from '../../support/entity/service/SearchIndexServiceClass';
+import { StorageServiceClass } from '../../support/entity/service/StorageServiceClass';
+import { SpreadsheetClass } from '../../support/entity/SpreadsheetClass';
+import { StoredProcedureClass } from '../../support/entity/StoredProcedureClass';
+import { TableClass } from '../../support/entity/TableClass';
+import { TopicClass } from '../../support/entity/TopicClass';
+import { WorksheetClass } from '../../support/entity/WorksheetClass';
+import { Glossary } from '../../support/glossary/Glossary';
+import { GlossaryTerm } from '../../support/glossary/GlossaryTerm';
+import { TeamClass } from '../../support/team/TeamClass';
+import { UserClass } from '../../support/user/UserClass';
+import { performAdminLogin } from '../../utils/admin';
+import {
+  assignDataProduct,
+  assignDomain,
+  redirectToHomePage,
+} from '../../utils/common';
+import {
+  DATA_ASSET_RULES,
+  DEFAULT_DATA_ASSET_RULES,
+} from '../../utils/dataAssetRules';
+import { addMultiOwner, assignGlossaryTerm } from '../../utils/entity';
+import { test } from '../fixtures/pages';
+
+const entities = [
+  ApiEndpointClass,
+  TableClass,
+  StoredProcedureClass,
+  DashboardClass,
+  PipelineClass,
+  TopicClass,
+  MlModelClass,
+  ContainerClass,
+  SearchIndexClass,
+  DashboardDataModelClass,
+  MetricClass,
+  ChartClass,
+  DirectoryClass,
+  FileClass,
+  SpreadsheetClass,
+  WorksheetClass,
+  ApiServiceClass,
+  ApiCollectionClass,
+  DatabaseServiceClass,
+  DashboardServiceClass,
+  MessagingServiceClass,
+  MlmodelServiceClass,
+  PipelineServiceClass,
+  SearchIndexServiceClass,
+  StorageServiceClass,
+  DatabaseClass,
+  DatabaseSchemaClass,
+  DriveServiceClass,
+] as const;
+
+const user = new UserClass();
+const user2 = new UserClass();
+const team = new TeamClass();
+const table = new TableClass();
+const table2 = new TableClass();
+const table3 = new TableClass();
+const domain = new Domain();
+const domain2 = new Domain();
+const testDataProducts = [new DataProduct([domain]), new DataProduct([domain])];
+const createdDataProducts: DataProduct[] = [];
+const glossary = new Glossary();
+const glossaryTerm = new GlossaryTerm(glossary);
+const glossaryTerm2 = new GlossaryTerm(glossary);
+
+test.beforeAll('Setup pre-requests', async ({ browser }) => {
+  test.slow(true);
+
+  const { apiContext, afterAction } = await performAdminLogin(browser);
+  await user.create(apiContext);
+  await user2.create(apiContext);
+  await team.create(apiContext);
+  await table.create(apiContext);
+  await table2.create(apiContext);
+  await table3.create(apiContext);
+  await domain.create(apiContext);
+  await domain2.create(apiContext);
+  for (const dp of testDataProducts) {
+    await dp.create(apiContext);
+    createdDataProducts.push(dp);
+  }
+  await glossary.create(apiContext);
+  await glossaryTerm.create(apiContext);
+  await glossaryTerm2.create(apiContext);
+
+  // Enable All the Data Asset Rules
+  await apiContext.put(`/api/v1/system/settings`, {
+    data: {
+      config_type: 'entityRulesSettings',
+      config_value: {
+        entitySemantics: DATA_ASSET_RULES.map((item) => ({
+          ...item,
+          enabled: false,
+        })),
+      },
+    },
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+
+  await afterAction();
+});
+
+test.afterAll('Cleanup', async ({ browser }) => {
+  const { apiContext, afterAction } = await performAdminLogin(browser);
+  // Reset Rules to Default
+  await apiContext.put(`/api/v1/system/settings`, {
+    data: {
+      config_type: 'entityRulesSettings',
+      config_value: {
+        entitySemantics: DEFAULT_DATA_ASSET_RULES,
+      },
+    },
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+
+  await afterAction();
+});
+
+test.describe(
+  `Data Asset Rules Disabled`,
+  {
+    tag: '@dataAssetRules',
+  },
+  () => {
+    for (const EntityClass of entities) {
+      const entity = new EntityClass();
+      const entityName = entity.getType();
+
+      test(`Verify the ${entityName} entity item action after rules disabled`, async ({
+        page,
+        browser,
+      }) => {
+        test.slow(true);
+
+        const { apiContext, afterAction } = await performAdminLogin(browser);
+        await entity.create(apiContext);
+        await afterAction();
+
+        await redirectToHomePage(page);
+        await entity.visitEntityPage(page);
+
+        // Assign and Team and User both owner together
+        const teamName = team.responseData.displayName;
+        await addMultiOwner({
+          page,
+          ownerNames: [user.getUserDisplayName(), user2.getUserDisplayName()],
+          activatorBtnDataTestId: 'edit-owner',
+          resultTestId: 'data-assets-header',
+          endpoint: entity.endpoint,
+          type: 'Users',
+        });
+
+        await page.click(`[data-testid="edit-owner"]`);
+
+        await expect(
+          page.locator("[data-testid='select-owner-tabs']")
+        ).toBeVisible();
+
+        await page.waitForSelector(
+          '[data-testid="select-owner-tabs"] [data-testid="loader"]',
+          { state: 'detached' }
+        );
+
+        await page
+          .locator("[data-testid='select-owner-tabs']")
+          .getByRole('tab', { name: 'Teams' })
+          .click();
+
+        await page.waitForSelector(
+          '[data-testid="select-owner-tabs"] [data-testid="loader"]',
+          { state: 'detached' }
+        );
+
+        const searchUser = page.waitForResponse(
+          `/api/v1/search/query?q=*${encodeURIComponent(teamName)}*`
+        );
+        await page.getByTestId(`owner-select-teams-search-bar`).fill(teamName);
+        await searchUser;
+
+        const ownerItem = page.getByRole('listitem', {
+          name: teamName,
+          exact: true,
+        });
+
+        await ownerItem.waitFor({ state: 'visible' });
+        await ownerItem.click();
+        const patchRequest = page.waitForResponse(
+          `/api/v1/${entity.endpoint}/*`
+        );
+        await page
+          .locator('[id^="rc-tabs-"][id$="-panel-teams"]')
+          .getByTestId('selectable-list-update-btn')
+          .click();
+        await patchRequest;
+
+        await expect(
+          page.getByTestId('data-assets-header').getByTestId(`${teamName}`)
+        ).toBeVisible();
+
+        for (const name of [
+          user.getUserDisplayName(),
+          user2.getUserDisplayName(),
+          teamName,
+        ]) {
+          await expect(
+            page.getByTestId('data-assets-header').getByTestId(`${name}`)
+          ).toBeVisible();
+        }
+
+        await assignDomain(page, domain.responseData);
+        await assignDomain(page, domain2.responseData, false);
+
+        await expect(page.getByTestId('domain-count-button')).toBeVisible();
+
+        // Add Multiple DataProduct, since default single select is off
+        if (!entityName.includes('Service')) {
+          await assignDataProduct(page, domain.responseData, [
+            createdDataProducts[0].responseData,
+          ]);
+
+          await assignDataProduct(
+            page,
+            domain.responseData,
+            [createdDataProducts[1].responseData],
+            'Edit'
+          );
+        }
+
+        // Add Multiple GlossaryTerm to Table
+        await assignGlossaryTerm(page, glossaryTerm.responseData);
+        await assignGlossaryTerm(page, glossaryTerm2.responseData, 'Edit');
+      });
+    }
+  }
+);