Feature #18173: Version API Improvements, Last x versions order by desc, versions from specific timeline, versions for specific metadata changes, sdk support and UI integration #26307

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged

pmbrull merged 35 commits into main from 18173

Apr 23, 2026

.agents/skills/playwright-validation/SKILL.md

-Original file line number
+Diff line change
@@ -0,0 +1,175 @@
+    ---
+    name: playwright-validation
+    description: Use when validating UI changes in a branch require Playwright E2E testing. Reviews branch changes, validates UI with Playwright MCP, and adds missing test cases.
+    ---
+    # Playwright Validation Skill
+    This skill guides you through validating UI changes and ensuring comprehensive Playwright E2E test coverage.
+    ## When to Use
+    - After completing UI feature development
+    - Before creating a PR for UI changes
+    - When reviewing UI-related branches
+    - To verify existing Playwright tests cover all scenarios
+    ## Workflow
+    ### Phase 1: Review Branch Changes
+. **Identify changed files vs main:**
+       ```bash
+       git diff main --stat
+       git diff main --name-only | grep -E "\.(tsx?|less|css|scss)$"
+       ```
+. **Focus on UI component changes:**
+       ```bash
+       git diff main -- "openmetadata-ui/src/main/resources/ui/src/components/**" --stat
+       ```
+. **Check for existing Playwright tests:**
+       ```bash
+       git diff main --name-only | grep -E "playwright.*\.spec\.ts$"
+       ```
+. **Read the changed component files** to understand the UI modifications
+    ### Phase 2: Review Existing Playwright Tests
+. **Locate relevant test files:**
+       - Check `playwright/e2e/Pages/` for page-level tests
+       - Check `playwright/e2e/Features/` for feature-specific tests
+       - Use Glob/Grep to find tests related to the feature
+. **Analyze test coverage:**
+       - Read the existing test file(s)
+       - Identify the test scenarios already covered
+       - Note any gaps in coverage based on the UI changes
+. **Review test utilities:**
+       - Check `playwright/utils/` for helper functions
+       - Check `playwright/support/` for entity classes and fixtures
+    ### Phase 3: Validate with Playwright MCP
+. **Start the browser and navigate:**
+       ```
+       mcp__playwright__browser_navigate to http://localhost:8585
+       ```
+. **Authenticate if needed:**
+       - Use `mcp__playwright__browser_fill_form` for login
+       - Default admin: `admin@open-metadata.org` / `admin`
+. **Navigate to the feature area:**
+       - Use `mcp__playwright__browser_click` for navigation
+       - Use `mcp__playwright__browser_snapshot` to inspect page state
+. **Validate UI behavior:**
+       - Test the main user flows
+       - Verify visual elements (icons, badges, labels)
+       - Check interactive elements (buttons, dropdowns, forms)
+       - Verify state changes and API calls
+. **Document findings:**
+       - Note what works correctly
+       - Identify any issues or missing functionality
+       - List scenarios not covered by existing tests
+    ### Phase 4: Add Missing Test Cases
+. **Create a TodoWrite checklist** of missing test scenarios
+. **For each missing test case:**
+       a. **Add necessary test fixtures** in `beforeAll`:
+          - Create new entity instances (TableClass, DataProduct, etc.)
+          - Set up required relationships (domains, assets)
+       b. **Add cleanup** in `afterAll`:
+          - Delete created entities in reverse order
+       c. **Write the test** following the pattern:
+          ```typescript
+          test('Descriptive Test Name - What it validates', async ({ page }) => {
+            test.setTimeout(300000);
+            await test.step('Step description', async () => {
+              // Test actions and assertions
+            });
+            await test.step('Next step', async () => {
+              // More actions and assertions
+            });
+          });
+          ```
+. **Test patterns to cover:**
+       - Happy path (expected behavior)
+       - Edge cases (empty states, max values)
+       - Error handling (invalid inputs, failed requests)
+       - State transitions (before/after actions)
+       - UI feedback (loading states, success/error messages)
+       - Permissions (disabled buttons, restricted actions)
+. **Run lint check:**
+       ```bash
+       yarn eslint playwright/e2e/Pages/YourTest.spec.ts
+       ```
+    ## Common Test Utilities
+    ### Navigation
+    ```typescript
+    import { sidebarClick } from '../../utils/sidebar';
+    import { redirectToHomePage } from '../../utils/common';
+    import { selectDataProduct, selectDomain } from '../../utils/domain';
+    ```
+    ### Waiting
+    ```typescript
+    import { waitForAllLoadersToDisappear } from '../../utils/entity';
+    await page.waitForLoadState('networkidle');
+    await page.waitForSelector('[data-testid="loader"]', { state: 'detached' });
+    ```
+    ### API Responses
+    ```typescript
+    const response = page.waitForResponse('/api/v1/endpoint*');
+    await someAction();
+    await response;
+    expect((await response).status()).toBe(200);
+    ```
+    ### Assertions
+    ```typescript
+    await expect(page.getByTestId('element')).toBeVisible();
+    await expect(page.getByTestId('element')).toContainText('text');
+    await expect(page.locator('.class')).not.toBeVisible();
+    ```
+    ## Checklist Before Completion
+    - [ ] All UI changes have corresponding test coverage
+    - [ ] Tests cover both positive and negative scenarios
+    - [ ] Tests verify visual indicators (icons, badges, states)
+    - [ ] Tests validate API interactions
+    - [ ] Lint check passes with no errors
+    - [ ] Test fixtures are properly created and cleaned up
+    - [ ] Test timeouts are appropriate (300000ms for complex tests)
+    ## Example: Data Contract Inheritance Tests
+    For reference, see the comprehensive test coverage in:
+    `playwright/e2e/Pages/DataContractInheritance.spec.ts`
+    This file demonstrates:
+    - Multiple entity setup in beforeAll
+    - Domain assignment patches
+    - Contract creation and validation
+    - Inheritance icon verification
+    - Action button state verification (disabled/enabled)
+    - API response validation (POST vs PATCH)
+    - Fallback behavior testing

