Apply quality framework: CI gates, benchmarks, destructive tests

claude · claude · commit 04e3e8e203b4 · 2026-03-15T17:50:37.000Z
Integrate the quality framework into the development workflow: - Add quality stage to GitLab CI with coverage, race detection, and vulnerability scanning gates - Add Makefile targets: test-race, test-bench, coverage-report, vulnerability-scan, quality (all-in-one) - Add benchmark tests for clone management (GetClones, FindWrapper, GetSnapshotList, concurrent set/get, GetCloningState) - Add benchmark tests for API utilities (WriteJSON, ReadJSON, WriteData) - Add destructive test harness for failure-mode testing (kill mid-clone, concurrent clones, restart with state preservation, snapshot integrity) - Update CLAUDE.md with quality commands and framework references https://claude.ai/code/session_01BMygsj1Bb967LXm7guNEBS
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -16,10 +16,28 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - Build all components: `cd engine && make build`
 - Lint code: `cd engine && make run-lint`
 - Run unit tests: `cd engine && make test`
+- Run unit tests with race detection: `cd engine && make test-race`
 - Run integration tests: `cd engine && make test-ci-integration`
+- Run benchmark tests: `cd engine && make test-bench`
+- Run all quality checks: `cd engine && make quality`
+- Run coverage report: `cd engine && make coverage-report`
+- Run vulnerability scan: `cd engine && make vulnerability-scan`
 - Run a specific test: `cd engine && GO111MODULE=on go test -v ./path/to/package -run TestName`
 - Run UI: `cd ui && pnpm start:ce` (Community Edition) or `pnpm start:platform`
 
+## Quality Engineering
+
+See `quality/QUALITY_ENGINEERING_GUIDE.md` for the full quality framework.
+
+Key references:
+- PR review checklist: `quality/checklists/pr-review-checklist.md`
+- Release readiness checklist: `quality/checklists/release-readiness-checklist.md`
+- AI PR review prompt: `quality/prompts/pr-review-system-prompt.md`
+- AI test generation prompt: `quality/prompts/test-generation-prompt.md`
+- CI quality gates: `quality/ci/quality-gates.yml`
+- Quality metrics template: `quality/metrics/quality-metrics-template.md`
+- Pre-push quality script: `quality/scripts/run-quality-checks.sh`
+
 ## Code Style Guidelines
 - Go code follows "Effective Go" and "Go Code Review Comments" guidelines
 - Use present tense and imperative mood in commit messages
diff --git a/engine/.gitlab-ci.yml b/engine/.gitlab-ci.yml
@@ -15,6 +15,7 @@ default:
 
 stages:
   - test
+  - quality
   - build-binary
   - build
   - integration-test
@@ -66,6 +67,34 @@ lint:
     - cd engine
     - make lint
 
+### Quality gates.
+coverage-check:
+  <<: *only_engine
+  stage: quality
+  script:
+    - cd engine
+    - make coverage-report
+  coverage: '/Total coverage: \d+.\d+%/'
+  artifacts:
+    paths:
+      - engine/coverage.out
+    expire_in: 30 days
+
+race-check:
+  <<: *only_engine
+  stage: quality
+  script:
+    - cd engine
+    - make test-race
+
+vulnerability-scan:
+  <<: *only_engine
+  stage: quality
+  script:
+    - cd engine
+    - make vulnerability-scan
+  allow_failure: true
+
 ### Build binary.
 build-binary-alpine:
   <<: *only_engine
diff --git a/engine/Makefile b/engine/Makefile
@@ -75,9 +75,26 @@ build-dle: build build-image ## Build Database Lab Engine binary and Docker imag
 test: ## Run unit tests
 	${GOTEST} ./...
 
+test-race: ## Run unit tests with race detector (explicit target for CI quality gate)
+	${GOTEST} -count=1 -timeout=10m ./...
+
 test-ci-integration: ## Run integration tests
 	GO111MODULE=on go test -race  -tags=integration ./...
 
+test-bench: ## Run benchmark tests
+	GO111MODULE=on go test -bench=. -benchmem -count=3 -timeout=30m ./... 2>&1 | tee bench-results.txt
+
+coverage-report: ## Run tests with coverage and report result
+	@GO111MODULE=on go test -coverprofile=coverage.out -covermode=atomic ./... 2>&1 | tail -1
+	@TOTAL=$$(go tool cover -func=coverage.out | grep total | awk '{print $$3}' | sed 's/%//'); \
+	echo "Total coverage: $${TOTAL}%"
+
+vulnerability-scan: ## Scan dependencies for known vulnerabilities
+	go install golang.org/x/vuln/cmd/govulncheck@latest
+	govulncheck ./...
+
+quality: fmt run-lint test coverage-report ## Run all quality checks (format, lint, test, coverage)
+
 fmt: ## Format code
 	go fmt $$(go list ./... | grep -v /vendor/)
 
@@ -100,4 +117,4 @@ run-dle: build-dle
 	-p "2345:2345" \
 	dblab_server:local
 
