Quarkus Verification
Verification loop for Quarkus projects: build, static analysis (Checkstyle, PMD, SpotBugs), tests with JaCoCo coverage, OWASP dependency and container security scans, GraalVM native compilation, health checks, and config validation. Use when verifying a Quarkus service before a PR, after major refactoring or dependency upgrades, or pre-deploy.
Get the complete skill folder, including its scripts and reference files.
·
When to use this skill
Use Quarkus Verification when an AI agent needs a reusable SKILL.md workflow for this job: Verification loop for Quarkus projects: build, static analysis (Checkstyle, PMD, SpotBugs), tests with JaCoCo coverage, OWASP dependency and container security scans, GraalVM native compilation, health checks, and config validation. Use when verifying a Quarkus service before a PR, after major refactoring or dependency upgrades, or pre-deploy.
When not to use it
Skip Quarkus Verification when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/quarkus-verification # Save SKILL.md to ~/.claude/skills/quarkus-verification/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/quarkus-verification/SKILL.md. For a shared project, commit the folder at .claude/skills/quarkus-verification/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Quarkus Verification skill for this task: Use Quarkus Verification when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
76/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 85/100
- Practical detail
- 76/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# Quarkus Verification Loop
Run before PRs, after major changes, and pre-deploy.
## When to Activate
- Before opening a pull request for a Quarkus service - After major refactoring or dependency upgrades - Pre-deployment verification for staging or production - Running full build → lint → test → security scan → native compilation pipeline - Validating test coverage meets thresholds (80%+) - Testing native image compatibility
## Phase 1: Build
```bash # Maven mvn clean verify -DskipTests
# Gradle ./gradlew clean assemble -x test ```
If build fails, stop and fix compilation errors.
## Phase 2: Static Analysis
### Checkstyle, PMD, SpotBugs (Maven)
```bash mvn checkstyle:check pmd:check spotbugs:check ```
### SonarQube (if configured)
```bash mvn sonar:sonar \ -Dsonar.projectKey=my-quarkus-project \ -Dsonar.host.url=http://localhost:9000 \ -Dsonar.login=${SONAR_TOKEN} ```
### Common Issues to Address
- Unused imports or variables - Complex methods (high cyclomatic complexity) - Potential null pointer dereferences - Security issues flagged by SpotBugs
## Phase 3: Tests + Coverage
```bash # Run all tests mvn clean test
# Generate coverage report mvn jacoco:report
# Enforce coverage threshold (80%) mvn jacoco:check
# Or with Gradle ./gradlew test jacocoTestReport jacocoTestCoverageVerification ```
### Test Categories
#### Unit Tests Test service logic with mocked dependencies:
```java @ExtendWith(MockitoExtension.class) class UserServiceTest { @Mock UserRepository userRepository; @InjectMocks UserService userService;
@Test void createUser_validInput_returnsUser() { var dto = new CreateUserDto("Alice", "[email protected]");
// Panache persist() is void — use doNothing + verify doNothing().when(userRepository).persist(any(User.class));
User result = userService.create(dto);
assertThat(result.name).isEqualTo("Alice"); verify(userRepository).persist(any(User.class)); } } ```
#### Integration Tests Test with real database (Testcontainers):
```java @QuarkusTest @QuarkusTestResource(PostgresTestResource.class) class UserRepositoryIntegrationTest {
@Inject UserRepository userRepository;
@Test @Transactional void findByEmail_existingUser_returnsUser() { User user = new User(); user.name = "Alice"; user.email = "[email protected]"; userRepository.persist(user);
Optional<User> found = userRepository.findByEmail("[email protected]");
assertThat(found).isPresent(); assertThat(found.get().name).isEqualTo("Alice"); } } ```
#### API Tests Test REST endpoints with REST Assured:
```java @QuarkusTest class UserResourceTest {
@Test void createUser_validInput_returns201() { given() .contentType(ContentType.JSON) .body(""" {"name": "Alice", "email": "[email protected]"} """) .when().post("/api/users") .then() .statusCode(201) .body("name", equalTo("Alice")); }
@Test void createUser_invalidEmail_returns400() { given() .contentType(ContentType.JSON) .body(""" {"name": "Alice", "email": "invalid"} """) .when().post("/api/users") .then() .statusCode(400); } } ```
### Coverage Report
Check `target/site/jacoco/index.html` for detailed coverage: - Overall line coverage (target: 80%+) - Branch coverage (target: 70%+) - Identify uncovered critical paths
## Phase 4: Security Scanning
### Dependency Vulnerabilities (Maven)
```bash mvn org.owasp:dependency-check-maven:check ```
Review `target/dependency-check-report.html` for CVEs.
### Quarkus Security Audit
```bash # Check vulnerable extensions mvn quarkus:audit
# List all extensions mvn quarkus:list-extensions ```
### OWASP ZAP (API Security Testing)
```bash docker run -t ghcr.io/zaproxy/zaproxy:stable zap-api-scan.py \ -t http://localhost:8080/q/openapi \ -f openapi ```
### Common Security Checks
- [ ] All secrets in environment variables (not in code) - [ ] Input validation on all endpoints - [ ] Authentication/authorization configured - [ ] CORS properly configured - [ ] Security headers set - [ ] Passwords hashed with BCrypt - [ ] SQL injection protection (parameterized queries) - [ ] Rate limiting on public endpoints
## Phase 5: Native Compilation
Test GraalVM native image compatibility:
```bash # Build native executable mvn package -Dnative
# Or with container mvn package -Dnative -Dquarkus.native.container-build=true
# Test native executable ./target/*-runner
# Run basic smoke tests curl http://localhost:8080/q/health/live curl http://localhost:8080/q/health/ready ```
### Native Image Troubleshooting
Common issues: - **Reflection**: Add reflection config for dynamic classes - **Resources**: Include resources with `quarkus.native.resources.includes` - **JNI**: Register JNI classes if using native libraries
Example reflection config: ```java @RegisterForReflection(targets = {MyDynamicClass.class}) public class ReflectionConfiguration {} ```
## Phase 6: Performance Testing
### Load Testing with K6
```javascript // load-test.js import http from 'k6/http'; import { check } from 'k6';
export const options = { stages: [ { duration: '30s', target: 50 }, { duration: '1m', target: 100 }, { duration: '30s', target: 0 }, ], };
export default function () { const res = http.get('http://localhost:8080/api/markets'); check(res, { 'status is 200': (r) => r.status === 200, 'response time < 200ms': (r) => r.timings.duration < 200, }); } ```
Run: ```bash k6 run load-test.js ```
### Metrics to Monitor
- Response time (p50, p95, p99) - Throughput (requests/sec) - Error rate - Memory usage - CPU usage
## Phase 7: Health Checks
```bash # Liveness curl http://localhost:8080/q/health/live
# Readiness curl http://localhost:8080/q/health/ready
# All health checks curl http://localhost:8080/q/health
# Metrics (if enabled) curl http://localhost:8080/q/metrics ```
Expected responses: ```json { "status": "UP", "checks": [ { "name": "Database connection", "status": "UP" } ] } ```
## Phase 8: Container Image Build
```bash # Build container image mvn package -Dquarkus.container-image.build=true
# Or with specific registry mvn package \ -Dquarkus.container-image.build=true \ -Dquarkus.container-image.registry=docker.io \ -Dquarkus.container-image.group=myorg \ -Dquarkus.container-image.tag=1.0.0
# Test container docker run -p 8080:8080 myorg/my-quarkus-app:1.0.0 ```
### Container Security Scan
```bash # Trivy trivy image myorg/my-quarkus-app:1.0.0
# Grype grype myorg/my-quarkus-app:1.0.0 ```
## Phase 9: Configuration Validation
```bash # Check all configuration properties mvn quarkus:info
# List all config sources curl http://localhost:8080/q/dev/io.quarkus.quarkus-vertx-http/config ```
### Environment-Specific Checks
- [ ] Database URLs configured per environment - [ ] Secrets externalized (Vault, env vars) - [ ] Logging levels appropriate - [ ] CORS origins set correctly - [ ] Rate limiting configured - [ ] Monitoring/tracing enabled
## Phase 10: Documentation Review
- [ ] OpenAPI/Swagger docs up to date (`/q/swagger-ui`) - [ ] README has setup instructions - [ ] API changes documented - [ ] Migration guide for breaking changes - [ ] Configuration properties documented
Generate OpenAPI spec: ```bash curl http://localhost:8080/q/openapi -o openapi.json ```
## Verification Checklist
### Code Quality - [ ] Build passes without warnings - [ ] Static analysis clean (no high/medium issues) - [ ] Code follows team conventions - [ ] No commented-out code or TODOs in PR
### Testing - [ ] All tests pass - [ ] Code coverage ≥ 80% - [ ] Integration tests with real database - [ ] Security tests pass - [ ] Performance within acceptable limits
### Security - [ ] No dependency vulnerabilities - [ ] Authentication/authorization tested - [ ] Input validation complete - [ ] Secrets not in source code - [ ] Security headers configured
### Deployment - [ ] Native compilation successful - [ ] Container image builds - [ ] Health checks respond correctly - [ ] Configuration valid for target environment
### Native Image - [ ] Native executable builds - [ ] Native tests pass - [ ] Startup time < 100ms - [ ] Memory footprint acceptable
## Automated Verification Script
```bash #!/bin/bash set -e
echo "=== Phase 1: Build ===" mvn clean verify -DskipTests
echo "=== Phase 2: Static Analysis ===" mvn checkstyle:check pmd:check spotbugs:check
echo "=== Phase 3: Tests + Coverage ===" mvn test jacoco:report jacoco:check
echo "=== Phase 4: Security Scan ===" mvn org.owasp:dependency-check-maven:check
echo "=== Phase 5: Native Compilation ===" mvn package -Dnative -Dquarkus.native.container-build=true
echo "=== All Phases Complete ===" echo "Review reports:" echo " - Coverage: target/site/jacoco/index.html" echo " - Security: target/dependency-check-report.html" echo " - Native: target/*-runner" ```
## CI/CD Integration
### GitHub Actions Example
```yaml name: Verification
on: [push, pull_request]
jobs: verify: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7
- name: Set up JDK 21 uses: actions/setup-java@v5 with: java-version: '21' distribution: 'temurin'
- name: Cache Maven packages uses: actions/cache@v6 with: path: ~/.m2 key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
- name: Build run: mvn clean verify -DskipTests
- name: Test with Coverage run: mvn test jacoco:report jacoco:check
- name: Security Scan run: mvn org.owasp:dependency-check-maven:check
- name: Upload Coverage uses: codecov/codecov-action@v7 with: token: ${{ secrets.CODECOV_TOKEN }} files: target/site/jacoco/jacoco.xml ```
## Best Practices
- Run verification loop before every PR - Automate in CI/CD pipeline - Fix issues immediately; don't accumulate debt - Keep coverage above 80% - Update dependencies regularly - Test native compilation periodically - Monitor performance trends - Document breaking changes - Review security scan results - Validate configuration for each environment
Intended uses
- Use Quarkus Verification when this documented workflow matches the task.
Implementation notes
- Run verification loop before every PR
- Automate in CI/CD pipeline
- Fix issues immediately; don't accumulate debt
- Keep coverage above 80%
- Update dependencies regularly
- Test native compilation periodically
- Monitor performance trends
- Document breaking changes
- Review security scan results
- Validate configuration for each environment
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.