test-enforcement

Files (1)

• SKILL.md

SKILL.md (first lines)

# Test Enforcement for OpenMetadata

Ensure every code change has comprehensive tests — 90% line coverage for service code, integration tests for APIs, and Playwright E2E tests for UI changes.

## When to Use

- After implementing any feature or bug fix (before creating a PR)
- When reviewing a PR to check test completeness
- When the `/tdd` skill was not used during implementation

## Scope and evidence reuse

Apply AGENTS.md's completion boundary. Check coverage and test gaps for changed behavior;
do not treat each skill as a separate execution requirement. Reuse applicable results. For
implementation, push or PR creation run focused checks and list broader coverage as outstanding;
full impacted runs are required for merge-readiness tasks. An infrastructure blocker is a
reported limitation, not permission to retry indefinitely or dispatch new workflows.

## Workflow

### Step 1: Identify Changed Files

Determine what changed and classify by layer:

```bash
# Branch changes
git diff main...HEAD --name-only

# Or staged changes
git diff --cached --name-only

# Or PR changes
gh pr diff <number> --name-only
```

Classify each changed file:

| File path pattern | Layer | Required tests |
|---|---|---|
| `openmetadata-service/src/main/` | Java backend | Unit tests (90% coverage) + integration tests |
| `openmetadata-spec/src/main/resources/json/schema/` | Schema | Regeneration verification + downstream tests |
| `openmetadata-integration-tests/` | Integration tests | Self — verify they pass |
| `ingestion/src/metadata/` | Python ingestion | pytest unit tests (90% coverage) |
| `openmetadata-ui/.../ui/src/` | React frontend | Jest unit tests + Playwright E2E |
| `bootstrap/sql/migrations/` | Database | Integration tests verifying migration |

### Step 2: Check Java Service Coverage

For any changes under `openmetadata-service/src/main/`:

#### 2a. Find existing tests

```bash
# For a changed class Foo.java, find its test
CHANGED_CLASS="Foo"
find openmetadata-service/src/test -name "${CHANGED_CLASS}Test.java" -o -name "${CHANGED_CLASS}Tests.java"

# Also check integration tests
find openmetadata-integration-tests/src/test -name "*${CHANGED_CLASS}*IT.java"
```

#### 2b. Run coverage for the module

```bash
mvn test -pl openmetadata-service -P static-code-analysis -Dtest=<TestClass>
# Coverage report: openmetadata-service/target/site/jacoco/index.html
```

#### 2c. Verify 90% line coverage for changed code

After running tests, check the JaCoCo report for the specific classes you changed:

```bash
# Parse the JaCoCo XML report for specific classes
REPORT="openmetadata-service/target/site/jacoco/jacoco.xml"
# Look for coverage of your specific packages/classes
grep -A5 "name=\"YourClassName\"" "$REPORT"
```

**Target: 90% line coverage on all changed/new classes.**

#### 2d. Generate missing tests

If coverage is below 90%, create tests following these patterns:

**Unit tests** (`openmetadata-service/src/test/`):
- Test public methods with meaningful inputs
- Test edge cases: null inputs, empty collections, boundary values
- Test error paths: invalid input, missing data, permission denied
- Use descriptive test names: `testCreateEntityWithValidInput`, `testDeleteEntityNotFound`

**Do NOT:**
- Mock internal OpenMetadata classes — write integration tests instead
- Test obvious getters/setters
- Write tests that only verify mock wiring

### Step 3: Check Integration Tests for API Endpoints

For any changes to REST resources or entity logic:

#### 3a. Map changed code to API endpoints

```bash
# Find resource classes that changed
git diff main...HEAD --name-only | grep -E "Resource\.java$"

# Find the @Path annotations to identify endpoints
grep -n "@Path" <resource-file>
```

#### 3b. Check existing integration tests

```bash
# Integration test naming convention: <Entity>IT.java
find openmetadata-integration-tests/src/test -name "*IT.java" | sort
```

Every REST resource should have a corresponding `*IT.java` that tests:

From open-metadata/OpenMetadata, Apache-2.0.

More from open-metadata/OpenMetadata