-.PHONY: help all build test run-lint install-lint lint fmt clean build-image build-dle build-ci-checker build-client build-rds-refresh run-dle
+.PHONY: help all build test test-race test-bench test-ci-integration run-lint install-lint lint fmt clean build-image build-dle build-ci-checker build-client build-rds-refresh run-dle coverage-report vulnerability-scan quality
diff --git a/engine/internal/cloning/benchmark_test.go b/engine/internal/cloning/benchmark_test.go
@@ -0,0 +1,132 @@
+package cloning
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"gitlab.com/postgres-ai/database-lab/v3/pkg/models"
+)
+
+func BenchmarkGetClones(b *testing.B) {
+	cloning := &Base{
+		config:      &Config{},
+		clones:      make(map[string]*CloneWrapper),
+		snapshotBox: SnapshotBox{items: make(map[string]*models.Snapshot)},
+	}
+
+	for i := 0; i < 100; i++ {
+		id := fmt.Sprintf("clone-%03d", i)
+		cloning.setWrapper(id, &CloneWrapper{
+			Clone: &models.Clone{
+				ID:        id,
+				CreatedAt: &models.LocalTime{Time: time.Now()},
+				Status:    models.Status{Code: models.StatusOK},
+			},
+		})
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_ = cloning.GetClones()
+	}
+}
+
+func BenchmarkFindWrapper(b *testing.B) {
+	cloning := &Base{
+		clones:      make(map[string]*CloneWrapper),
+		snapshotBox: SnapshotBox{items: make(map[string]*models.Snapshot)},
+	}
+
+	for i := 0; i < 1000; i++ {
+		id := fmt.Sprintf("clone-%04d", i)
+		cloning.setWrapper(id, &CloneWrapper{
+			Clone: &models.Clone{ID: id},
+		})
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		cloning.findWrapper("clone-0500")
+	}
+}
+
+func BenchmarkGetSnapshotList(b *testing.B) {
+	cloning := &Base{
+		clones:      make(map[string]*CloneWrapper),
+		snapshotBox: SnapshotBox{items: make(map[string]*models.Snapshot)},
+	}
+
+	for i := 0; i < 50; i++ {
+		id := fmt.Sprintf("snap-%03d", i)
+		cloning.snapshotBox.items[id] = &models.Snapshot{
+			ID:        id,
+			CreatedAt: &models.LocalTime{Time: time.Now()},
+		}
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_ = cloning.getSnapshotList()
+	}
+}
+
+func BenchmarkSetGetWrapper_Concurrent(b *testing.B) {
+	cloning := &Base{
+		clones:      make(map[string]*CloneWrapper),
+		snapshotBox: SnapshotBox{items: make(map[string]*models.Snapshot)},
+	}
+
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			id := fmt.Sprintf("clone-%04d", i%100)
+			cloning.setWrapper(id, &CloneWrapper{Clone: &models.Clone{ID: id}})
+			cloning.findWrapper(id)
+			i++
+		}
+	})
+}
+
+func BenchmarkGetCloningState(b *testing.B) {
+	cloning := &Base{
+		config:      &Config{},
+		clones:      make(map[string]*CloneWrapper),
+		snapshotBox: SnapshotBox{items: make(map[string]*models.Snapshot)},
+	}
+
+	for i := 0; i < 50; i++ {
+		id := fmt.Sprintf("clone-%03d", i)
+		cloning.setWrapper(id, &CloneWrapper{
+			Clone: &models.Clone{
+				ID:        id,
+				CreatedAt: &models.LocalTime{Time: time.Now()},
+				Status:    models.Status{Code: models.StatusOK},
+			},
+		})
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_ = cloning.GetCloningState()
+	}
+}
+
+func TestBenchmarkSetup(t *testing.T) {
+	cloning := &Base{
+		config:      &Config{},
+		clones:      make(map[string]*CloneWrapper),
+		snapshotBox: SnapshotBox{items: make(map[string]*models.Snapshot)},
+	}
+
+	cloning.setWrapper("test", &CloneWrapper{Clone: &models.Clone{ID: "test"}})
+	w, ok := cloning.findWrapper("test")
+	require.True(t, ok)
+	require.Equal(t, "test", w.Clone.ID)
+}
diff --git a/engine/internal/srv/api/benchmark_test.go b/engine/internal/srv/api/benchmark_test.go
@@ -0,0 +1,64 @@
+package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"gitlab.com/postgres-ai/database-lab/v3/pkg/models"
+)
+
+func BenchmarkWriteJSON_SmallPayload(b *testing.B) {
+	status := models.Status{Code: models.StatusOK, Message: "instance is running"}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		w := httptest.NewRecorder()
+		_ = WriteJSON(w, http.StatusOK, status)
+	}
+}
+
+func BenchmarkWriteJSON_LargePayload(b *testing.B) {
+	clones := make([]*models.Clone, 100)
+	for i := range clones {
+		clones[i] = &models.Clone{
+			ID:        "clone-" + string(rune('a'+i%26)),
+			CreatedAt: &models.LocalTime{Time: time.Now()},
+			Status:    models.Status{Code: models.StatusOK, Message: "clone is running"},
+			DB:        models.Database{DBName: "testdb", Username: "user"},
+		}
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		w := httptest.NewRecorder()
+		_ = WriteJSON(w, http.StatusOK, clones)
+	}
+}
+
+func BenchmarkReadJSON(b *testing.B) {
+	body := `{"id":"bench-clone","snapshot":{"id":"snap-1"},"db":{"username":"test","password":"test"}}`
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		req := httptest.NewRequest(http.MethodPost, "/clone", strings.NewReader(body))
+		var result map[string]interface{}
+		_ = ReadJSON(req, &result)
+	}
+}
+
+func BenchmarkWriteData(b *testing.B) {
+	data := []byte(`{"status":"ok","engine":{"version":"3.5.0"},"cloning":{"numClones":42}}`)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		w := httptest.NewRecorder()
+		_ = WriteData(w, http.StatusOK, data)
+	}
+}
diff --git a/engine/test/5.destructive.sh b/engine/test/5.destructive.sh
