test-operator

Files (1)

• SKILL.md

SKILL.md (first lines)

# Test Operator - Quality Assurance & Testing

This skill provides comprehensive testing, linting, and quality assurance workflows for openstack-k8s-operators operators, following Go and Kubernetes operator best practices.

## Testing Workflow

When testing an operator, I will systematically:

1. **Code Formatting**: Ensure consistent code style with `go fmt`
2. **Static Analysis**: Run `go vet` to catch common mistakes
3. **Linting**: Execute golangci-lint with comprehensive checks
4. **Unit Tests**: Run Ginkgo test suites with proper coverage
5. **Security Scanning**: Check for vulnerabilities and security issues
6. **CRD Validation**: Verify Custom Resource Definition schemas
7. **Operator-Specific Checks**: Run operator-lint for controller patterns

## Available Make Targets

Based on the openstack-k8s-operators operator Makefile conventions:

### Core Testing

```bash
make test              # Run full test suite with Ginkgo
make gotest            # Alias for test
make test GINKGO_ARGS="--focus 'pattern'"  # Focused tests
```

### Code Formatting

```bash
make fmt               # Run go fmt
make gofmt             # Run gofmt via CI tools (with checks)
make tidy              # Run go mod tidy
```

### Static Analysis

```bash
make vet               # Run go vet
make govet             # Run govet via CI tools
make operator-lint     # Run operator-specific linting
```

### Linting (Multiple Levels)

```bash
make golangci          # Standard golangci-lint checks
make golangci-lint     # Direct golangci-lint with --fix
make golint            # Additional Go linting
```

### Code Generation & Validation

```bash
make manifests         # Generate CRDs, webhooks, RBAC
make generate          # Generate DeepCopy methods
make crd-schema-check  # Validate CRD schema changes
```

## Comprehensive Quality Check

I will run a complete quality check workflow:

### Level 1: Quick Checks (Fast Feedback)

1. `make fmt` - Format code
2. `make vet` - Static analysis
3. Quick syntax validation

### Level 2: Standard Checks (Pre-commit)

1. `make gofmt` - Format validation
2. `make govet` - Enhanced static analysis
3. `make golangci` - Standard linting
4. `make tidy` - Dependency check

### Level 3: Comprehensive Checks (Pre-PR)

1. `make golangci-lint` - Full linting with auto-fix
2. `make operator-lint` - Operator-specific patterns
3. `make test` - Full test suite
4. `make crd-schema-check` - Schema validation

### Level 4: Security & Advanced (CI/CD)

1. Security scanning (gosec, staticcheck)
2. Vulnerability detection (govulncheck)
3. Code complexity analysis (gocyclo)
4. Test coverage analysis

## Ginkgo Testing Patterns

### Basic Test Execution

```bash
# Run all tests
make test

# Run with specific Ginkgo args
make test GINKGO_ARGS="-v --trace"

# Focus on specific tests
make test GINKGO_ARGS="--focus 'Glance controller'"

# Run tests in parallel
make test GINKGO_ARGS="--procs 4"

# Randomize test order
make test GINKGO_ARGS="--randomize-all"
```

### Advanced Ginkgo Usage

```bash
# Focused testing with pattern
make test GINKGO_ARGS="--focus 'initializes the status fields'"

# Skip specific tests

From openstack-k8s-operators/devskills, MIT.

More from openstack-k8s-operators/devskills