.agents/skills/playwright/SKILL.md

-Original file line number
+Diff line change
@@ -0,0 +1,123 @@
+    ---
+    name: playwright-test
+    description: Generate robust, zero-flakiness Playwright E2E tests following OpenMetadata patterns. Creates comprehensive test files with proper waits, API validation, multi-role permissions, and complete entity lifecycle management.
+    user-invocable: true
+    ---
+    # Playwright Test Generator - OpenMetadata
+    Generate production-ready, zero-flakiness Playwright tests following OpenMetadata conventions.
+    ## Usage
+    ```
+    /playwright-test
+    Feature: <feature name>
+    Category: <Features|Pages|Flow|VersionPages>
+    Entity: <Table|Dashboard|Pipeline|Topic|Database|User|Team|Glossary|Other>
+    Domain: <Governance|Discovery|Platform|Observability|Integration>
+    Scenarios:
+      - <scenario 1 description>
+      - <scenario 2 description>
+      - <scenario 3 description>
+    Roles: <admin|dataConsumer|dataSteward|owner> (optional, defaults to admin)
+    ```
+    ## Quick Example
+    ```
+    /playwright-test
+    Feature: Data Quality Rules
+    Category: Features
+    Entity: Table
+    Domain: Observability
+    Scenarios:
+      - Admin can create and configure data quality rules
+      - Data consumer can view test results but not edit rules
+      - Test results are persisted after page reload
+    Roles: admin, dataConsumer
+    ```
+    ---
+    ## Instructions
+    ### Step 1: Read the Handbook FIRST
+    **CRITICAL**: Before generating any tests, read and apply ALL patterns from:
+    ```
+    openmetadata-ui/src/main/resources/ui/playwright/PLAYWRIGHT_DEVELOPER_HANDBOOK.md
+    ```
+    The handbook contains:
+    - Testing philosophy (user-centric, behavior-focused)
+    - Anti-flakiness patterns (the :visible selector chain pattern, etc.)
+    - Test timeout strategies (test.slow() vs test.setTimeout())
+    - Common test patterns (form submission, dropdowns, multi-role testing)
+    - Locator priority guidelines
+    - Support classes reference
+    - Domain tags
+    - Validation checklist
+    **Apply ALL handbook principles before proceeding.**
+    ---
+    ### Step 2: Generate Test Using Handbook Template
+    Use the **Test File Structure Template** from the handbook. It includes:
+    - Proper imports (performAdminLogin, entity classes, utilities)
+    - test.describe with domain tags
+    - beforeAll/afterAll for entity lifecycle via API
+    - test.slow() for timeout handling
+    - test.step() for clear organization
+    - API response validation pattern
+    ---
+    ### Step 3: Apply Common Test Patterns from Handbook
+    Reference the **Common Test Patterns** section for:
+    - Form submission with API validation
+    - Dropdown selection (with :visible chain pattern)
+    - Multi-role permission testing
+    - Data persistence verification
+    - Navigation patterns
+    - Search and filter patterns
+    ---
+    ### Step 4: Validate Against Handbook Checklist
+    Before returning the generated test, verify ALL items from the handbook's **Validation Checklist**:
+    - ✅ Structure & Organization (test.step, domain tags, imports, beforeAll/afterAll)
+    - ✅ Anti-Flakiness (no waitForTimeout, no networkidle, no force: true, no positional selectors, no stored :visible locators)
+    - ✅ API & Network (waitForResponse before actions, status code validation)
+    - ✅ Waits & Assertions (waitForAllLoadersToDisappear, semantic locators, proper assertions)
+    - ✅ Coverage & Roles (multi-role tests, data persistence, error handling)
+    ---
+    ## Key Reminders
+    **All patterns, rules, and best practices are in the handbook.**
+    Read and apply the handbook sections in order:
+. **Anti-Flakiness Patterns** (CRITICAL - #1 cause of flaky tests)
+. **Test File Structure Template** (for proper test structure)
+. **Common Test Patterns** (for specific scenarios)
+. **Validation Checklist** (before returning generated test)
+    ---
+    ## Final Notes
+    - Generate **production-ready** tests that pass 10/10 times
+    - Follow ALL patterns from the handbook exactly
+    - No comments for obvious code (e.g., `// Create entity` before `entity.create()`)
+    - Test independence - each test runs in any order
+    - Reference examples: `playwright/e2e/Pages/DataContractInheritance.spec.ts`, `playwright/e2e/Features/Table.spec.ts`
+    **Generate tests that are production-ready, maintainable, and zero-flakiness by following the handbook patterns exactly.**

.agents/skills/writing-playwright-tests/SKILL.md

-Original file line number
+Diff line change
@@ -0,0 +1,10 @@
+    ---
+    name: writing-playwright-tests
+    description: Use when writing new Playwright E2E tests or adding test cases. Provides testing philosophy, patterns, and best practices from the Playwright Developer Handbook.
+    ---
+    # Writing Playwright Tests Skill
+    This skill guides you through writing Playwright E2E tests following OpenMetadata standards.
+    **Reference**: @openmetadata-ui/src/main/resources/ui/playwright/PLAYWRIGHT_DEVELOPER_HANDBOOK.md

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Feature #18173: Version API Improvements, Last x versions order by desc, versions from specific timeline, versions for specific metadata changes, sdk support and UI integration #26307

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!