bretton.dev / coves
A community based topic aggregation platform built on atproto
fork atom

refactor: Unify testing configuration into single .env.dev file

Consolidate all test and development configuration into a single source
of truth (.env.dev) for cleaner, more maintainable setup.

Changes:
- Remove obsolete .env.test and .env.test.example files
- Update Makefile to load .env.dev variables automatically via include
- Simplify test commands (no more bash subshells or complex sourcing)
- Update integration tests to read config from environment variables
- Rewrite TESTING_SUMMARY.md with current unified approach
- Update LOCAL_DEVELOPMENT.md to reference single config file

Benefits:
- Single source of truth for all configuration
- Simpler test execution: just `make test`
- Isolated test DB (port 5434) separate from dev (port 5433)
- Better documentation and developer experience

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

bretton.dev 340889f1 a7df8b81

options
unified split
Changed files
+410 -137
.env.test.example
Makefile
TESTING_SUMMARY.md
docs
LOCAL_DEVELOPMENT.md
tests
integration
integration_test.go
-12
.env.test.example 
···

       
1

       
-

       
# Test Environment Configuration


     

       
2

       
-

       
# This file contains environment variables for running tests


     

       
3

       
-

       
# Copy this file to .env.test and update with your actual values


     

       
4

       
-

       



     

       
5

       
-

       
# Test Database Configuration


     

       
6

       
-

       
TEST_DATABASE_URL=postgres://your_test_user:your_test_password@localhost:5434/coves_test?sslmode=disable


     

       
7

       
-

       



     

       
8

       
-

       
# Test Server Configuration (if needed)


     

       
9

       
-

       
TEST_PORT=8081


     

       
10

       
-

       



     

       
11

       
-

       
# Test CAR Storage Directory


     

       
12

       
-

       
TEST_CAR_STORAGE_DIR=/tmp/coves_test_carstore

     
···
+7 -3
Makefile 
···

       
9

       
 

       
GREEN := \033[32m


     

       
10

       
 

       
YELLOW := \033[33m


     

       
11

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
12

       
 

       
##@ General


     

       
13

       
 

       



     

       
14

       
 

       
help: ## Show this help message


     
···

       
92

       
 

       
	@echo "Waiting for test database to be ready..."


     

       
93

       
 

       
	@sleep 3


     

       
94

       
 

       
	@echo "$(GREEN)Running migrations on test database...$(RESET)"


     

       
95

       
-

       
	@. .env.dev && goose -dir internal/db/migrations postgres "postgresql://$$POSTGRES_TEST_USER:$$POSTGRES_TEST_PASSWORD@localhost:$$POSTGRES_TEST_PORT/$$POSTGRES_TEST_DB?sslmode=disable" up || true


     

       
96

       
 

       
	@echo "$(GREEN)Running tests...$(RESET)"


     

       
97

       
-

       
	@. .env.dev && TEST_DATABASE_URL="postgresql://$$POSTGRES_TEST_USER:$$POSTGRES_TEST_PASSWORD@localhost:$$POSTGRES_TEST_PORT/$$POSTGRES_TEST_DB?sslmode=disable" go test ./... -v


     

       
98

       
 

       
	@echo "$(GREEN)✓ Tests complete$(RESET)"


     

       
99

       
 

       



     

       
100

       
 

       
test-db-reset: ## Reset test database


     
···

       
104

       
 

       
	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test


     

       
105

       
 

       
	@echo "Waiting for PostgreSQL to be ready..."


     

       
106

       
 

       
	@sleep 3


     

       
107

       
-

       
	@. .env.dev && goose -dir internal/db/migrations postgres "postgresql://$$POSTGRES_TEST_USER:$$POSTGRES_TEST_PASSWORD@localhost:$$POSTGRES_TEST_PORT/$$POSTGRES_TEST_DB?sslmode=disable" up || true


     

       
108

       
 

       
	@echo "$(GREEN)✓ Test database reset$(RESET)"


     

       
109

       
 

       



     

       
110

       
 

       
test-db-stop: ## Stop test database


     
···

       
9

       
 

       
GREEN := \033[32m


     

       
10

       
 

       
YELLOW := \033[33m


     

       
11

       
 

       



     

       
12

       
+

       
# Load test database configuration from .env.dev


     

       
13

       
+

       
include .env.dev


     

       
14

       
+

       
export


     

       
15

       
+

       



     

       
16

       
 

       
##@ General


     

       
17

       
 

       



     

       
18

       
 

       
help: ## Show this help message


     
···

       
96

       
 

       
	@echo "Waiting for test database to be ready..."


     

       
97

       
 

       
	@sleep 3


     

       
98

       
 

       
	@echo "$(GREEN)Running migrations on test database...$(RESET)"


     

       
99

       
+

       
	@goose -dir internal/db/migrations postgres "postgresql://$(POSTGRES_TEST_USER):$(POSTGRES_TEST_PASSWORD)@localhost:$(POSTGRES_TEST_PORT)/$(POSTGRES_TEST_DB)?sslmode=disable" up || true


     

       
100

       
 

       
	@echo "$(GREEN)Running tests...$(RESET)"


     

       
101

       
+

       
	@go test ./... -v


     

       
102

       
 

       
	@echo "$(GREEN)✓ Tests complete$(RESET)"


     

       
103

       
 

       



     

       
104

       
 

       
test-db-reset: ## Reset test database


     
···

       
108

       
 

       
	@docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test


     

       
109

       
 

       
	@echo "Waiting for PostgreSQL to be ready..."


     

       
110

       
 

       
	@sleep 3


     

       
111

       
+

       
	@goose -dir internal/db/migrations postgres "postgresql://$(POSTGRES_TEST_USER):$(POSTGRES_TEST_PASSWORD)@localhost:$(POSTGRES_TEST_PORT)/$(POSTGRES_TEST_DB)?sslmode=disable" up || true


     

       
112

       
 

       
	@echo "$(GREEN)✓ Test database reset$(RESET)"


     

       
113

       
 

       



     

       
114

       
 

       
test-db-stop: ## Stop test database
+363 -109
TESTING_SUMMARY.md 
···

       
1

       
-

       
# Repository Testing Summary


     

       
2

       
 

       



     

       
3

       
-

       
## Lexicon Schema Validation


     

       
4

       
 

       



     

       
5

       
-

       
We use Indigo's lexicon validator to ensure all AT Protocol schemas are valid and properly structured.


     

       
6

       
 

       



     

       
7

       
-

       
### Validation Components:


     

       
8

       
-

       
1. **Schema Validation** (`cmd/validate-lexicon/main.go`)


     

       
9

       
-

       
   - Validates all 57 lexicon schema files are valid JSON


     

       
10

       
-

       
   - Checks cross-references between schemas


     

       
11

       
-

       
   - Validates test data files against their schemas


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
12

       
 

       



     

       
13

       
-

       
2. **Test Data** (`tests/lexicon-test-data/`)


     

       
14

       
-

       
   - Contains example records for validation testing


     

       
15

       
-

       
   - Files use naming convention:


     

       
16

       
-

       
     - `*-valid*.json` - Should pass validation


     

       
17

       
-

       
     - `*-invalid-*.json` - Should fail validation (tests error detection)


     

       
18

       
-

       
   - Currently covers 5 record types:


     

       
19

       
-

       
     - social.coves.actor.profile


     

       
20

       
-

       
     - social.coves.community.profile  


     

       
21

       
-

       
     - social.coves.post.record


     

       
22

       
-

       
     - social.coves.interaction.vote


     

       
23

       
-

       
     - social.coves.moderation.ban


     

       
24

       
 

       



     

       
25

       
-

       
3. **Validation Library** (`internal/validation/lexicon.go`)


     

       
26

       
-

       
   - Wrapper around Indigo's ValidateRecord


     

       
27

       
-

       
   - Provides type-specific validation methods


     

       
28

       
-

       
   - Supports multiple input formats


     

       
29

       
 

       



     

       
30

       
-

       
### Running Lexicon Validation


     

       
31

       
 

       
```bash


     

       
32

       
-

       
# Full validation (schemas + test data) - DEFAULT


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
33

       
 

       
go run cmd/validate-lexicon/main.go


     

       
34

       
 

       



     

       
35

       
-

       
# Schemas only (skip test data validation)


     

       
36

       
 

       
go run cmd/validate-lexicon/main.go --schemas-only


     

       
37

       
 

       



     

       
38

       
 

       
# Verbose output


     

       
39

       
 

       
go run cmd/validate-lexicon/main.go -v


     

       
40

       
 

       



     

       
41

       
-

       
# Strict validation mode


     

       
42

       
 

       
go run cmd/validate-lexicon/main.go --strict


     

       
43

       
 

       
```


     

       
44

       
 

       



     

       
45

       
-

       
### Test Coverage Warning


     

       
46

       
-

       
The validator explicitly outputs which record types have test data and which don't. This prevents false confidence from passing tests when schemas lack test coverage.


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
47

       
 

       



     

       
48

       
-

       
Example output:


     

       

       

       
     

       
49

       
 

       
```


     

       
50

       
-

       
📋 Validation Summary:


     

       
51

       
-

       
  Valid test files:   5/5 passed


     

       
52

       
-

       
  Invalid test files: 2/2 correctly rejected


     

       
53

       
 

       



     

       
54

       
-

       
  ✅ All test files behaved as expected!


     

       
55

       
 

       



     

       
56

       
-

       
📊 Test Data Coverage Summary:


     

       
57

       
-

       
  - Records with test data: 5 types


     

       
58

       
-

       
  - Valid test files: 5


     

       
59

       
-

       
  - Invalid test files: 2 (for error validation)


     

       
60

       
 

       



     

       
61

       
-

       
  Tested record types:


     

       
62

       
-

       
    ✓ social.coves.actor.profile


     

       
63

       
-

       
    ✓ social.coves.community.profile


     

       
64

       
-

       
    ✓ social.coves.post.record


     

       
65

       
-

       
    ✓ social.coves.interaction.vote


     

       
66

       
-

       
    ✓ social.coves.moderation.ban


     

       
67

       
 

       



     

       
68

       
-

       
  ⚠️  Record types without test data:


     

       
69

       
-

       
    - social.coves.actor.membership


     

       
70

       
-

       
    - social.coves.actor.subscription


     

       
71

       
-

       
    - social.coves.community.rules


     

       
72

       
-

       
    ... (8 more)


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
73

       
 

       



     

       
74

       
-

       
  Coverage: 5/16 record types have test data (31.2%)


     

       

       

       
     

       

       

       
     

       
75

       
 

       
```


     

       
76

       
 

       



     

       
77

       
-

       
### Running Tests


     

       

       

       
     

       
78

       
 

       
```bash


     

       
79

       
-

       
# Run lexicon validation tests


     

       
80

       
-

       
go test -v ./tests/lexicon_validation_test.go


     

       
81

       
 

       



     

       
82

       
-

       
# Run validation library tests  


     

       
83

       
-

       
go test -v ./internal/validation/...


     

       
84

       
 

       
```


     

       
85

       
 

       



     

       
86

       
-

       
## Test Infrastructure Setup


     

       
87

       
-

       
- Created Docker Compose configuration for isolated test database on port 5434


     

       
88

       
-

       
- Test database is completely separate from development (5433) and production (5432)


     

       
89

       
-

       
- Configuration location: `/internal/db/test_db_compose/docker-compose.yml`


     

       
90

       
 

       



     

       
91

       
-

       
## Repository Service Implementation


     

       
92

       
-

       
Successfully integrated Indigo's carstore for ATProto repository management:


     

       

       

       
     

       
93

       
 

       



     

       
94

       
-

       
### Key Components:


     

       
95

       
-

       
1. **CarStore Wrapper** (`/internal/atproto/carstore/carstore.go`)


     

       
96

       
-

       
   - Wraps Indigo's carstore implementation


     

       
97

       
-

       
   - Manages CAR file storage with PostgreSQL metadata


     

       
98

       
 

       



     

       
99

       
-

       
2. **RepoStore** (`/internal/atproto/carstore/repo_store.go`)


     

       
100

       
-

       
   - Combines CarStore with UserMapping for DID-based access


     

       
101

       
-

       
   - Handles DID to UID conversions transparently


     

       
102

       
 

       



     

       
103

       
-

       
3. **UserMapping** (`/internal/atproto/carstore/user_mapping.go`)


     

       
104

       
-

       
   - Maps ATProto DIDs to numeric UIDs (required by Indigo)


     

       
105

       
-

       
   - Auto-creates user_maps table via GORM


     

       
106

       
 

       



     

       
107

       
-

       
4. **Repository Service** (`/internal/core/repository/service.go`)


     

       
108

       
-

       
   - Updated to use Indigo's carstore instead of custom implementation


     

       
109

       
-

       
   - Handles empty repositories gracefully


     

       
110

       
-

       
   - Placeholder CID for empty repos until records are added


     

       
111

       
 

       



     

       
112

       
-

       
## Test Results


     

       
113

       
-

       
All repository tests passing:


     

       
114

       
-

       
- ✅ CreateRepository - Creates user mapping and repository record


     

       
115

       
-

       
- ✅ ImportExport - Handles empty CAR data correctly


     

       
116

       
-

       
- ✅ DeleteRepository - Removes repository and carstore data


     

       
117

       
-

       
- ✅ CompactRepository - Runs garbage collection


     

       
118

       
-

       
- ✅ UserMapping - DID to UID mapping works correctly


     

       
119

       
 

       



     

       
120

       
-

       
## Implementation Notes


     

       
121

       
-

       
1. **Empty Repositories**: Since Indigo's carstore expects actual CAR data, we handle empty repositories by:


     

       
122

       
-

       
   - Creating user mapping only


     

       
123

       
-

       
   - Using placeholder CID


     

       
124

       
-

       
   - Returning empty byte array on export


     

       
125

       
-

       
   - Actual CAR data will be created when records are added


     

       
126

       
 

       



     

       
127

       
-

       
2. **Database Tables**: Indigo's carstore auto-creates:


     

       
128

       
-

       
   - `user_maps` (DID ↔ UID mapping)


     

       
129

       
-

       
   - `car_shards` (CAR file metadata)


     

       
130

       
-

       
   - `block_refs` (IPLD block references)


     

       
131

       
 

       



     

       
132

       
-

       
3. **Migration**: Created migration to drop our custom block_refs table to avoid conflicts


     

       

       

       
     

       

       

       
     

       
133

       
 

       



     

       
134

       
-

       
## Next Steps


     

       
135

       
-

       
To fully utilize the carstore, implement:


     

       
136

       
-

       
1. Record CRUD operations using carstore's DeltaSession


     

       
137

       
-

       
2. Proper CAR file generation when adding records


     

       
138

       
-

       
3. Commit tracking with proper signatures


     

       
139

       
-

       
4. Repository versioning and history


     

       
140

       
 

       



     

       
141

       
-

       
## Running Tests


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
142

       
 

       
```bash


     

       
143

       
-

       
# Start test database


     

       
144

       
-

       
cd internal/db/test_db_compose


     

       
145

       
-

       
docker-compose up -d


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
146

       
 

       



     

       
147

       
-

       
# Run repository tests


     

       
148

       
-

       
TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \


     

       
149

       
-

       
  go test -v ./internal/core/repository/...


     

       
150

       
 

       



     

       
151

       
-

       
# Stop test database


     

       
152

       
-

       
docker-compose down


     

       
153

       
-

       
```

     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     
···

       
1

       
+

       
# Coves Testing Guide


     

       
2

       
 

       



     

       
3

       
+

       
This document explains how testing works in Coves, including setup, running tests, and understanding the test infrastructure.


     

       
4

       
 

       



     

       
5

       
+

       
## Overview


     

       
6

       
 

       



     

       
7

       
+

       
Coves uses a unified testing approach with:


     

       
8

       
+

       
- **Single configuration file**: [.env.dev](.env.dev) for all environments (dev + test)


     

       
9

       
+

       
- **Isolated test database**: PostgreSQL on port 5434 (separate from dev on 5433)


     

       
10

       
+

       
- **Makefile commands**: Simple `make test` command handles everything


     

       
11

       
+

       
- **Docker Compose profiles**: Test database spins up automatically


     

       
12

       
+

       



     

       
13

       
+

       
## Quick Start


     

       
14

       
+

       



     

       
15

       
+

       
```bash


     

       
16

       
+

       
# Run all tests (starts test DB, runs migrations, executes tests)


     

       
17

       
+

       
make test


     

       
18

       
+

       



     

       
19

       
+

       
# Reset test database (clean slate)


     

       
20

       
+

       
make test-db-reset


     

       
21

       
+

       



     

       
22

       
+

       
# Stop test database


     

       
23

       
+

       
make test-db-stop


     

       
24

       
+

       
```


     

       
25

       
+

       



     

       
26

       
+

       
## Test Infrastructure


     

       
27

       
 

       



     

       
28

       
+

       
### Configuration (.env.dev)


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
29

       
 

       



     

       
30

       
+

       
All test configuration lives in [.env.dev](.env.dev):


     

       

       

       
     

       

       

       
     

       

       

       
     

       
31

       
 

       



     

       

       

       
     

       
32

       
 

       
```bash


     

       
33

       
+

       
# Test Database Configuration


     

       
34

       
+

       
POSTGRES_TEST_DB=coves_test


     

       
35

       
+

       
POSTGRES_TEST_USER=test_user


     

       
36

       
+

       
POSTGRES_TEST_PASSWORD=test_password


     

       
37

       
+

       
POSTGRES_TEST_PORT=5434


     

       
38

       
+

       
```


     

       
39

       
+

       



     

       
40

       
+

       
**No separate `.env.test` file needed!** Everything is in `.env.dev`.


     

       
41

       
+

       



     

       
42

       
+

       
### Test Database


     

       
43

       
+

       



     

       
44

       
+

       
The test database runs in Docker via [docker-compose.dev.yml](docker-compose.dev.yml):


     

       
45

       
+

       



     

       
46

       
+

       
- **Service**: `postgres-test` (profile: `test`)


     

       
47

       
+

       
- **Port**: 5434 (separate from dev database on 5433)


     

       
48

       
+

       
- **Automatic startup**: The Makefile handles starting/stopping


     

       
49

       
+

       
- **Isolated data**: Completely separate from development database


     

       
50

       
+

       



     

       
51

       
+

       
### Running Tests Manually


     

       
52

       
+

       



     

       
53

       
+

       
If you need to run tests without the Makefile:


     

       
54

       
+

       



     

       
55

       
+

       
```bash


     

       
56

       
+

       
# 1. Load environment variables


     

       
57

       
+

       
set -a && source .env.dev && set +a


     

       
58

       
+

       



     

       
59

       
+

       
# 2. Start test database


     

       
60

       
+

       
docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test


     

       
61

       
+

       



     

       
62

       
+

       
# 3. Wait for it to be ready


     

       
63

       
+

       
sleep 3


     

       
64

       
+

       



     

       
65

       
+

       
# 4. Run migrations


     

       
66

       
+

       
goose -dir internal/db/migrations postgres \


     

       
67

       
+

       
  "postgresql://$POSTGRES_TEST_USER:$POSTGRES_TEST_PASSWORD@localhost:$POSTGRES_TEST_PORT/$POSTGRES_TEST_DB?sslmode=disable" up


     

       
68

       
+

       



     

       
69

       
+

       
# 5. Run tests


     

       
70

       
+

       
go test ./... -v


     

       
71

       
+

       



     

       
72

       
+

       
# 6. Stop test database (optional)


     

       
73

       
+

       
docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test stop postgres-test


     

       
74

       
+

       
```


     

       
75

       
+

       



     

       
76

       
+

       
**Note**: The Makefile automatically loads `.env.dev` variables, so `make test` is simpler than running manually.


     

       
77

       
+

       



     

       
78

       
+

       
## Test Types


     

       
79

       
+

       



     

       
80

       
+

       
### 1. Unit Tests


     

       
81

       
+

       



     

       
82

       
+

       
Test individual components in isolation.


     

       
83

       
+

       



     

       
84

       
+

       
**Example**: [internal/core/users/service_test.go](internal/core/users/service_test.go)


     

       
85

       
+

       



     

       
86

       
+

       
```bash


     

       
87

       
+

       
# Run unit tests for a specific package


     

       
88

       
+

       
go test -v ./internal/core/users/...


     

       
89

       
+

       
```


     

       
90

       
+

       



     

       
91

       
+

       
### 2. Integration Tests


     

       
92

       
+

       



     

       
93

       
+

       
Test full request/response flows with a real database.


     

       
94

       
+

       



     

       
95

       
+

       
**Location**: [tests/integration/](tests/integration/)


     

       
96

       
+

       



     

       
97

       
+

       
**How they work**:


     

       
98

       
+

       
- Start test database


     

       
99

       
+

       
- Run migrations


     

       
100

       
+

       
- Execute HTTP requests against real handlers


     

       
101

       
+

       
- Verify responses


     

       
102

       
+

       



     

       
103

       
+

       
**Example**: [tests/integration/integration_test.go](tests/integration/integration_test.go)


     

       
104

       
+

       



     

       
105

       
+

       
```bash


     

       
106

       
+

       
# Run integration tests


     

       
107

       
+

       
make test


     

       
108

       
+

       
# or


     

       
109

       
+

       
go test -v ./tests/integration/...


     

       
110

       
+

       
```


     

       
111

       
+

       



     

       
112

       
+

       
### 3. Lexicon Validation Tests


     

       
113

       
+

       



     

       
114

       
+

       
Validate AT Protocol Lexicon schemas and test data.


     

       
115

       
+

       



     

       
116

       
+

       
**Components**:


     

       
117

       
+

       
- **Schemas**: [internal/atproto/lexicon/](internal/atproto/lexicon/) - 57 lexicon schema files


     

       
118

       
+

       
- **Test Data**: [tests/lexicon-test-data/](tests/lexicon-test-data/) - Example records for validation


     

       
119

       
+

       
- **Validator**: [cmd/validate-lexicon/](cmd/validate-lexicon/) - Validation tool


     

       
120

       
+

       
- **Library**: [internal/validation/](internal/validation/) - Validation helpers


     

       
121

       
+

       



     

       
122

       
+

       
**Running validation**:


     

       
123

       
+

       



     

       
124

       
+

       
```bash


     

       
125

       
+

       
# Full validation (schemas + test data)


     

       
126

       
 

       
go run cmd/validate-lexicon/main.go


     

       
127

       
 

       



     

       
128

       
+

       
# Schemas only (skip test data)


     

       
129

       
 

       
go run cmd/validate-lexicon/main.go --schemas-only


     

       
130

       
 

       



     

       
131

       
 

       
# Verbose output


     

       
132

       
 

       
go run cmd/validate-lexicon/main.go -v


     

       
133

       
 

       



     

       
134

       
+

       
# Strict mode


     

       
135

       
 

       
go run cmd/validate-lexicon/main.go --strict


     

       
136

       
 

       
```


     

       
137

       
 

       



     

       
138

       
+

       
**Test data naming convention**:


     

       
139

       
+

       
- `*-valid*.json` - Should pass validation


     

       
140

       
+

       
- `*-invalid-*.json` - Should fail validation (tests error detection)


     

       
141

       
+

       



     

       
142

       
+

       
**Current coverage** (as of last update):


     

       
143

       
+

       
- ✅ social.coves.actor.profile


     

       
144

       
+

       
- ✅ social.coves.community.profile


     

       
145

       
+

       
- ✅ social.coves.post.record


     

       
146

       
+

       
- ✅ social.coves.interaction.vote


     

       
147

       
+

       
- ✅ social.coves.moderation.ban


     

       
148

       
+

       



     

       
149

       
+

       
## Database Migrations


     

       
150

       
+

       



     

       
151

       
+

       
Migrations are managed with [goose](https://github.com/pressly/goose) and stored in [internal/db/migrations/](internal/db/migrations/).


     

       
152

       
+

       



     

       
153

       
+

       
### Running Migrations


     

       
154

       
+

       



     

       
155

       
+

       
```bash


     

       
156

       
+

       
# Development database


     

       
157

       
+

       
make db-migrate


     

       
158

       
 

       



     

       
159

       
+

       
# Test database (automatically run by `make test`)


     

       
160

       
+

       
make test-db-reset


     

       
161

       
 

       
```


     

       

       

       
     

       

       

       
     

       

       

       
     

       
162

       
 

       



     

       
163

       
+

       
### Creating Migrations


     

       
164

       
 

       



     

       
165

       
+

       
```bash


     

       
166

       
+

       
# Create a new migration


     

       
167

       
+

       
goose -dir internal/db/migrations create migration_name sql


     

       

       

       
     

       
168

       
 

       



     

       
169

       
+

       
# This creates:


     

       
170

       
+

       
# internal/db/migrations/YYYYMMDDHHMMSS_migration_name.sql


     

       
171

       
+

       
```


     

       

       

       
     

       

       

       
     

       

       

       
     

       
172

       
 

       



     

       
173

       
+

       
### Migration Best Practices


     

       
174

       
+

       



     

       
175

       
+

       
- **Always test migrations** on test database first


     

       
176

       
+

       
- **Write both Up and Down** migrations


     

       
177

       
+

       
- **Keep migrations atomic** - one logical change per migration


     

       
178

       
+

       
- **Test rollback** - verify the Down migration works


     

       
179

       
+

       
- **Don't modify old migrations** - create new ones instead


     

       
180

       
+

       



     

       
181

       
+

       
## Test Database Management


     

       
182

       
+

       



     

       
183

       
+

       
### Fresh Start


     

       
184

       
 

       



     

       
185

       
+

       
```bash


     

       
186

       
+

       
# Complete reset (deletes all data)


     

       
187

       
+

       
make test-db-reset


     

       
188

       
 

       
```


     

       
189

       
 

       



     

       
190

       
+

       
### Connecting to Test Database


     

       
191

       
+

       



     

       
192

       
 

       
```bash


     

       
193

       
+

       
# Using psql


     

       
194

       
+

       
PGPASSWORD=test_password psql -h localhost -p 5434 -U test_user -d coves_test


     

       
195

       
 

       



     

       
196

       
+

       
# Using docker exec


     

       
197

       
+

       
docker exec -it coves-test-postgres psql -U test_user -d coves_test


     

       
198

       
 

       
```


     

       
199

       
 

       



     

       
200

       
+

       
### Inspecting Test Data


     

       

       

       
     

       

       

       
     

       

       

       
     

       
201

       
 

       



     

       
202

       
+

       
```sql


     

       
203

       
+

       
-- List all tables


     

       
204

       
+

       
\dt


     

       
205

       
 

       



     

       
206

       
+

       
-- View table schema


     

       
207

       
+

       
\d table_name


     

       

       

       
     

       

       

       
     

       
208

       
 

       



     

       
209

       
+

       
-- Query data


     

       
210

       
+

       
SELECT * FROM users;


     

       

       

       
     

       
211

       
 

       



     

       
212

       
+

       
-- Check migrations


     

       
213

       
+

       
SELECT * FROM goose_db_version;


     

       
214

       
+

       
```


     

       
215

       
 

       



     

       
216

       
+

       
## Writing Tests


     

       

       

       
     

       

       

       
     

       

       

       
     

       
217

       
 

       



     

       
218

       
+

       
### Integration Test Template


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
219

       
 

       



     

       
220

       
+

       
```go


     

       
221

       
+

       
package integration


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
222

       
 

       



     

       
223

       
+

       
import (


     

       
224

       
+

       
	"testing"


     

       
225

       
+

       
	// ... imports


     

       
226

       
+

       
)


     

       
227

       
 

       



     

       
228

       
+

       
func TestYourFeature(t *testing.T) {


     

       
229

       
+

       
	db := setupTestDB(t)


     

       
230

       
+

       
	defer db.Close()


     

       
231

       
 

       



     

       
232

       
+

       
	// Wire up dependencies


     

       
233

       
+

       
	repo := postgres.NewYourRepository(db)


     

       
234

       
+

       
	service := yourpackage.NewYourService(repo)


     

       

       

       
     

       

       

       
     

       

       

       
     

       
235

       
 

       



     

       
236

       
+

       
	// Create test router


     

       
237

       
+

       
	r := chi.NewRouter()


     

       
238

       
+

       
	r.Mount("/api/path", routes.YourRoutes(service))


     

       
239

       
+

       



     

       
240

       
+

       
	// Make request


     

       
241

       
+

       
	req := httptest.NewRequest("GET", "/api/path", nil)


     

       
242

       
+

       
	w := httptest.NewRecorder()


     

       
243

       
+

       
	r.ServeHTTP(w, req)


     

       
244

       
+

       



     

       
245

       
+

       
	// Assert


     

       
246

       
+

       
	if w.Code != http.StatusOK {


     

       
247

       
+

       
		t.Errorf("Expected 200, got %d", w.Code)


     

       
248

       
+

       
	}


     

       
249

       
+

       
}


     

       
250

       
+

       
```


     

       
251

       
+

       



     

       
252

       
+

       
### Test Helper: setupTestDB


     

       
253

       
+

       



     

       
254

       
+

       
The `setupTestDB` function (in [tests/integration/integration_test.go](tests/integration/integration_test.go)):


     

       
255

       
+

       
- Reads config from environment variables (set by `.env.dev`)


     

       
256

       
+

       
- Connects to test database


     

       
257

       
+

       
- Runs migrations


     

       
258

       
+

       
- Cleans up test data


     

       
259

       
+

       
- Returns ready-to-use `*sql.DB`


     

       
260

       
+

       



     

       
261

       
+

       
## Common Test Commands


     

       
262

       
+

       



     

       
263

       
 

       
```bash


     

       
264

       
+

       
# Run all tests


     

       
265

       
+

       
make test


     

       
266

       
+

       



     

       
267

       
+

       
# Run specific test package


     

       
268

       
+

       
go test -v ./internal/core/users/...


     

       
269

       
+

       



     

       
270

       
+

       
# Run specific test


     

       
271

       
+

       
go test -v ./tests/integration/... -run TestCreateUser


     

       
272

       
+

       



     

       
273

       
+

       
# Run with coverage


     

       
274

       
+

       
go test -v -cover ./...


     

       
275

       
+

       



     

       
276

       
+

       
# Run with race detector


     

       
277

       
+

       
go test -v -race ./...


     

       
278

       
+

       



     

       
279

       
+

       
# Verbose output


     

       
280

       
+

       
go test -v ./...


     

       
281

       
+

       



     

       
282

       
+

       
# Clean and run


     

       
283

       
+

       
make test-db-reset && make test


     

       
284

       
+

       
```


     

       
285

       
 

       



     

       
286

       
+

       
## Troubleshooting


     

       
287

       
+

       



     

       
288

       
+

       
### Test database won't start


     

       
289

       
 

       



     

       
290

       
+

       
```bash


     

       
291

       
+

       
# Check if port 5434 is in use


     

       
292

       
+

       
lsof -i :5434


     

       
293

       
+

       



     

       
294

       
+

       
# Check container logs


     

       
295

       
+

       
docker logs coves-test-postgres


     

       
296

       
+

       



     

       
297

       
+

       
# Nuclear reset


     

       
298

       
+

       
docker-compose -f docker-compose.dev.yml --profile test down -v


     

       
299

       
+

       
make test-db-reset


     

       
300

       
+

       
```


     

       
301

       
+

       



     

       
302

       
+

       
### Migrations failing


     

       
303

       
+

       



     

       
304

       
+

       
```bash


     

       
305

       
+

       
# Load environment and check migration status


     

       
306

       
+

       
set -a && source .env.dev && set +a


     

       
307

       
+

       
goose -dir internal/db/migrations postgres \


     

       
308

       
+

       
  "postgresql://$POSTGRES_TEST_USER:$POSTGRES_TEST_PASSWORD@localhost:$POSTGRES_TEST_PORT/$POSTGRES_TEST_DB?sslmode=disable" status


     

       
309

       
+

       



     

       
310

       
+

       
# Reset and retry


     

       
311

       
+

       
make test-db-reset


     

       
312

       
+

       
```


     

       
313

       
+

       



     

       
314

       
+

       
### Tests can't connect to database


     

       
315

       
+

       



     

       
316

       
+

       
```bash


     

       
317

       
+

       
# Verify test database is running


     

       
318

       
+

       
docker ps | grep coves-test-postgres


     

       
319

       
+

       



     

       
320

       
+

       
# Verify environment variables


     

       
321

       
+

       
set -a && source .env.dev && set +a && echo "Test DB Port: $POSTGRES_TEST_PORT"


     

       
322

       
+

       



     

       
323

       
+

       
# Test connection manually


     

       
324

       
+

       
PGPASSWORD=test_password psql -h localhost -p 5434 -U test_user -d coves_test -c "SELECT 1"


     

       
325

       
+

       
```


     

       
326

       
+

       



     

       
327

       
+

       
### Lexicon validation errors


     

       
328

       
+

       



     

       
329

       
+

       
```bash


     

       
330

       
+

       
# Check schema syntax


     

       
331

       
+

       
cat internal/atproto/lexicon/path/to/schema.json | jq .


     

       
332

       
+

       



     

       
333

       
+

       
# Validate specific schema


     

       
334

       
+

       
go run cmd/validate-lexicon/main.go -v


     

       
335

       
+

       



     

       
336

       
+

       
# Check test data format


     

       
337

       
+

       
cat tests/lexicon-test-data/your-test.json | jq .


     

       
338

       
+

       
```


     

       
339

       
+

       



     

       
340

       
+

       
## Best Practices


     

       
341

       
+

       



     

       
342

       
+

       
### Test Organization


     

       
343

       
+

       
- ✅ Unit tests live next to the code they test (`*_test.go`)


     

       
344

       
+

       
- ✅ Integration tests live in `tests/integration/`


     

       
345

       
+

       
- ✅ Test data lives in `tests/lexicon-test-data/`


     

       
346

       
+

       
- ✅ One test file per feature/endpoint


     

       
347

       
+

       



     

       
348

       
+

       
### Test Data


     

       
349

       
+

       
- ✅ Use `@example.com` emails for test users (auto-cleaned by setupTestDB)


     

       
350

       
+

       
- ✅ Clean up data in tests (or rely on setupTestDB cleanup)


     

       
351

       
+

       
- ✅ Don't rely on specific test execution order


     

       
352

       
+

       
- ✅ Each test should be independent


     

       
353

       
+

       



     

       
354

       
+

       
### Database Tests


     

       
355

       
+

       
- ✅ Always use the test database (port 5434)


     

       
356

       
+

       
- ✅ Never connect to development database (port 5433) in tests


     

       
357

       
+

       
- ✅ Use transactions for fast test cleanup (where applicable)


     

       
358

       
+

       
- ✅ Test with realistic data sizes


     

       
359

       
+

       



     

       
360

       
+

       
### Lexicon Tests


     

       
361

       
+

       
- ✅ Create both valid and invalid test cases


     

       
362

       
+

       
- ✅ Cover all required fields


     

       
363

       
+

       
- ✅ Test edge cases (empty strings, max lengths, etc.)


     

       
364

       
+

       
- ✅ Update tests when schemas change


     

       
365

       
+

       



     

       
366

       
+

       
## CI/CD Integration


     

       
367

       
+

       



     

       
368

       
+

       
When setting up CI/CD, the test pipeline should:


     

       
369

       
+

       



     

       
370

       
+

       
```yaml


     

       
371

       
+

       
# Example GitHub Actions workflow


     

       
372

       
+

       
steps:


     

       
373

       
+

       
  - name: Start test database


     

       
374

       
+

       
    run: |


     

       
375

       
+

       
      docker-compose -f docker-compose.dev.yml --env-file .env.dev --profile test up -d postgres-test


     

       
376

       
+

       
      sleep 5


     

       
377

       
+

       



     

       
378

       
+

       
  - name: Run migrations


     

       
379

       
+

       
    run: make test-db-migrate  # (add this to Makefile if needed)


     

       
380

       
+

       



     

       
381

       
+

       
  - name: Run tests


     

       
382

       
+

       
    run: make test


     

       
383

       
+

       



     

       
384

       
+

       
  - name: Cleanup


     

       
385

       
+

       
    run: docker-compose -f docker-compose.dev.yml --profile test down -v


     

       
386

       
+

       
```


     

       
387

       
+

       



     

       
388

       
+

       
## Related Documentation


     

       
389

       
+

       



     

       
390

       
+

       
- [Makefile](Makefile) - All test commands


     

       
391

       
+

       
- [.env.dev](.env.dev) - Test configuration


     

       
392

       
+

       
- [docker-compose.dev.yml](docker-compose.dev.yml) - Test database setup


     

       
393

       
+

       
- [LOCAL_DEVELOPMENT.md](docs/LOCAL_DEVELOPMENT.md) - Full development setup


     

       
394

       
+

       
- [CLAUDE.md](CLAUDE.md) - Build guidelines


     

       
395

       
+

       



     

       
396

       
+

       
## Getting Help


     

       
397

       
+

       



     

       
398

       
+

       
If tests are failing:


     

       
399

       
+

       
1. Check [Troubleshooting](#troubleshooting) section above


     

       
400

       
+

       
2. Verify `.env.dev` has correct test database config


     

       
401

       
+

       
3. Run `make test-db-reset` for a clean slate


     

       
402

       
+

       
4. Check test database logs: `docker logs coves-test-postgres`


     

       
403

       
+

       



     

       
404

       
+

       
For questions about:


     

       
405

       
+

       
- **Test infrastructure**: This document


     

       
406

       
+

       
- **AT Protocol testing**: [ATPROTO_GUIDE.md](ATPROTO_GUIDE.md)


     

       
407

       
+

       
- **Development setup**: [LOCAL_DEVELOPMENT.md](docs/LOCAL_DEVELOPMENT.md)
+17 -10
docs/LOCAL_DEVELOPMENT.md 
···

       
190

       
 

       
### Testing Commands


     

       
191

       
 

       



     

       
192

       
 

       
```bash


     

       
193

       
-

       
make test              # Run all tests with test database


     

       
194

       
-

       
make test-db-reset     # Reset test database


     

       

       

       
     

       
195

       
 

       
```


     

       

       

       
     

       

       

       
     

       
196

       
 

       



     

       
197

       
 

       
### Workflow Commands


     

       
198

       
 

       



     
···

       
385

       
 

       



     

       
386

       
 

       
## Environment Variables


     

       
387

       
 

       



     

       
388

       
-

       
All configuration is in `.env.dev`:


     

       
389

       
 

       



     

       
390

       
-

       
### Database Configuration


     

       
391

       
 

       
```bash


     

       
392

       
 

       
POSTGRES_HOST=localhost


     

       
393

       
 

       
POSTGRES_PORT=5433


     
···

       
396

       
 

       
POSTGRES_PASSWORD=dev_password


     

       
397

       
 

       
```


     

       
398

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
399

       
 

       
### PDS Configuration


     

       
400

       
 

       
```bash


     

       
401

       
 

       
PDS_HOSTNAME=localhost


     
···

       
403

       
 

       
PDS_JWT_SECRET=local-dev-jwt-secret-change-in-production


     

       
404

       
 

       
PDS_ADMIN_PASSWORD=admin


     

       
405

       
 

       
PDS_SERVICE_HANDLE_DOMAINS=.local.coves.dev


     

       
406

       
-

       
```


     

       
407

       
-

       



     

       
408

       
-

       
### Relay Configuration


     

       
409

       
-

       
```bash


     

       
410

       
-

       
BGS_PORT=2471


     

       
411

       
-

       
BGS_ADMIN_KEY=dev-admin-key


     

       
412

       
 

       
```


     

       
413

       
 

       



     

       
414

       
 

       
### AppView Configuration


     
···

       
423

       
 

       
ENV=development


     

       
424

       
 

       
LOG_LEVEL=debug


     

       
425

       
 

       
```


     

       

       

       
     

       

       

       
     

       
426

       
 

       



     

       
427

       
 

       
## Next Steps


     

       
428

       
 

       



     
···

       
190

       
 

       
### Testing Commands


     

       
191

       
 

       



     

       
192

       
 

       
```bash


     

       
193

       
+

       
make test              # Run all tests (starts test DB, runs migrations, executes tests)


     

       
194

       
+

       
make test-db-reset     # Reset test database (clean slate)


     

       
195

       
+

       
make test-db-stop      # Stop test database


     

       
196

       
 

       
```


     

       
197

       
+

       



     

       
198

       
+

       
**See [TESTING_SUMMARY.md](../TESTING_SUMMARY.md) for complete testing documentation.**


     

       
199

       
 

       



     

       
200

       
 

       
### Workflow Commands


     

       
201

       
 

       



     
···

       
388

       
 

       



     

       
389

       
 

       
## Environment Variables


     

       
390

       
 

       



     

       
391

       
+

       
All configuration is in [.env.dev](../.env.dev) - a single file for both development and testing:


     

       
392

       
 

       



     

       
393

       
+

       
### Development Database (Port 5433)


     

       
394

       
 

       
```bash


     

       
395

       
 

       
POSTGRES_HOST=localhost


     

       
396

       
 

       
POSTGRES_PORT=5433


     
···

       
399

       
 

       
POSTGRES_PASSWORD=dev_password


     

       
400

       
 

       
```


     

       
401

       
 

       



     

       
402

       
+

       
### Test Database (Port 5434)


     

       
403

       
+

       
```bash


     

       
404

       
+

       
POSTGRES_TEST_DB=coves_test


     

       
405

       
+

       
POSTGRES_TEST_USER=test_user


     

       
406

       
+

       
POSTGRES_TEST_PASSWORD=test_password


     

       
407

       
+

       
POSTGRES_TEST_PORT=5434


     

       
408

       
+

       
```


     

       
409

       
+

       



     

       
410

       
 

       
### PDS Configuration


     

       
411

       
 

       
```bash


     

       
412

       
 

       
PDS_HOSTNAME=localhost


     
···

       
414

       
 

       
PDS_JWT_SECRET=local-dev-jwt-secret-change-in-production


     

       
415

       
 

       
PDS_ADMIN_PASSWORD=admin


     

       
416

       
 

       
PDS_SERVICE_HANDLE_DOMAINS=.local.coves.dev


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
417

       
 

       
```


     

       
418

       
 

       



     

       
419

       
 

       
### AppView Configuration


     
···

       
428

       
 

       
ENV=development


     

       
429

       
 

       
LOG_LEVEL=debug


     

       
430

       
 

       
```


     

       
431

       
+

       



     

       
432

       
+

       
**No separate `.env.test` file needed!** All configuration (dev + test) is in `.env.dev`.


     

       
433

       
 

       



     

       
434

       
 

       
## Next Steps


     

       
435
+23 -3
tests/integration/integration_test.go 
···

       
6

       
 

       
	"bytes"


     

       
7

       
 

       
	"database/sql"


     

       
8

       
 

       
	"encoding/json"


     

       

       

       
     

       
9

       
 

       
	"net/http"


     

       
10

       
 

       
	"net/http/httptest"


     

       
11

       
 

       
	"os"


     
···

       
19

       
 

       
)


     

       
20

       
 

       



     

       
21

       
 

       
func setupTestDB(t *testing.T) *sql.DB {


     

       
22

       
-

       
	dbURL := os.Getenv("TEST_DATABASE_URL")


     

       
23

       
-

       
	if dbURL == "" {


     

       
24

       
-

       
		dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
25

       
 

       
	}


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
26

       
 

       



     

       
27

       
 

       
	db, err := sql.Open("postgres", dbURL)


     

       
28

       
 

       
	if err != nil {


     
···

       
6

       
 

       
	"bytes"


     

       
7

       
 

       
	"database/sql"


     

       
8

       
 

       
	"encoding/json"


     

       
9

       
+

       
	"fmt"


     

       
10

       
 

       
	"net/http"


     

       
11

       
 

       
	"net/http/httptest"


     

       
12

       
 

       
	"os"


     
···

       
20

       
 

       
)


     

       
21

       
 

       



     

       
22

       
 

       
func setupTestDB(t *testing.T) *sql.DB {


     

       
23

       
+

       
	// Build connection string from environment variables (set by .env.dev)


     

       
24

       
+

       
	// These are loaded by the Makefile when running tests


     

       
25

       
+

       
	testUser := os.Getenv("POSTGRES_TEST_USER")


     

       
26

       
+

       
	testPassword := os.Getenv("POSTGRES_TEST_PASSWORD")


     

       
27

       
+

       
	testPort := os.Getenv("POSTGRES_TEST_PORT")


     

       
28

       
+

       
	testDB := os.Getenv("POSTGRES_TEST_DB")


     

       
29

       
+

       



     

       
30

       
+

       
	// Fallback to defaults if not set


     

       
31

       
+

       
	if testUser == "" {


     

       
32

       
+

       
		testUser = "test_user"


     

       
33

       
 

       
	}


     

       
34

       
+

       
	if testPassword == "" {


     

       
35

       
+

       
		testPassword = "test_password"


     

       
36

       
+

       
	}


     

       
37

       
+

       
	if testPort == "" {


     

       
38

       
+

       
		testPort = "5434"


     

       
39

       
+

       
	}


     

       
40

       
+

       
	if testDB == "" {


     

       
41

       
+

       
		testDB = "coves_test"


     

       
42

       
+

       
	}


     

       
43

       
+

       



     

       
44

       
+

       
	dbURL := fmt.Sprintf("postgres://%s:%s@localhost:%s/%s?sslmode=disable",


     

       
45

       
+

       
		testUser, testPassword, testPort, testDB)


     

       
46

       
 

       



     

       
47

       
 

       
	db, err := sql.Open("postgres", dbURL)


     

       
48

       
 

       
	if err != nil {