commit b4ddb008c0cdc30f799eeaa1f813b2e811013c60 · bretton.dev/coves

+34 -25

tests/e2e/user_signup_test.go

···

       1
       1
        
       package e2e

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/identity"

     

       5
       5
       +
       	"Coves/internal/atproto/jetstream"

     

       6
       6
       +
       	"Coves/internal/core/users"

     

       7
       7
       +
       	"Coves/internal/db/postgres"

     

       4
       8
        
       	"bytes"

     

       5
       9
        
       	"context"

     

       6
       10
        
       	"database/sql"

     
···

       11
       15
        
       	"testing"

     

       12
       16
        
       	"time"

     

       13
       17
        
       

     

       14
       14
       -
       	"Coves/internal/atproto/identity"

     

       15
       15
       -
       	"Coves/internal/atproto/jetstream"

     

       16
       16
       -
       	"Coves/internal/core/users"

     

       17
       17
       -
       	"Coves/internal/db/postgres"

     

       18
       18
        
       	_ "github.com/lib/pq"

     

       19
       19
        
       	"github.com/pressly/goose/v3"

     

       20
       20
        
       )

     
···

       31
       31
        
       //   - Test database on localhost:5434

     

       32
       32
        
       //

     

       33
       33
        
       // Run with:

     

       34
       34
       -
       //   make e2e-up  # Start infrastructure

     

       35
       35
       -
       //   go run ./cmd/server &  # Start AppView

     

       36
       36
       -
       //   go test ./tests/integration -run TestE2E_UserSignup -v

     

       34
       34
       +
       //

     

       35
       35
       +
       //	make e2e-up  # Start infrastructure

     

       36
       36
       +
       //	go run ./cmd/server &  # Start AppView

     

       37
       37
       +
       //	go test ./tests/integration -run TestE2E_UserSignup -v

     

       37
       38
        
       func TestE2E_UserSignup(t *testing.T) {

     

       38
       39
        
       	if testing.Short() {

     

       39
       40
        
       		t.Skip("Skipping E2E test in short mode")

     
···

       55
       56
        
       	}

     

       56
       57
        
       

     

       57
       58
        
       	db := setupTestDB(t)

     

       58
       58
       -
       	defer db.Close()

     

       59
       59
       +
       	defer func() {

     

       60
       60
       +
       		if err := db.Close(); err != nil {

     

       61
       61
       +
       			t.Logf("Failed to close database: %v", err)

     

       62
       62
       +
       		}

     

       63
       63
       +
       	}()

     

       59
       64
        
       

     

       60
       65
        
       	// Set up services

     

       61
       66
        
       	userRepo := postgres.NewUserRepository(db)

     
···

       253
       258
        
       	if err != nil {

     

       254
       259
        
       		return "", fmt.Errorf("failed to create invite code: %w", err)

     

       255
       260
        
       	}

     

       256
       256
       -
       	defer resp.Body.Close()

     

       261
       261
       +
       	defer func() { _ = resp.Body.Close() }()

     

       257
       262
        
       

     

       258
       263
        
       	if resp.StatusCode != http.StatusOK {

     

       259
       264
        
       		var errorResp map[string]interface{}

     

       260
       260
       -
       		json.NewDecoder(resp.Body).Decode(&errorResp)

     

       265
       265
       +
       		if err := json.NewDecoder(resp.Body).Decode(&errorResp); err != nil {

     

       266
       266
       +
       			return "", fmt.Errorf("PDS admin API returned status %d (failed to decode error: %w)", resp.StatusCode, err)

     

       267
       267
       +
       		}

     

       261
       268
        
       		return "", fmt.Errorf("PDS admin API returned status %d: %v", resp.StatusCode, errorResp)

     

       262
       269
        
       	}

     

       263
       270
        
       

     
···

       303
       310
        
       	if err != nil {

     

       304
       311
        
       		return "", fmt.Errorf("failed to call signup endpoint: %w", err)

     

       305
       312
        
       	}

     

       306
       306
       -
       	defer resp.Body.Close()

     

       313
       313
       +
       	defer func() { _ = resp.Body.Close() }()

     

       307
       314
        
       

     

       308
       315
        
       	if resp.StatusCode != http.StatusOK {

     

       309
       316
        
       		var errorResp map[string]interface{}

     

       310
       310
       -
       		json.NewDecoder(resp.Body).Decode(&errorResp)

     

       317
       317
       +
       		if err := json.NewDecoder(resp.Body).Decode(&errorResp); err != nil {

     

       318
       318
       +
       			return "", fmt.Errorf("signup endpoint returned status %d (failed to decode error: %w)", resp.StatusCode, err)

     

       319
       319
       +
       		}

     

       311
       320
        
       		return "", fmt.Errorf("signup endpoint returned status %d: %v", resp.StatusCode, errorResp)

     

       312
       321
        
       	}

     

       313
       322
        
       

     

       314
       323
        
       	var result struct {

     

       315
       315
       -
       		DID         string `json:"did"`

     

       316
       316
       -
       		Handle      string `json:"handle"`

     

       317
       317
       -
       		AccessJwt   string `json:"accessJwt"`

     

       318
       318
       -
       		RefreshJwt  string `json:"refreshJwt"`

     

       324
       324
       +
       		DID        string `json:"did"`

     

       325
       325
       +
       		Handle     string `json:"handle"`

     

       326
       326
       +
       		AccessJwt  string `json:"accessJwt"`

     

       327
       327
       +
       		RefreshJwt string `json:"refreshJwt"`

     

       319
       328
        
       	}

     

       320
       329
        
       

     

       321
       330
        
       	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     
···

       334
       343
        
       		t.Logf("PDS not available: %v", err)

     

       335
       344
        
       		return false

     

       336
       345
        
       	}

     

       337
       337
       -
       	defer resp.Body.Close()

     

       346
       346
       +
       	defer func() { _ = resp.Body.Close() }()

     

       338
       347
        
       	return resp.StatusCode == http.StatusOK

     

       339
       348
        
       }

     

       340
       349
        
       

     
···

       346
       355
        
       		t.Logf("Jetstream not available: %v", err)

     

       347
       356
        
       		return false

     

       348
       357
        
       	}

     

       349
       349
       -
       	defer resp.Body.Close()

     

       358
       358
       +
       	defer func() { _ = resp.Body.Close() }()

     

       350
       359
        
       	return resp.StatusCode == http.StatusOK

     

       351
       360
        
       }

     

       352
       361
        
       

     
···

       357
       366
        
       		t.Logf("AppView not available: %v", err)

     

       358
       367
        
       		return false

     

       359
       368
        
       	}

     

       360
       360
       -
       	defer resp.Body.Close()

     

       369
       369
       +
       	defer func() { _ = resp.Body.Close() }()

     

       361
       370
        
       	return resp.StatusCode == http.StatusOK

     

       362
       371
        
       }

     

       363
       372
        
       

     
···

       391
       400
        
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       392
       401
        
       	}

     

       393
       402
        
       

     

       394
       394
       -
       	if err := db.Ping(); err != nil {

     

       395
       395
       -
       		t.Fatalf("Failed to ping test database: %v", err)

     

       403
       403
       +
       	if pingErr := db.Ping(); pingErr != nil {

     

       404
       404
       +
       		t.Fatalf("Failed to ping test database: %v", pingErr)

     

       396
       405
        
       	}

     

       397
       406
        
       

     

       398
       398
       -
       	if err := goose.SetDialect("postgres"); err != nil {

     

       399
       399
       -
       		t.Fatalf("Failed to set goose dialect: %v", err)

     

       407
       407
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       408
       408
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       400
       409
        
       	}

     

       401
       410
        
       

     

       402
       402
       -
       	if err := goose.Up(db, "../../internal/db/migrations"); err != nil {

     

       403
       403
       -
       		t.Fatalf("Failed to run migrations: %v", err)

     

       411
       411
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       412
       412
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       404
       413
        
       	}

     

       405
       414
        
       

     

       406
       415
        
       	// Clean up any existing test data

+43 -28

tests/integration/community_consumer_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/did"

     

       5
       5
       +
       	"Coves/internal/atproto/jetstream"

     

       6
       6
       +
       	"Coves/internal/core/communities"

     

       7
       7
       +
       	"Coves/internal/db/postgres"

     

       4
       8
        
       	"context"

     

       5
       9
        
       	"fmt"

     

       6
       10
        
       	"testing"

     

       7
       11
        
       	"time"

     

       8
       8
       -
       

     

       9
       9
       -
       	"Coves/internal/atproto/did"

     

       10
       10
       -
       	"Coves/internal/atproto/jetstream"

     

       11
       11
       -
       	"Coves/internal/core/communities"

     

       12
       12
       -
       	"Coves/internal/db/postgres"

     

       13
       12
        
       )

     

       14
       13
        
       

     

       15
       14
        
       func TestCommunityConsumer_HandleCommunityProfile(t *testing.T) {

     

       16
       15
        
       	db := setupTestDB(t)

     

       17
       17
       -
       	defer db.Close()

     

       16
       16
       +
       	defer func() {

     

       17
       17
       +
       		if err := db.Close(); err != nil {

     

       18
       18
       +
       			t.Logf("Failed to close database: %v", err)

     

       19
       19
       +
       		}

     

       20
       20
       +
       	}()

     

       18
       21
        
       

     

       19
       22
        
       	repo := postgres.NewCommunityRepository(db)

     

       20
       23
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     
···

       22
       25
        
       	ctx := context.Background()

     

       23
       26
        
       

     

       24
       27
        
       	t.Run("creates community from firehose event", func(t *testing.T) {

     

       25
       25
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       28
       28
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       29
       29
       +
       		if err != nil {

     

       30
       30
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       31
       31
       +
       		}

     

       26
       32
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       27
       33
        
       

     

       28
       34
        
       		// Simulate a Jetstream commit event

     
···

       57
       63
        
       		}

     

       58
       64
        
       

     

       59
       65
        
       		// Handle the event

     

       60
       60
       -
       		err := consumer.HandleEvent(ctx, event)

     

       61
       61
       -
       		if err != nil {

     

       66
       66
       +
       		if err := consumer.HandleEvent(ctx, event); err != nil {

     

       62
       67
        
       			t.Fatalf("Failed to handle event: %v", err)

     

       63
       68
        
       		}

     

       64
       69
        
       

     
···

       80
       85
        
       	})

     

       81
       86
        
       

     

       82
       87
        
       	t.Run("updates existing community", func(t *testing.T) {

     

       83
       83
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       88
       88
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       89
       89
       +
       		if err != nil {

     

       90
       90
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       91
       91
       +
       		}

     

       84
       92
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       85
       93
        
       		handle := fmt.Sprintf("!update-test-%s@coves.local", uniqueSuffix)

     

       86
       94
        
       

     
···

       100
       108
        
       			UpdatedAt:              time.Now(),

     

       101
       109
        
       		}

     

       102
       110
        
       

     

       103
       103
       -
       		_, err := repo.Create(ctx, initialCommunity)

     

       104
       104
       -
       		if err != nil {

     

       111
       111
       +
       		if _, err := repo.Create(ctx, initialCommunity); err != nil {

     

       105
       112
        
       			t.Fatalf("Failed to create initial community: %v", err)

     

       106
       113
        
       		}

     

       107
       114
        
       

     
···

       137
       144
        
       		}

     

       138
       145
        
       

     

       139
       146
        
       		// Handle the update

     

       140
       140
       -
       		err = consumer.HandleEvent(ctx, updateEvent)

     

       141
       141
       -
       		if err != nil {

     

       147
       147
       +
       		if err := consumer.HandleEvent(ctx, updateEvent); err != nil {

     

       142
       148
        
       			t.Fatalf("Failed to handle update event: %v", err)

     

       143
       149
        
       		}

     

       144
       150
        
       

     
···

       163
       169
        
       	})

     

       164
       170
        
       

     

       165
       171
        
       	t.Run("deletes community", func(t *testing.T) {

     

       166
       166
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       172
       172
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       173
       173
       +
       		if err != nil {

     

       174
       174
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       175
       175
       +
       		}

     

       167
       176
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       168
       177
        
       

     

       169
       178
        
       		// Create community to delete

     
···

       179
       188
        
       			UpdatedAt:    time.Now(),

     

       180
       189
        
       		}

     

       181
       190
        
       

     

       182
       182
       -
       		_, err := repo.Create(ctx, community)

     

       183
       183
       -
       		if err != nil {

     

       191
       191
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       184
       192
        
       			t.Fatalf("Failed to create community: %v", err)

     

       185
       193
        
       		}

     

       186
       194
        
       

     
···

       198
       206
        
       		}

     

       199
       207
        
       

     

       200
       208
        
       		// Handle the delete

     

       201
       201
       -
       		err = consumer.HandleEvent(ctx, deleteEvent)

     

       202
       202
       -
       		if err != nil {

     

       209
       209
       +
       		if err := consumer.HandleEvent(ctx, deleteEvent); err != nil {

     

       203
       210
        
       			t.Fatalf("Failed to handle delete event: %v", err)

     

       204
       211
        
       		}

     

       205
       212
        
       

     

       206
       213
        
       		// Verify community was deleted

     

       207
       207
       -
       		_, err = repo.GetByDID(ctx, communityDID)

     

       208
       208
       -
       		if err != communities.ErrCommunityNotFound {

     

       214
       214
       +
       		if _, err := repo.GetByDID(ctx, communityDID); err != communities.ErrCommunityNotFound {

     

       209
       215
        
       			t.Errorf("Expected ErrCommunityNotFound, got: %v", err)

     

       210
       216
        
       		}

     

       211
       217
        
       	})

     
···

       213
       219
        
       

     

       214
       220
        
       func TestCommunityConsumer_HandleSubscription(t *testing.T) {

     

       215
       221
        
       	db := setupTestDB(t)

     

       216
       216
       -
       	defer db.Close()

     

       222
       222
       +
       	defer func() {

     

       223
       223
       +
       		if err := db.Close(); err != nil {

     

       224
       224
       +
       			t.Logf("Failed to close database: %v", err)

     

       225
       225
       +
       		}

     

       226
       226
       +
       	}()

     

       217
       227
        
       

     

       218
       228
        
       	repo := postgres.NewCommunityRepository(db)

     

       219
       229
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     
···

       222
       232
        
       

     

       223
       233
        
       	t.Run("creates subscription from event", func(t *testing.T) {

     

       224
       234
        
       		// Create a community first

     

       225
       225
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       235
       235
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       236
       236
       +
       		if err != nil {

     

       237
       237
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       238
       238
       +
       		}

     

       226
       239
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       227
       240
        
       

     

       228
       241
        
       		community := &communities.Community{

     
···

       237
       250
        
       			UpdatedAt:    time.Now(),

     

       238
       251
        
       		}

     

       239
       252
        
       

     

       240
       240
       -
       		_, err := repo.Create(ctx, community)

     

       241
       241
       -
       		if err != nil {

     

       253
       253
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       242
       254
        
       			t.Fatalf("Failed to create community: %v", err)

     

       243
       255
        
       		}

     

       244
       256
        
       

     
···

       261
       273
        
       		}

     

       262
       274
        
       

     

       263
       275
        
       		// Handle the subscription

     

       264
       264
       -
       		err = consumer.HandleEvent(ctx, subEvent)

     

       265
       265
       -
       		if err != nil {

     

       276
       276
       +
       		if err := consumer.HandleEvent(ctx, subEvent); err != nil {

     

       266
       277
        
       			t.Fatalf("Failed to handle subscription event: %v", err)

     

       267
       278
        
       		}

     

       268
       279
        
       

     
···

       293
       304
        
       

     

       294
       305
        
       func TestCommunityConsumer_IgnoresNonCommunityEvents(t *testing.T) {

     

       295
       306
        
       	db := setupTestDB(t)

     

       296
       296
       -
       	defer db.Close()

     

       307
       307
       +
       	defer func() {

     

       308
       308
       +
       		if err := db.Close(); err != nil {

     

       309
       309
       +
       			t.Logf("Failed to close database: %v", err)

     

       310
       310
       +
       		}

     

       311
       311
       +
       	}()

     

       297
       312
        
       

     

       298
       313
        
       	repo := postgres.NewCommunityRepository(db)

     

       299
       314
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

+41 -18

tests/integration/community_credentials_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/did"

     

       5
       5
       +
       	"Coves/internal/core/communities"

     

       6
       6
       +
       	"Coves/internal/db/postgres"

     

       4
       7
        
       	"context"

     

       5
       8
        
       	"fmt"

     

       6
       9
        
       	"testing"

     

       7
       10
        
       	"time"

     

       8
       8
       -
       

     

       9
       9
       -
       	"Coves/internal/atproto/did"

     

       10
       10
       -
       	"Coves/internal/core/communities"

     

       11
       11
       -
       	"Coves/internal/db/postgres"

     

       12
       11
        
       )

     

       13
       12
        
       

     

       14
       13
        
       // TestCommunityRepository_CredentialPersistence tests that PDS credentials are properly persisted

     

       15
       14
        
       func TestCommunityRepository_CredentialPersistence(t *testing.T) {

     

       16
       15
        
       	db := setupTestDB(t)

     

       17
       17
       -
       	defer db.Close()

     

       16
       16
       +
       	defer func() {

     

       17
       17
       +
       		if err := db.Close(); err != nil {

     

       18
       18
       +
       			t.Logf("Failed to close database: %v", err)

     

       19
       19
       +
       		}

     

       20
       20
       +
       	}()

     

       18
       21
        
       

     

       19
       22
        
       	repo := postgres.NewCommunityRepository(db)

     

       20
       23
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       21
       24
        
       	ctx := context.Background()

     

       22
       25
        
       

     

       23
       26
        
       	t.Run("persists PDS credentials on create", func(t *testing.T) {

     

       24
       24
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       27
       27
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       28
       28
       +
       		if err != nil {

     

       29
       29
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       30
       30
       +
       		}

     

       25
       31
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       26
       32
        
       

     

       27
       33
        
       		community := &communities.Community{

     
···

       75
       81
        
       	})

     

       76
       82
        
       

     

       77
       83
        
       	t.Run("handles empty credentials gracefully", func(t *testing.T) {

     

       78
       78
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       84
       84
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       85
       85
       +
       		if err != nil {

     

       86
       86
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       87
       87
       +
       		}

     

       79
       88
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       80
       89
        
       

     

       81
       90
        
       		// Community without PDS credentials (e.g., from Jetstream consumer)

     
···

       122
       131
        
       // TestCommunityRepository_EncryptedCredentials tests encryption at rest

     

       123
       132
        
       func TestCommunityRepository_EncryptedCredentials(t *testing.T) {

     

       124
       133
        
       	db := setupTestDB(t)

     

       125
       125
       -
       	defer db.Close()

     

       134
       134
       +
       	defer func() {

     

       135
       135
       +
       		if err := db.Close(); err != nil {

     

       136
       136
       +
       			t.Logf("Failed to close database: %v", err)

     

       137
       137
       +
       		}

     

       138
       138
       +
       	}()

     

       126
       139
        
       

     

       127
       140
        
       	repo := postgres.NewCommunityRepository(db)

     

       128
       141
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       129
       142
        
       	ctx := context.Background()

     

       130
       143
        
       

     

       131
       144
        
       	t.Run("credentials are encrypted in database", func(t *testing.T) {

     

       132
       132
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       145
       145
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       146
       146
       +
       		if err != nil {

     

       147
       147
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       148
       148
       +
       		}

     

       133
       149
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       134
       150
        
       

     

       135
       151
        
       		accessToken := "sensitive_access_token_xyz123"

     
···

       152
       168
        
       			UpdatedAt:       time.Now(),

     

       153
       169
        
       		}

     

       154
       170
        
       

     

       155
       155
       -
       		_, err := repo.Create(ctx, community)

     

       156
       156
       -
       		if err != nil {

     

       171
       171
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       157
       172
        
       			t.Fatalf("Failed to create community: %v", err)

     

       158
       173
        
       		}

     

       159
       174
        
       

     
···

       164
       179
        
       			FROM communities

     

       165
       180
        
       			WHERE did = $1

     

       166
       181
        
       		`

     

       167
       167
       -
       		err = db.QueryRowContext(ctx, query, communityDID).Scan(&encryptedAccess, &encryptedRefresh)

     

       168
       168
       -
       		if err != nil {

     

       182
       182
       +
       		if err := db.QueryRowContext(ctx, query, communityDID).Scan(&encryptedAccess, &encryptedRefresh); err != nil {

     

       169
       183
        
       			t.Fatalf("Failed to query encrypted data: %v", err)

     

       170
       184
        
       		}

     

       171
       185
        
       

     
···

       200
       214
        
       	})

     

       201
       215
        
       

     

       202
       216
        
       	t.Run("encryption handles special characters", func(t *testing.T) {

     

       203
       203
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       217
       217
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       218
       218
       +
       		if err != nil {

     

       219
       219
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       220
       220
       +
       		}

     

       204
       221
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       205
       222
        
       

     

       206
       223
        
       		// Token with special characters

     
···

       220
       237
        
       			UpdatedAt:       time.Now(),

     

       221
       238
        
       		}

     

       222
       239
        
       

     

       223
       223
       -
       		_, err := repo.Create(ctx, community)

     

       224
       224
       -
       		if err != nil {

     

       240
       240
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       225
       241
        
       			t.Fatalf("Failed to create community with special chars: %v", err)

     

       226
       242
        
       		}

     

       227
       243
        
       

     
···

       239
       255
        
       // TestCommunityRepository_V2OwnershipModel tests that communities are self-owned

     

       240
       256
        
       func TestCommunityRepository_V2OwnershipModel(t *testing.T) {

     

       241
       257
        
       	db := setupTestDB(t)

     

       242
       242
       -
       	defer db.Close()

     

       258
       258
       +
       	defer func() {

     

       259
       259
       +
       		if err := db.Close(); err != nil {

     

       260
       260
       +
       			t.Logf("Failed to close database: %v", err)

     

       261
       261
       +
       		}

     

       262
       262
       +
       	}()

     

       243
       263
        
       

     

       244
       264
        
       	repo := postgres.NewCommunityRepository(db)

     

       245
       265
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       246
       266
        
       	ctx := context.Background()

     

       247
       267
        
       

     

       248
       268
        
       	t.Run("V2 communities are self-owned", func(t *testing.T) {

     

       249
       249
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       269
       269
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       270
       270
       +
       		if err != nil {

     

       271
       271
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       272
       272
       +
       		}

     

       250
       273
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       251
       274
        
       

     

       252
       275
        
       		community := &communities.Community{

+99 -44

tests/integration/community_e2e_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/api/routes"

     

       5
       5
       +
       	"Coves/internal/atproto/did"

     

       6
       6
       +
       	"Coves/internal/atproto/identity"

     

       7
       7
       +
       	"Coves/internal/atproto/jetstream"

     

       8
       8
       +
       	"Coves/internal/core/communities"

     

       9
       9
       +
       	"Coves/internal/core/users"

     

       10
       10
       +
       	"Coves/internal/db/postgres"

     

       4
       11
        
       	"bytes"

     

       5
       12
        
       	"context"

     

       6
       13
        
       	"database/sql"

     
···

       19
       26
        
       	"github.com/gorilla/websocket"

     

       20
       27
        
       	_ "github.com/lib/pq"

     

       21
       28
        
       	"github.com/pressly/goose/v3"

     

       22
       22
       -
       

     

       23
       23
       -
       	"Coves/internal/api/routes"

     

       24
       24
       -
       	"Coves/internal/atproto/did"

     

       25
       25
       -
       	"Coves/internal/atproto/identity"

     

       26
       26
       -
       	"Coves/internal/atproto/jetstream"

     

       27
       27
       -
       	"Coves/internal/core/communities"

     

       28
       28
       -
       	"Coves/internal/core/users"

     

       29
       29
       -
       	"Coves/internal/db/postgres"

     

       30
       29
        
       )

     

       31
       30
        
       

     

       32
       31
        
       // TestCommunity_E2E is a TRUE end-to-end test covering the complete flow:

     
···

       55
       54
        
       	if err != nil {

     

       56
       55
        
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       57
       56
        
       	}

     

       58
       58
       -
       	defer db.Close()

     

       57
       57
       +
       	defer func() {

     

       58
       58
       +
       		if closeErr := db.Close(); closeErr != nil {

     

       59
       59
       +
       			t.Logf("Failed to close database: %v", closeErr)

     

       60
       60
       +
       		}

     

       61
       61
       +
       	}()

     

       59
       62
        
       

     

       60
       63
        
       	// Run migrations

     

       61
       61
       -
       	if err := goose.SetDialect("postgres"); err != nil {

     

       62
       62
       -
       		t.Fatalf("Failed to set goose dialect: %v", err)

     

       64
       64
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       65
       65
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       63
       66
        
       	}

     

       64
       64
       -
       	if err := goose.Up(db, "../../internal/db/migrations"); err != nil {

     

       65
       65
       -
       		t.Fatalf("Failed to run migrations: %v", err)

     

       67
       67
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       68
       68
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       66
       69
        
       	}

     

       67
       70
        
       

     

       68
       71
        
       	// Check if PDS is running

     
···

       75
       78
        
       	if err != nil {

     

       76
       79
        
       		t.Skipf("PDS not running at %s: %v", pdsURL, err)

     

       77
       80
        
       	}

     

       78
       78
       -
       	healthResp.Body.Close()

     

       81
       81
       +
       	func() {

     

       82
       82
       +
       		if closeErr := healthResp.Body.Close(); closeErr != nil {

     

       83
       83
       +
       			t.Logf("Failed to close health response: %v", closeErr)

     

       84
       84
       +
       		}

     

       85
       85
       +
       	}()

     

       79
       86
        
       

     

       80
       87
        
       	// Setup dependencies

     

       81
       88
        
       	communityRepo := postgres.NewCommunityRepository(db)

     
···

       208
       215
        
       		if err != nil {

     

       209
       216
        
       			t.Fatalf("Failed to query PDS: %v", err)

     

       210
       217
        
       		}

     

       211
       211
       -
       		defer pdsResp.Body.Close()

     

       218
       218
       +
       		defer func() { _ = pdsResp.Body.Close() }()

     

       212
       219
        
       

     

       213
       220
        
       		if pdsResp.StatusCode != http.StatusOK {

     

       214
       214
       -
       			body, _ := io.ReadAll(pdsResp.Body)

     

       221
       221
       +
       			body, readErr := io.ReadAll(pdsResp.Body)

     

       222
       222
       +
       			if readErr != nil {

     

       223
       223
       +
       				t.Fatalf("PDS returned status %d (failed to read body: %v)", pdsResp.StatusCode, readErr)

     

       224
       224
       +
       			}

     

       215
       225
        
       			t.Fatalf("PDS returned status %d: %s", pdsResp.StatusCode, string(body))

     

       216
       226
        
       		}

     

       217
       227
        
       

     

       218
       228
        
       		var pdsRecord struct {

     

       229
       229
       +
       			Value map[string]interface{} `json:"value"`

     

       219
       230
        
       			URI   string                 `json:"uri"`

     

       220
       231
        
       			CID   string                 `json:"cid"`

     

       221
       221
       -
       			Value map[string]interface{} `json:"value"`

     

       222
       232
        
       		}

     

       223
       233
        
       

     

       224
       234
        
       		if err := json.NewDecoder(pdsResp.Body).Decode(&pdsRecord); err != nil {

     
···

       230
       240
        
       		t.Logf("   CID: %s", pdsRecord.CID)

     

       231
       241
        
       

     

       232
       242
        
       		// Print full record for inspection

     

       233
       233
       -
       		recordJSON, _ := json.MarshalIndent(pdsRecord.Value, "   ", "  ")

     

       234
       234
       -
       		t.Logf("   Record value:\n   %s", string(recordJSON))

     

       243
       243
       +
       		recordJSON, marshalErr := json.MarshalIndent(pdsRecord.Value, "   ", "  ")

     

       244
       244
       +
       		if marshalErr != nil {

     

       245
       245
       +
       			t.Logf("   Failed to marshal record: %v", marshalErr)

     

       246
       246
       +
       		} else {

     

       247
       247
       +
       			t.Logf("   Record value:\n   %s", string(recordJSON))

     

       248
       248
       +
       		}

     

       235
       249
        
       

     

       236
       250
        
       		// V2: DID is NOT in the record - it's in the repository URI

     

       237
       251
        
       		// The record should have handle, name, etc. but no 'did' field

     
···

       330
       344
        
       	// Part 3: XRPC HTTP Endpoints

     

       331
       345
        
       	// ====================================================================================

     

       332
       346
        
       	t.Run("3. XRPC HTTP Endpoints", func(t *testing.T) {

     

       333
       333
       -
       

     

       334
       347
        
       		t.Run("Create via XRPC endpoint", func(t *testing.T) {

     

       335
       348
        
       			// Use Unix timestamp (seconds) instead of UnixNano to keep handle short

     

       336
       349
        
       			createReq := map[string]interface{}{

     
···

       343
       356
        
       				"allowExternalDiscovery": true,

     

       344
       357
        
       			}

     

       345
       358
        
       

     

       346
       346
       -
       			reqBody, _ := json.Marshal(createReq)

     

       359
       359
       +
       			reqBody, marshalErr := json.Marshal(createReq)

     

       360
       360
       +
       			if marshalErr != nil {

     

       361
       361
       +
       				t.Fatalf("Failed to marshal request: %v", marshalErr)

     

       362
       362
       +
       			}

     

       347
       363
        
       

     

       348
       364
        
       			// Step 1: Client POSTs to XRPC endpoint

     

       349
       365
        
       			t.Logf("📡 Client → POST /xrpc/social.coves.community.create")

     
···

       356
       372
        
       			if err != nil {

     

       357
       373
        
       				t.Fatalf("Failed to POST: %v", err)

     

       358
       374
        
       			}

     

       359
       359
       -
       			defer resp.Body.Close()

     

       375
       375
       +
       			defer func() { _ = resp.Body.Close() }()

     

       360
       376
        
       

     

       361
       377
        
       			if resp.StatusCode != http.StatusOK {

     

       362
       362
       -
       				body, _ := io.ReadAll(resp.Body)

     

       378
       378
       +
       				body, readErr := io.ReadAll(resp.Body)

     

       379
       379
       +
       				if readErr != nil {

     

       380
       380
       +
       					t.Fatalf("Expected 200, got %d (failed to read body: %v)", resp.StatusCode, readErr)

     

       381
       381
       +
       				}

     

       363
       382
        
       				t.Logf("❌ XRPC Create Failed")

     

       364
       383
        
       				t.Logf("   Status: %d", resp.StatusCode)

     

       365
       384
        
       				t.Logf("   Response: %s", string(body))

     
···

       373
       392
        
       				Handle string `json:"handle"`

     

       374
       393
        
       			}

     

       375
       394
        
       

     

       376
       376
       -
       			json.NewDecoder(resp.Body).Decode(&createResp)

     

       395
       395
       +
       			if err := json.NewDecoder(resp.Body).Decode(&createResp); err != nil {

     

       396
       396
       +
       				t.Fatalf("Failed to decode create response: %v", err)

     

       397
       397
       +
       			}

     

       377
       398
        
       

     

       378
       399
        
       			t.Logf("✅ XRPC response received:")

     

       379
       400
        
       			t.Logf("   DID:    %s", createResp.DID)

     
···

       409
       430
        
       					CID: createResp.CID,

     

       410
       431
        
       				},

     

       411
       432
        
       			}

     

       412
       412
       -
       			consumer.HandleEvent(context.Background(), &event)

     

       433
       433
       +
       			if handleErr := consumer.HandleEvent(context.Background(), &event); handleErr != nil {

     

       434
       434
       +
       				t.Logf("Warning: failed to handle event: %v", handleErr)

     

       435
       435
       +
       			}

     

       413
       436
        
       

     

       414
       437
        
       			// Step 3: Verify it's indexed in AppView

     

       415
       438
        
       			t.Logf("🔍 Querying AppView to verify indexing...")

     
···

       443
       466
        
       			if err != nil {

     

       444
       467
        
       				t.Fatalf("Failed to GET: %v", err)

     

       445
       468
        
       			}

     

       446
       446
       -
       			defer resp.Body.Close()

     

       469
       469
       +
       			defer func() { _ = resp.Body.Close() }()

     

       447
       470
        
       

     

       448
       471
        
       			if resp.StatusCode != http.StatusOK {

     

       449
       449
       -
       				body, _ := io.ReadAll(resp.Body)

     

       472
       472
       +
       				body, readErr := io.ReadAll(resp.Body)

     

       473
       473
       +
       				if readErr != nil {

     

       474
       474
       +
       					t.Fatalf("Expected 200, got %d (failed to read body: %v)", resp.StatusCode, readErr)

     

       475
       475
       +
       				}

     

       450
       476
        
       				t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body))

     

       451
       477
        
       			}

     

       452
       478
        
       

     

       453
       479
        
       			var getCommunity communities.Community

     

       454
       454
       -
       			json.NewDecoder(resp.Body).Decode(&getCommunity)

     

       480
       480
       +
       			if err := json.NewDecoder(resp.Body).Decode(&getCommunity); err != nil {

     

       481
       481
       +
       				t.Fatalf("Failed to decode get response: %v", err)

     

       482
       482
       +
       			}

     

       455
       483
        
       

     

       456
       456
       -
       			t.Logf("✅ Retrieved via XRPC HTTP endpoint:")

     

       484
       484
       +
       			t.Logf("Retrieved via XRPC HTTP endpoint:")

     

       457
       485
        
       			t.Logf("   DID:         %s", getCommunity.DID)

     

       458
       486
        
       			t.Logf("   DisplayName: %s", getCommunity.DisplayName)

     

       459
       487
        
       

     
···

       473
       501
        
       			if err != nil {

     

       474
       502
        
       				t.Fatalf("Failed to GET list: %v", err)

     

       475
       503
        
       			}

     

       476
       476
       -
       			defer resp.Body.Close()

     

       504
       504
       +
       			defer func() { _ = resp.Body.Close() }()

     

       477
       505
        
       

     

       478
       506
        
       			if resp.StatusCode != http.StatusOK {

     

       479
       479
       -
       				body, _ := io.ReadAll(resp.Body)

     

       507
       507
       +
       				body, readErr := io.ReadAll(resp.Body)

     

       508
       508
       +
       				if readErr != nil {

     

       509
       509
       +
       					t.Fatalf("Expected 200, got %d (failed to read body: %v)", resp.StatusCode, readErr)

     

       510
       510
       +
       				}

     

       480
       511
        
       				t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body))

     

       481
       512
        
       			}

     

       482
       513
        
       

     
···

       485
       516
        
       				Total       int                     `json:"total"`

     

       486
       517
        
       			}

     

       487
       518
        
       

     

       488
       488
       -
       			json.NewDecoder(resp.Body).Decode(&listResp)

     

       519
       519
       +
       			if err := json.NewDecoder(resp.Body).Decode(&listResp); err != nil {

     

       520
       520
       +
       				t.Fatalf("Failed to decode list response: %v", err)

     

       521
       521
       +
       			}

     

       489
       522
        
       

     

       490
       523
        
       			t.Logf("✅ Listed %d communities via XRPC", len(listResp.Communities))

     

       491
       524
        
       

     
···

       547
       580
        
       	collection := "social.coves.community.profile"

     

       548
       581
        
       	rkey := extractRKeyFromURI(community.RecordURI)

     

       549
       582
        
       

     

       550
       550
       -
       	pdsResp, _ := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     

       583
       583
       +
       	pdsResp, pdsErr := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     

       551
       584
        
       		pdsURL, instanceDID, collection, rkey))

     

       552
       552
       -
       	defer pdsResp.Body.Close()

     

       585
       585
       +
       	if pdsErr != nil {

     

       586
       586
       +
       		t.Fatalf("Failed to fetch PDS record: %v", pdsErr)

     

       587
       587
       +
       	}

     

       588
       588
       +
       	defer func() {

     

       589
       589
       +
       		if closeErr := pdsResp.Body.Close(); closeErr != nil {

     

       590
       590
       +
       			t.Logf("Failed to close PDS response: %v", closeErr)

     

       591
       591
       +
       		}

     

       592
       592
       +
       	}()

     

       553
       593
        
       

     

       554
       594
        
       	var pdsRecord struct {

     

       555
       555
       -
       		CID   string                 `json:"cid"`

     

       556
       595
        
       		Value map[string]interface{} `json:"value"`

     

       596
       596
       +
       		CID   string                 `json:"cid"`

     

       557
       597
        
       	}

     

       558
       558
       -
       	json.NewDecoder(pdsResp.Body).Decode(&pdsRecord)

     

       598
       598
       +
       	if decodeErr := json.NewDecoder(pdsResp.Body).Decode(&pdsRecord); decodeErr != nil {

     

       599
       599
       +
       		t.Fatalf("Failed to decode PDS record: %v", decodeErr)

     

       600
       600
       +
       	}

     

       559
       601
        
       

     

       560
       602
        
       	// Simulate firehose event

     

       561
       603
        
       	event := jetstream.JetstreamEvent{

     
···

       572
       614
        
       		},

     

       573
       615
        
       	}

     

       574
       616
        
       

     

       575
       575
       -
       	consumer.HandleEvent(context.Background(), &event)

     

       617
       617
       +
       	if handleErr := consumer.HandleEvent(context.Background(), &event); handleErr != nil {

     

       618
       618
       +
       		t.Logf("Warning: failed to handle event: %v", handleErr)

     

       619
       619
       +
       	}

     

       576
       620
        
       

     

       577
       621
        
       	return community

     

       578
       622
        
       }

     
···

       594
       638
        
       		"password":   password,

     

       595
       639
        
       	}

     

       596
       640
        
       

     

       597
       597
       -
       	reqBody, _ := json.Marshal(sessionReq)

     

       641
       641
       +
       	reqBody, marshalErr := json.Marshal(sessionReq)

     

       642
       642
       +
       	if marshalErr != nil {

     

       643
       643
       +
       		return "", "", fmt.Errorf("failed to marshal session request: %w", marshalErr)

     

       644
       644
       +
       	}

     

       598
       645
        
       	resp, err := http.Post(

     

       599
       646
        
       		pdsURL+"/xrpc/com.atproto.server.createSession",

     

       600
       647
        
       		"application/json",

     
···

       603
       650
        
       	if err != nil {

     

       604
       651
        
       		return "", "", fmt.Errorf("failed to create session: %w", err)

     

       605
       652
        
       	}

     

       606
       606
       -
       	defer resp.Body.Close()

     

       653
       653
       +
       	defer func() { _ = resp.Body.Close() }()

     

       607
       654
        
       

     

       608
       655
        
       	if resp.StatusCode != http.StatusOK {

     

       609
       609
       -
       		body, _ := io.ReadAll(resp.Body)

     

       656
       656
       +
       		body, readErr := io.ReadAll(resp.Body)

     

       657
       657
       +
       		if readErr != nil {

     

       658
       658
       +
       			return "", "", fmt.Errorf("PDS auth failed (status %d, failed to read body: %w)", resp.StatusCode, readErr)

     

       659
       659
       +
       		}

     

       610
       660
        
       		return "", "", fmt.Errorf("PDS auth failed (status %d): %s", resp.StatusCode, string(body))

     

       611
       661
        
       	}

     

       612
       662
        
       

     
···

       665
       715
        
       	if err != nil {

     

       666
       716
        
       		return "", "", fmt.Errorf("failed to query PDS: %w", err)

     

       667
       717
        
       	}

     

       668
       668
       -
       	defer resp.Body.Close()

     

       718
       718
       +
       	defer func() { _ = resp.Body.Close() }()

     

       669
       719
        
       

     

       670
       720
        
       	if resp.StatusCode != http.StatusOK {

     

       671
       671
       -
       		body, _ := io.ReadAll(resp.Body)

     

       721
       721
       +
       		body, readErr := io.ReadAll(resp.Body)

     

       722
       722
       +
       		if readErr != nil {

     

       723
       723
       +
       			return "", "", fmt.Errorf("account not found (status %d, failed to read body: %w)", resp.StatusCode, readErr)

     

       724
       724
       +
       		}

     

       672
       725
        
       		return "", "", fmt.Errorf("account not found (status %d): %s", resp.StatusCode, string(body))

     

       673
       726
        
       	}

     

       674
       727
        
       

     
···

       700
       753
        
       	if err != nil {

     

       701
       754
        
       		return fmt.Errorf("failed to connect to Jetstream: %w", err)

     

       702
       755
        
       	}

     

       703
       703
       -
       	defer conn.Close()

     

       756
       756
       +
       	defer func() { _ = conn.Close() }()

     

       704
       757
        
       

     

       705
       758
        
       	// Read messages until we find our event or receive done signal

     

       706
       759
        
       	for {

     
···

       711
       764
        
       			return ctx.Err()

     

       712
       765
        
       		default:

     

       713
       766
        
       			// Set read deadline to avoid blocking forever

     

       714
       714
       -
       			conn.SetReadDeadline(time.Now().Add(5 * time.Second))

     

       767
       767
       +
       			if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil {

     

       768
       768
       +
       				return fmt.Errorf("failed to set read deadline: %w", err)

     

       769
       769
       +
       			}

     

       715
       770
        
       

     

       716
       771
        
       			var event jetstream.JetstreamEvent

     

       717
       772
        
       			err := conn.ReadJSON(&event)

+88 -43

tests/integration/community_repo_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/did"

     

       5
       5
       +
       	"Coves/internal/core/communities"

     

       6
       6
       +
       	"Coves/internal/db/postgres"

     

       4
       7
        
       	"context"

     

       5
       8
        
       	"fmt"

     

       6
       9
        
       	"testing"

     

       7
       10
        
       	"time"

     

       8
       8
       -
       

     

       9
       9
       -
       	"Coves/internal/atproto/did"

     

       10
       10
       -
       	"Coves/internal/core/communities"

     

       11
       11
       -
       	"Coves/internal/db/postgres"

     

       12
       11
        
       )

     

       13
       12
        
       

     

       14
       13
        
       func TestCommunityRepository_Create(t *testing.T) {

     

       15
       14
        
       	db := setupTestDB(t)

     

       16
       16
       -
       	defer db.Close()

     

       15
       15
       +
       	defer func() {

     

       16
       16
       +
       		if err := db.Close(); err != nil {

     

       17
       17
       +
       			t.Logf("Failed to close database: %v", err)

     

       18
       18
       +
       		}

     

       19
       19
       +
       	}()

     

       17
       20
        
       

     

       18
       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       19
       22
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       20
       23
        
       	ctx := context.Background()

     

       21
       24
        
       

     

       22
       25
        
       	t.Run("creates community successfully", func(t *testing.T) {

     

       23
       23
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       26
       26
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       27
       27
       +
       		if err != nil {

     

       28
       28
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       29
       29
       +
       		}

     

       24
       30
        
       		// Generate unique handle using timestamp to avoid collisions

     

       25
       31
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       26
       32
        
       		community := &communities.Community{

     
···

       52
       58
        
       	})

     

       53
       59
        
       

     

       54
       60
        
       	t.Run("returns error for duplicate DID", func(t *testing.T) {

     

       55
       55
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       61
       61
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       62
       62
       +
       		if err != nil {

     

       63
       63
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       64
       64
       +
       		}

     

       56
       65
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       57
       66
        
       		community := &communities.Community{

     

       58
       67
        
       			DID:          communityDID,

     
···

       67
       76
        
       		}

     

       68
       77
        
       

     

       69
       78
        
       		// Create first time

     

       70
       70
       -
       		_, err := repo.Create(ctx, community)

     

       71
       71
       -
       		if err != nil {

     

       79
       79
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       72
       80
        
       			t.Fatalf("First create failed: %v", err)

     

       73
       81
        
       		}

     

       74
       82
        
       

     

       75
       83
        
       		// Try to create again with same DID

     

       76
       76
       -
       		_, err = repo.Create(ctx, community)

     

       77
       77
       -
       		if err != communities.ErrCommunityAlreadyExists {

     

       84
       84
       +
       		if _, err = repo.Create(ctx, community); err != communities.ErrCommunityAlreadyExists {

     

       78
       85
        
       			t.Errorf("Expected ErrCommunityAlreadyExists, got: %v", err)

     

       79
       86
        
       		}

     

       80
       87
        
       	})

     
···

       84
       91
        
       		handle := fmt.Sprintf("!unique-handle-%s@coves.local", uniqueSuffix)

     

       85
       92
        
       

     

       86
       93
        
       		// First community

     

       87
       87
       -
       		did1, _ := didGen.GenerateCommunityDID()

     

       94
       94
       +
       		did1, err := didGen.GenerateCommunityDID()

     

       95
       95
       +
       		if err != nil {

     

       96
       96
       +
       			t.Fatalf("Failed to generate first community DID: %v", err)

     

       97
       97
       +
       		}

     

       88
       98
        
       		community1 := &communities.Community{

     

       89
       99
        
       			DID:          did1,

     

       90
       100
        
       			Handle:       handle,

     
···

       97
       107
        
       			UpdatedAt:    time.Now(),

     

       98
       108
        
       		}

     

       99
       109
        
       

     

       100
       100
       -
       		_, err := repo.Create(ctx, community1)

     

       101
       101
       -
       		if err != nil {

     

       110
       110
       +
       		if _, err := repo.Create(ctx, community1); err != nil {

     

       102
       111
        
       			t.Fatalf("First create failed: %v", err)

     

       103
       112
        
       		}

     

       104
       113
        
       

     

       105
       114
        
       		// Second community with different DID but same handle

     

       106
       106
       -
       		did2, _ := didGen.GenerateCommunityDID()

     

       115
       115
       +
       		did2, err := didGen.GenerateCommunityDID()

     

       116
       116
       +
       		if err != nil {

     

       117
       117
       +
       			t.Fatalf("Failed to generate second community DID: %v", err)

     

       118
       118
       +
       		}

     

       107
       119
        
       		community2 := &communities.Community{

     

       108
       120
        
       			DID:          did2,

     

       109
       121
        
       			Handle:       handle, // Same handle!

     
···

       116
       128
        
       			UpdatedAt:    time.Now(),

     

       117
       129
        
       		}

     

       118
       130
        
       

     

       119
       119
       -
       		_, err = repo.Create(ctx, community2)

     

       120
       120
       -
       		if err != communities.ErrHandleTaken {

     

       131
       131
       +
       		if _, err = repo.Create(ctx, community2); err != communities.ErrHandleTaken {

     

       121
       132
        
       			t.Errorf("Expected ErrHandleTaken, got: %v", err)

     

       122
       133
        
       		}

     

       123
       134
        
       	})

     
···

       125
       136
        
       

     

       126
       137
        
       func TestCommunityRepository_GetByDID(t *testing.T) {

     

       127
       138
        
       	db := setupTestDB(t)

     

       128
       128
       -
       	defer db.Close()

     

       139
       139
       +
       	defer func() {

     

       140
       140
       +
       		if err := db.Close(); err != nil {

     

       141
       141
       +
       			t.Logf("Failed to close database: %v", err)

     

       142
       142
       +
       		}

     

       143
       143
       +
       	}()

     

       129
       144
        
       

     

       130
       145
        
       	repo := postgres.NewCommunityRepository(db)

     

       131
       146
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       132
       147
        
       	ctx := context.Background()

     

       133
       148
        
       

     

       134
       149
        
       	t.Run("retrieves existing community", func(t *testing.T) {

     

       135
       135
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       150
       150
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       151
       151
       +
       		if err != nil {

     

       152
       152
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       153
       153
       +
       		}

     

       136
       154
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       137
       155
        
       		community := &communities.Community{

     

       138
       156
        
       			DID:          communityDID,

     
···

       170
       188
        
       	})

     

       171
       189
        
       

     

       172
       190
        
       	t.Run("returns error for non-existent community", func(t *testing.T) {

     

       173
       173
       -
       		fakeDID, _ := didGen.GenerateCommunityDID()

     

       174
       174
       -
       		_, err := repo.GetByDID(ctx, fakeDID)

     

       175
       175
       -
       		if err != communities.ErrCommunityNotFound {

     

       191
       191
       +
       		fakeDID, err := didGen.GenerateCommunityDID()

     

       192
       192
       +
       		if err != nil {

     

       193
       193
       +
       			t.Fatalf("Failed to generate fake DID: %v", err)

     

       194
       194
       +
       		}

     

       195
       195
       +
       		if _, err := repo.GetByDID(ctx, fakeDID); err != communities.ErrCommunityNotFound {

     

       176
       196
        
       			t.Errorf("Expected ErrCommunityNotFound, got: %v", err)

     

       177
       197
        
       		}

     

       178
       198
        
       	})

     
···

       180
       200
        
       

     

       181
       201
        
       func TestCommunityRepository_GetByHandle(t *testing.T) {

     

       182
       202
        
       	db := setupTestDB(t)

     

       183
       183
       -
       	defer db.Close()

     

       203
       203
       +
       	defer func() {

     

       204
       204
       +
       		if err := db.Close(); err != nil {

     

       205
       205
       +
       			t.Logf("Failed to close database: %v", err)

     

       206
       206
       +
       		}

     

       207
       207
       +
       	}()

     

       184
       208
        
       

     

       185
       209
        
       	repo := postgres.NewCommunityRepository(db)

     

       186
       210
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       187
       211
        
       	ctx := context.Background()

     

       188
       212
        
       

     

       189
       213
        
       	t.Run("retrieves community by handle", func(t *testing.T) {

     

       190
       190
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       214
       214
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       215
       215
       +
       		if err != nil {

     

       216
       216
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       217
       217
       +
       		}

     

       191
       218
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       192
       219
        
       		handle := fmt.Sprintf("!handle-lookup-%s@coves.local", uniqueSuffix)

     

       193
       220
        
       

     
···

       203
       230
        
       			UpdatedAt:    time.Now(),

     

       204
       231
        
       		}

     

       205
       232
        
       

     

       206
       206
       -
       		_, err := repo.Create(ctx, community)

     

       207
       207
       -
       		if err != nil {

     

       233
       233
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       208
       234
        
       			t.Fatalf("Failed to create community: %v", err)

     

       209
       235
        
       		}

     

       210
       236
        
       

     
···

       224
       250
        
       

     

       225
       251
        
       func TestCommunityRepository_Subscriptions(t *testing.T) {

     

       226
       252
        
       	db := setupTestDB(t)

     

       227
       227
       -
       	defer db.Close()

     

       253
       253
       +
       	defer func() {

     

       254
       254
       +
       		if err := db.Close(); err != nil {

     

       255
       255
       +
       			t.Logf("Failed to close database: %v", err)

     

       256
       256
       +
       		}

     

       257
       257
       +
       	}()

     

       228
       258
        
       

     

       229
       259
        
       	repo := postgres.NewCommunityRepository(db)

     

       230
       260
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       231
       261
        
       	ctx := context.Background()

     

       232
       262
        
       

     

       233
       263
        
       	// Create a community for subscription tests

     

       234
       234
       -
       	communityDID, _ := didGen.GenerateCommunityDID()

     

       264
       264
       +
       	communityDID, err := didGen.GenerateCommunityDID()

     

       265
       265
       +
       	if err != nil {

     

       266
       266
       +
       		t.Fatalf("Failed to generate community DID: %v", err)

     

       267
       267
       +
       	}

     

       235
       268
        
       	uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       236
       269
        
       	community := &communities.Community{

     

       237
       270
        
       		DID:          communityDID,

     
···

       245
       278
        
       		UpdatedAt:    time.Now(),

     

       246
       279
        
       	}

     

       247
       280
        
       

     

       248
       248
       -
       	_, err := repo.Create(ctx, community)

     

       249
       249
       -
       	if err != nil {

     

       281
       281
       +
       	if _, err := repo.Create(ctx, community); err != nil {

     

       250
       282
        
       		t.Fatalf("Failed to create community: %v", err)

     

       251
       283
        
       	}

     

       252
       284
        
       

     
···

       274
       306
        
       			SubscribedAt: time.Now(),

     

       275
       307
        
       		}

     

       276
       308
        
       

     

       277
       277
       -
       		_, err := repo.Subscribe(ctx, sub)

     

       278
       278
       -
       		if err != nil {

     

       309
       309
       +
       		if _, err := repo.Subscribe(ctx, sub); err != nil {

     

       279
       310
        
       			t.Fatalf("First subscription failed: %v", err)

     

       280
       311
        
       		}

     

       281
       312
        
       

     
···

       314
       345
        
       

     

       315
       346
        
       func TestCommunityRepository_List(t *testing.T) {

     

       316
       347
        
       	db := setupTestDB(t)

     

       317
       317
       -
       	defer db.Close()

     

       348
       348
       +
       	defer func() {

     

       349
       349
       +
       		if err := db.Close(); err != nil {

     

       350
       350
       +
       			t.Logf("Failed to close database: %v", err)

     

       351
       351
       +
       		}

     

       352
       352
       +
       	}()

     

       318
       353
        
       

     

       319
       354
        
       	repo := postgres.NewCommunityRepository(db)

     

       320
       355
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     
···

       324
       359
        
       		// Create multiple communities

     

       325
       360
        
       		baseSuffix := time.Now().UnixNano()

     

       326
       361
        
       		for i := 0; i < 5; i++ {

     

       327
       327
       -
       			communityDID, _ := didGen.GenerateCommunityDID()

     

       362
       362
       +
       			communityDID, err := didGen.GenerateCommunityDID()

     

       363
       363
       +
       			if err != nil {

     

       364
       364
       +
       				t.Fatalf("Failed to generate community DID: %v", err)

     

       365
       365
       +
       			}

     

       328
       366
        
       			community := &communities.Community{

     

       329
       367
        
       				DID:          communityDID,

     

       330
       368
        
       				Handle:       fmt.Sprintf("!list-test-%d-%d@coves.local", baseSuffix, i),

     
···

       336
       374
        
       				CreatedAt:    time.Now(),

     

       337
       375
        
       				UpdatedAt:    time.Now(),

     

       338
       376
        
       			}

     

       339
       339
       -
       			_, err := repo.Create(ctx, community)

     

       340
       340
       -
       			if err != nil {

     

       377
       377
       +
       			if _, err := repo.Create(ctx, community); err != nil {

     

       341
       378
        
       				t.Fatalf("Failed to create community %d: %v", i, err)

     

       342
       379
        
       			}

     

       343
       380
        
       			time.Sleep(10 * time.Millisecond) // Ensure different timestamps

     
···

       365
       402
        
       

     

       366
       403
        
       	t.Run("filters by visibility", func(t *testing.T) {

     

       367
       404
        
       		// Create an unlisted community

     

       368
       368
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       405
       405
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       406
       406
       +
       		if err != nil {

     

       407
       407
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       408
       408
       +
       		}

     

       369
       409
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       370
       410
        
       		community := &communities.Community{

     

       371
       411
        
       			DID:          communityDID,

     
···

       379
       419
        
       			UpdatedAt:    time.Now(),

     

       380
       420
        
       		}

     

       381
       421
        
       

     

       382
       382
       -
       		_, err := repo.Create(ctx, community)

     

       383
       383
       -
       		if err != nil {

     

       422
       422
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       384
       423
        
       			t.Fatalf("Failed to create unlisted community: %v", err)

     

       385
       424
        
       		}

     

       386
       425
        
       

     
···

       407
       446
        
       

     

       408
       447
        
       func TestCommunityRepository_Search(t *testing.T) {

     

       409
       448
        
       	db := setupTestDB(t)

     

       410
       410
       -
       	defer db.Close()

     

       449
       449
       +
       	defer func() {

     

       450
       450
       +
       		if err := db.Close(); err != nil {

     

       451
       451
       +
       			t.Logf("Failed to close database: %v", err)

     

       452
       452
       +
       		}

     

       453
       453
       +
       	}()

     

       411
       454
        
       

     

       412
       455
        
       	repo := postgres.NewCommunityRepository(db)

     

       413
       456
        
       	didGen := did.NewGenerator(true, "https://plc.directory")

     
···

       415
       458
        
       

     

       416
       459
        
       	t.Run("searches communities by name", func(t *testing.T) {

     

       417
       460
        
       		// Create a community with searchable name

     

       418
       418
       -
       		communityDID, _ := didGen.GenerateCommunityDID()

     

       461
       461
       +
       		communityDID, err := didGen.GenerateCommunityDID()

     

       462
       462
       +
       		if err != nil {

     

       463
       463
       +
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       464
       464
       +
       		}

     

       419
       465
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       420
       466
        
       		community := &communities.Community{

     

       421
       467
        
       			DID:          communityDID,

     
···

       431
       477
        
       			UpdatedAt:    time.Now(),

     

       432
       478
        
       		}

     

       433
       479
        
       

     

       434
       434
       -
       		_, err := repo.Create(ctx, community)

     

       435
       435
       -
       		if err != nil {

     

       480
       480
       +
       		if _, err := repo.Create(ctx, community); err != nil {

     

       436
       481
        
       			t.Fatalf("Failed to create community: %v", err)

     

       437
       482
        
       		}

     

       438
       483

+13 -6

tests/integration/community_v2_validation_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/jetstream"

     

       5
       5
       +
       	"Coves/internal/core/communities"

     

       6
       6
       +
       	"Coves/internal/db/postgres"

     

       4
       7
        
       	"context"

     

       5
       8
        
       	"testing"

     

       6
       9
        
       	"time"

     

       7
       7
       -
       

     

       8
       8
       -
       	"Coves/internal/atproto/jetstream"

     

       9
       9
       -
       	"Coves/internal/core/communities"

     

       10
       10
       -
       	"Coves/internal/db/postgres"

     

       11
       10
        
       )

     

       12
       11
        
       

     

       13
       12
        
       // TestCommunityConsumer_V2RKeyValidation tests that only V2 communities (rkey="self") are accepted

     

       14
       13
        
       func TestCommunityConsumer_V2RKeyValidation(t *testing.T) {

     

       15
       14
        
       	db := setupTestDB(t)

     

       16
       16
       -
       	defer db.Close()

     

       15
       15
       +
       	defer func() {

     

       16
       16
       +
       		if err := db.Close(); err != nil {

     

       17
       17
       +
       			t.Logf("Failed to close database: %v", err)

     

       18
       18
       +
       		}

     

       19
       19
       +
       	}()

     

       17
       20
        
       

     

       18
       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       19
       22
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     
···

       231
       234
        
       // TestCommunityConsumer_HandleField tests the V2 handle field

     

       232
       235
        
       func TestCommunityConsumer_HandleField(t *testing.T) {

     

       233
       236
        
       	db := setupTestDB(t)

     

       234
       234
       -
       	defer db.Close()

     

       237
       237
       +
       	defer func() {

     

       238
       238
       +
       		if err := db.Close(); err != nil {

     

       239
       239
       +
       			t.Logf("Failed to close database: %v", err)

     

       240
       240
       +
       		}

     

       241
       241
       +
       	}()

     

       235
       242
        
       

     

       236
       243
        
       	repo := postgres.NewCommunityRepository(db)

     

       237
       244
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

+36 -11

tests/integration/identity_resolution_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/identity"

     

       4
       5
        
       	"context"

     

       5
       6
        
       	"fmt"

     

       6
       7
        
       	"os"

     

       7
       8
        
       	"testing"

     

       8
       9
        
       	"time"

     

       9
       9
       -
       

     

       10
       10
       -
       	"Coves/internal/atproto/identity"

     

       11
       10
        
       )

     

       12
       11
        
       

     

       13
       12
        
       // uniqueID generates a unique identifier for test isolation

     
···

       18
       17
        
       // TestIdentityCache tests the PostgreSQL identity cache operations

     

       19
       18
        
       func TestIdentityCache(t *testing.T) {

     

       20
       19
        
       	db := setupTestDB(t)

     

       21
       21
       -
       	defer db.Close()

     

       20
       20
       +
       	defer func() {

     

       21
       21
       +
       		if err := db.Close(); err != nil {

     

       22
       22
       +
       			t.Logf("Failed to close database: %v", err)

     

       23
       23
       +
       		}

     

       24
       24
       +
       	}()

     

       22
       25
        
       

     

       23
       26
        
       	cache := identity.NewPostgresCache(db, 5*time.Minute)

     

       24
       27
        
       	ctx := context.Background()

     
···

       174
       177
        
       		}

     

       175
       178
        
       

     

       176
       179
        
       		// Cleanup

     

       177
       177
       -
       		cache.Delete(ctx, "alice.test")

     

       180
       180
       +
       		if delErr := cache.Delete(ctx, "alice.test"); delErr != nil {

     

       181
       181
       +
       			t.Logf("Failed to delete cache entry: %v", delErr)

     

       182
       182
       +
       		}

     

       178
       183
        
       	})

     

       179
       184
        
       

     

       180
       185
        
       	t.Run("DID is Case Sensitive", func(t *testing.T) {

     
···

       201
       206
        
       		}

     

       202
       207
        
       

     

       203
       208
        
       		// Cleanup

     

       204
       204
       -
       		cache.Delete(ctx, "did:plc:CaseSensitive")

     

       209
       209
       +
       		if delErr := cache.Delete(ctx, "did:plc:CaseSensitive"); delErr != nil {

     

       210
       210
       +
       			t.Logf("Failed to delete cache entry: %v", delErr)

     

       211
       211
       +
       		}

     

       205
       212
        
       	})

     

       206
       213
        
       }

     

       207
       214
        
       

     

       208
       215
        
       // TestIdentityCacheTTL tests that expired cache entries are not returned

     

       209
       216
        
       func TestIdentityCacheTTL(t *testing.T) {

     

       210
       217
        
       	db := setupTestDB(t)

     

       211
       211
       -
       	defer db.Close()

     

       218
       218
       +
       	defer func() {

     

       219
       219
       +
       		if err := db.Close(); err != nil {

     

       220
       220
       +
       			t.Logf("Failed to close database: %v", err)

     

       221
       221
       +
       		}

     

       222
       222
       +
       	}()

     

       212
       223
        
       

     

       213
       224
        
       	// Create cache with very short TTL (reduced from 1s to 100ms for faster, less flaky tests)

     

       214
       225
        
       	ttl := 100 * time.Millisecond

     
···

       250
       261
        
       // TestIdentityResolverWithCache tests the caching resolver behavior

     

       251
       262
        
       func TestIdentityResolverWithCache(t *testing.T) {

     

       252
       263
        
       	db := setupTestDB(t)

     

       253
       253
       -
       	defer db.Close()

     

       264
       264
       +
       	defer func() {

     

       265
       265
       +
       		if err := db.Close(); err != nil {

     

       266
       266
       +
       			t.Logf("Failed to close database: %v", err)

     

       267
       267
       +
       		}

     

       268
       268
       +
       	}()

     

       254
       269
        
       

     

       255
       270
        
       	cache := identity.NewPostgresCache(db, 5*time.Minute)

     

       256
       271
        
       

     

       257
       272
        
       	// Clean slate

     

       258
       258
       -
       	_, _ = db.Exec("TRUNCATE identity_cache")

     

       273
       273
       +
       	if _, err := db.Exec("TRUNCATE identity_cache"); err != nil {

     

       274
       274
       +
       		t.Logf("Warning: failed to truncate identity_cache: %v", err)

     

       275
       275
       +
       	}

     

       259
       276
        
       

     

       260
       277
        
       	// Create resolver with caching

     

       261
       278
        
       	resolver := identity.NewResolver(db, identity.Config{

     
···

       348
       365
        
       	}

     

       349
       366
        
       

     

       350
       367
        
       	db := setupTestDB(t)

     

       351
       351
       -
       	defer db.Close()

     

       368
       368
       +
       	defer func() {

     

       369
       369
       +
       		if err := db.Close(); err != nil {

     

       370
       370
       +
       			t.Logf("Failed to close database: %v", err)

     

       371
       371
       +
       		}

     

       372
       372
       +
       	}()

     

       352
       373
        
       

     

       353
       374
        
       	resolver := identity.NewResolver(db, identity.Config{

     

       354
       375
        
       		PLCURL:   "https://plc.directory",

     
···

       360
       381
        
       	testCases := []struct {

     

       361
       382
        
       		name           string

     

       362
       383
        
       		handle         string

     

       363
       363
       -
       		expectError    bool

     

       364
       384
        
       		expectedMethod identity.ResolutionMethod

     

       385
       385
       +
       		expectError    bool

     

       365
       386
        
       	}{

     

       366
       387
        
       		{

     

       367
       388
        
       			name:           "Resolve bsky.app (well-known handle)",

     
···

       432
       453
        
       	}

     

       433
       454
        
       

     

       434
       455
        
       	db := setupTestDB(t)

     

       435
       435
       -
       	defer db.Close()

     

       456
       456
       +
       	defer func() {

     

       457
       457
       +
       		if err := db.Close(); err != nil {

     

       458
       458
       +
       			t.Logf("Failed to close database: %v", err)

     

       459
       459
       +
       		}

     

       460
       460
       +
       	}()

     

       436
       461
        
       

     

       437
       462
        
       	resolver := identity.NewResolver(db, identity.Config{

     

       438
       463
        
       		PLCURL:   "https://plc.directory",

+13 -6

tests/integration/jetstream_consumer_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"testing"

     

       6
       6
       -
       	"time"

     

       7
       7
       -
       

     

       8
       4
        
       	"Coves/internal/atproto/identity"

     

       9
       5
        
       	"Coves/internal/atproto/jetstream"

     

       10
       6
        
       	"Coves/internal/core/users"

     

       11
       7
        
       	"Coves/internal/db/postgres"

     

       8
       8
       +
       	"context"

     

       9
       9
       +
       	"testing"

     

       10
       10
       +
       	"time"

     

       12
       11
        
       )

     

       13
       12
        
       

     

       14
       13
        
       func TestUserIndexingFromJetstream(t *testing.T) {

     

       15
       14
        
       	db := setupTestDB(t)

     

       16
       16
       -
       	defer db.Close()

     

       15
       15
       +
       	defer func() {

     

       16
       16
       +
       		if err := db.Close(); err != nil {

     

       17
       17
       +
       			t.Logf("Failed to close database: %v", err)

     

       18
       18
       +
       		}

     

       19
       19
       +
       	}()

     

       17
       20
        
       

     

       18
       21
        
       	// Wire up dependencies

     

       19
       22
        
       	userRepo := postgres.NewUserRepository(db)

     
···

       297
       300
        
       

     

       298
       301
        
       func TestUserServiceIdempotency(t *testing.T) {

     

       299
       302
        
       	db := setupTestDB(t)

     

       300
       300
       -
       	defer db.Close()

     

       303
       303
       +
       	defer func() {

     

       304
       304
       +
       		if err := db.Close(); err != nil {

     

       305
       305
       +
       			t.Logf("Failed to close database: %v", err)

     

       306
       306
       +
       		}

     

       307
       307
       +
       	}()

     

       301
       308
        
       

     

       302
       309
        
       	userRepo := postgres.NewUserRepository(db)

     

       303
       310
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

+74 -32

tests/integration/oauth_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/api/handlers/oauth"

     

       5
       5
       +
       	"Coves/internal/atproto/identity"

     

       4
       6
        
       	"bytes"

     

       5
       7
        
       	"context"

     

       6
       8
        
       	"encoding/json"

     
···

       9
       11
        
       	"os"

     

       10
       12
        
       	"testing"

     

       11
       13
        
       

     

       12
       12
       -
       	"Coves/internal/api/handlers/oauth"

     

       13
       13
       -
       	"Coves/internal/atproto/identity"

     

       14
       14
        
       	oauthCore "Coves/internal/core/oauth"

     

       15
       15
        
       

     

       16
       16
        
       	"github.com/lestrrat-go/jwx/v2/jwk"

     
···

       19
       19
        
       // TestOAuthClientMetadata tests the /oauth/client-metadata.json endpoint

     

       20
       20
        
       func TestOAuthClientMetadata(t *testing.T) {

     

       21
       21
        
       	tests := []struct {

     

       22
       22
       -
       		name              string

     

       23
       23
       -
       		appviewURL        string

     

       24
       24
       -
       		expectedClientID  string

     

       25
       25
       -
       		expectedJWKSURI   string

     

       26
       26
       -
       		expectedRedirect  string

     

       22
       22
       +
       		name             string

     

       23
       23
       +
       		appviewURL       string

     

       24
       24
       +
       		expectedClientID string

     

       25
       25
       +
       		expectedJWKSURI  string

     

       26
       26
       +
       		expectedRedirect string

     

       27
       27
        
       	}{

     

       28
       28
        
       		{

     

       29
       29
       -
       			name:              "localhost development",

     

       30
       30
       -
       			appviewURL:        "http://localhost:8081",

     

       31
       31
       -
       			expectedClientID:  "http://localhost?redirect_uri=http://localhost:8081/oauth/callback&scope=atproto%20transition:generic",

     

       32
       32
       -
       			expectedJWKSURI:   "", // No JWKS URI for localhost

     

       33
       33
       -
       			expectedRedirect:  "http://localhost:8081/oauth/callback",

     

       29
       29
       +
       			name:             "localhost development",

     

       30
       30
       +
       			appviewURL:       "http://localhost:8081",

     

       31
       31
       +
       			expectedClientID: "http://localhost?redirect_uri=http://localhost:8081/oauth/callback&scope=atproto%20transition:generic",

     

       32
       32
       +
       			expectedJWKSURI:  "", // No JWKS URI for localhost

     

       33
       33
       +
       			expectedRedirect: "http://localhost:8081/oauth/callback",

     

       34
       34
        
       		},

     

       35
       35
        
       		{

     

       36
       36
       -
       			name:              "production HTTPS",

     

       37
       37
       -
       			appviewURL:        "https://coves.social",

     

       38
       38
       -
       			expectedClientID:  "https://coves.social/oauth/client-metadata.json",

     

       39
       39
       -
       			expectedJWKSURI:   "https://coves.social/oauth/jwks.json",

     

       40
       40
       -
       			expectedRedirect:  "https://coves.social/oauth/callback",

     

       36
       36
       +
       			name:             "production HTTPS",

     

       37
       37
       +
       			appviewURL:       "https://coves.social",

     

       38
       38
       +
       			expectedClientID: "https://coves.social/oauth/client-metadata.json",

     

       39
       39
       +
       			expectedJWKSURI:  "https://coves.social/oauth/jwks.json",

     

       40
       40
       +
       			expectedRedirect: "https://coves.social/oauth/callback",

     

       41
       41
        
       		},

     

       42
       42
        
       	}

     

       43
       43
        
       

     

       44
       44
        
       	for _, tt := range tests {

     

       45
       45
        
       		t.Run(tt.name, func(t *testing.T) {

     

       46
       46
        
       			// Set environment

     

       47
       47
       -
       			os.Setenv("APPVIEW_PUBLIC_URL", tt.appviewURL)

     

       48
       48
       -
       			defer os.Unsetenv("APPVIEW_PUBLIC_URL")

     

       47
       47
       +
       			if err := os.Setenv("APPVIEW_PUBLIC_URL", tt.appviewURL); err != nil {

     

       48
       48
       +
       				t.Fatalf("Failed to set APPVIEW_PUBLIC_URL: %v", err)

     

       49
       49
       +
       			}

     

       50
       50
       +
       			defer func() {

     

       51
       51
       +
       				if err := os.Unsetenv("APPVIEW_PUBLIC_URL"); err != nil {

     

       52
       52
       +
       					t.Logf("Failed to unset APPVIEW_PUBLIC_URL: %v", err)

     

       53
       53
       +
       				}

     

       54
       54
       +
       			}()

     

       49
       55
        
       

     

       50
       56
        
       			// Create request

     

       51
       57
        
       			req := httptest.NewRequest("GET", "/oauth/client-metadata.json", nil)

     
···

       123
       129
        
       		t.Run(tt.name, func(t *testing.T) {

     

       124
       130
        
       			// Set environment

     

       125
       131
        
       			if tt.envValue != "" {

     

       126
       126
       -
       				os.Setenv("OAUTH_PRIVATE_JWK", tt.envValue)

     

       127
       127
       -
       				defer os.Unsetenv("OAUTH_PRIVATE_JWK")

     

       132
       132
       +
       				if err := os.Setenv("OAUTH_PRIVATE_JWK", tt.envValue); err != nil {

     

       133
       133
       +
       					t.Fatalf("Failed to set OAUTH_PRIVATE_JWK: %v", err)

     

       134
       134
       +
       				}

     

       135
       135
       +
       				defer func() {

     

       136
       136
       +
       					if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       137
       137
       +
       						t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       138
       138
       +
       					}

     

       139
       139
       +
       				}()

     

       128
       140
        
       			}

     

       129
       141
        
       

     

       130
       142
        
       			// Create request

     
···

       187
       199
        
       

     

       188
       200
        
       	// Setup test database

     

       189
       201
        
       	db := setupTestDB(t)

     

       190
       190
       -
       	defer db.Close()

     

       202
       202
       +
       	defer func() {

     

       203
       203
       +
       		if err := db.Close(); err != nil {

     

       204
       204
       +
       			t.Logf("Failed to close database: %v", err)

     

       205
       205
       +
       		}

     

       206
       206
       +
       	}()

     

       191
       207
        
       

     

       192
       208
        
       	// Create session store

     

       193
       209
        
       	sessionStore := oauthCore.NewPostgresSessionStore(db)

     
···

       231
       247
        
       		t.Run(tt.name, func(t *testing.T) {

     

       232
       248
        
       			// Set environment

     

       233
       249
        
       			if tt.envJWK != "" {

     

       234
       234
       -
       				os.Setenv("OAUTH_PRIVATE_JWK", tt.envJWK)

     

       235
       235
       -
       				defer os.Unsetenv("OAUTH_PRIVATE_JWK")

     

       250
       250
       +
       				if err := os.Setenv("OAUTH_PRIVATE_JWK", tt.envJWK); err != nil {

     

       251
       251
       +
       					t.Fatalf("Failed to set OAUTH_PRIVATE_JWK: %v", err)

     

       252
       252
       +
       				}

     

       253
       253
       +
       				defer func() {

     

       254
       254
       +
       					if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       255
       255
       +
       						t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       256
       256
       +
       					}

     

       257
       257
       +
       				}()

     

       236
       258
        
       			} else {

     

       237
       237
       -
       				os.Unsetenv("OAUTH_PRIVATE_JWK")

     

       259
       259
       +
       				if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       260
       260
       +
       					t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       261
       261
       +
       				}

     

       238
       262
        
       			}

     

       239
       263
        
       

     

       240
       264
        
       			// Create mock identity resolver for validation tests

     
···

       244
       268
        
       			handler := oauth.NewLoginHandler(mockResolver, sessionStore)

     

       245
       269
        
       

     

       246
       270
        
       			// Create request

     

       247
       247
       -
       			bodyBytes, _ := json.Marshal(tt.requestBody)

     

       271
       271
       +
       			bodyBytes, marshalErr := json.Marshal(tt.requestBody)

     

       272
       272
       +
       			if marshalErr != nil {

     

       273
       273
       +
       				t.Fatalf("Failed to marshal request body: %v", marshalErr)

     

       274
       274
       +
       			}

     

       248
       275
        
       			req := httptest.NewRequest("POST", "/oauth/login", bytes.NewReader(bodyBytes))

     

       249
       276
        
       			req.Header.Set("Content-Type", "application/json")

     

       250
       277
        
       			w := httptest.NewRecorder()

     
···

       269
       296
        
       

     

       270
       297
        
       	// Setup test database

     

       271
       298
        
       	db := setupTestDB(t)

     

       272
       272
       -
       	defer db.Close()

     

       299
       299
       +
       	defer func() {

     

       300
       300
       +
       		if err := db.Close(); err != nil {

     

       301
       301
       +
       			t.Logf("Failed to close database: %v", err)

     

       302
       302
       +
       		}

     

       303
       303
       +
       	}()

     

       273
       304
        
       

     

       274
       305
        
       	// Create session store

     

       275
       306
        
       	sessionStore := oauthCore.NewPostgresSessionStore(db)

     
···

       277
       308
        
       	testJWK := `{"alg":"ES256","crv":"P-256","d":"9tCMceYSgyZfO5KYOCm3rWEhXLqq2l4LjP7-PJtJKyk","kid":"oauth-client-key","kty":"EC","use":"sig","x":"EOYWEgZ2d-smTO6jh0f-9B7YSFYdlrvlryjuXTCrOjE","y":"_FR2jBcWNxoJl5cd1eq9sYtAs33No9AVtd42UyyWYi4"}`

     

       278
       309
        
       

     

       279
       310
        
       	tests := []struct {

     

       280
       280
       -
       		name           string

     

       281
       311
        
       		queryParams    map[string]string

     

       312
       312
       +
       		name           string

     

       282
       313
        
       		expectedStatus int

     

       283
       314
        
       	}{

     

       284
       315
        
       		{

     
···

       318
       349
        
       	for _, tt := range tests {

     

       319
       350
        
       		t.Run(tt.name, func(t *testing.T) {

     

       320
       351
        
       			// Set environment

     

       321
       321
       -
       			os.Setenv("OAUTH_PRIVATE_JWK", testJWK)

     

       322
       322
       -
       			defer os.Unsetenv("OAUTH_PRIVATE_JWK")

     

       352
       352
       +
       			if err := os.Setenv("OAUTH_PRIVATE_JWK", testJWK); err != nil {

     

       353
       353
       +
       				t.Fatalf("Failed to set OAUTH_PRIVATE_JWK: %v", err)

     

       354
       354
       +
       			}

     

       355
       355
       +
       			defer func() {

     

       356
       356
       +
       				if err := os.Unsetenv("OAUTH_PRIVATE_JWK"); err != nil {

     

       357
       357
       +
       					t.Logf("Failed to unset OAUTH_PRIVATE_JWK: %v", err)

     

       358
       358
       +
       				}

     

       359
       359
       +
       			}()

     

       323
       360
        
       

     

       324
       361
        
       			// Create handler

     

       325
       362
        
       			handler := oauth.NewCallbackHandler(sessionStore)

     
···

       400
       437
        
       	}

     

       401
       438
        
       

     

       402
       439
        
       	// Verify public key doesn't have private component

     

       403
       403
       -
       	pubKeyJSON, _ := json.Marshal(pubKey)

     

       440
       440
       +
       	pubKeyJSON, marshalErr := json.Marshal(pubKey)

     

       441
       441
       +
       	if marshalErr != nil {

     

       442
       442
       +
       		t.Fatalf("failed to marshal public key: %v", marshalErr)

     

       443
       443
       +
       	}

     

       404
       444
        
       	var pubKeyMap map[string]interface{}

     

       405
       405
       -
       	json.Unmarshal(pubKeyJSON, &pubKeyMap)

     

       445
       445
       +
       	if unmarshalErr := json.Unmarshal(pubKeyJSON, &pubKeyMap); unmarshalErr != nil {

     

       446
       446
       +
       		t.Fatalf("failed to unmarshal public key: %v", unmarshalErr)

     

       447
       447
       +
       	}

     

       406
       448
        
       

     

       407
       449
        
       	if _, hasPrivate := pubKeyMap["d"]; hasPrivate {

     

       408
       450
        
       		t.Error("SECURITY: public key should not contain private 'd' component!")

+31 -17

tests/integration/user_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/api/routes"

     

       5
       5
       +
       	"Coves/internal/atproto/identity"

     

       6
       6
       +
       	"Coves/internal/core/users"

     

       7
       7
       +
       	"Coves/internal/db/postgres"

     

       4
       8
        
       	"context"

     

       5
       9
        
       	"database/sql"

     

       6
       10
        
       	"encoding/json"

     
···

       14
       18
        
       	"github.com/go-chi/chi/v5"

     

       15
       19
        
       	_ "github.com/lib/pq"

     

       16
       20
        
       	"github.com/pressly/goose/v3"

     

       17
       17
       -
       

     

       18
       18
       -
       	"Coves/internal/api/routes"

     

       19
       19
       -
       	"Coves/internal/atproto/identity"

     

       20
       20
       -
       	"Coves/internal/core/users"

     

       21
       21
       -
       	"Coves/internal/db/postgres"

     

       22
       21
        
       )

     

       23
       22
        
       

     

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

     
···

       50
       49
        
       		t.Fatalf("Failed to connect to test database: %v", err)

     

       51
       50
        
       	}

     

       52
       51
        
       

     

       53
       53
       -
       	if err := db.Ping(); err != nil {

     

       54
       54
       -
       		t.Fatalf("Failed to ping test database: %v", err)

     

       52
       52
       +
       	if pingErr := db.Ping(); pingErr != nil {

     

       53
       53
       +
       		t.Fatalf("Failed to ping test database: %v", pingErr)

     

       55
       54
        
       	}

     

       56
       55
        
       

     

       57
       57
       -
       	if err := goose.SetDialect("postgres"); err != nil {

     

       58
       58
       -
       		t.Fatalf("Failed to set goose dialect: %v", err)

     

       56
       56
       +
       	if dialectErr := goose.SetDialect("postgres"); dialectErr != nil {

     

       57
       57
       +
       		t.Fatalf("Failed to set goose dialect: %v", dialectErr)

     

       59
       58
        
       	}

     

       60
       59
        
       

     

       61
       61
       -
       	if err := goose.Up(db, "../../internal/db/migrations"); err != nil {

     

       62
       62
       -
       		t.Fatalf("Failed to run migrations: %v", err)

     

       60
       60
       +
       	if migrateErr := goose.Up(db, "../../internal/db/migrations"); migrateErr != nil {

     

       61
       61
       +
       		t.Fatalf("Failed to run migrations: %v", migrateErr)

     

       63
       62
        
       	}

     

       64
       63
        
       

     

       65
       64
        
       	// Clean up any existing test data

     
···

       73
       72
        
       

     

       74
       73
        
       func TestUserCreationAndRetrieval(t *testing.T) {

     

       75
       74
        
       	db := setupTestDB(t)

     

       76
       76
       -
       	defer db.Close()

     

       75
       75
       +
       	defer func() {

     

       76
       76
       +
       		if err := db.Close(); err != nil {

     

       77
       77
       +
       			t.Logf("Failed to close database: %v", err)

     

       78
       78
       +
       		}

     

       79
       79
       +
       	}()

     

       77
       80
        
       

     

       78
       81
        
       	// Wire up dependencies

     

       79
       82
        
       	userRepo := postgres.NewUserRepository(db)

     
···

       150
       153
        
       

     

       151
       154
        
       func TestGetProfileEndpoint(t *testing.T) {

     

       152
       155
        
       	db := setupTestDB(t)

     

       153
       153
       -
       	defer db.Close()

     

       156
       156
       +
       	defer func() {

     

       157
       157
       +
       		if err := db.Close(); err != nil {

     

       158
       158
       +
       			t.Logf("Failed to close database: %v", err)

     

       159
       159
       +
       		}

     

       160
       160
       +
       	}()

     

       154
       161
        
       

     

       155
       162
        
       	// Wire up dependencies

     

       156
       163
        
       	userRepo := postgres.NewUserRepository(db)

     
···

       241
       248
        
       // TestDuplicateCreation tests that duplicate DID/handle creation fails properly

     

       242
       249
        
       func TestDuplicateCreation(t *testing.T) {

     

       243
       250
        
       	db := setupTestDB(t)

     

       244
       244
       -
       	defer db.Close()

     

       251
       251
       +
       	defer func() {

     

       252
       252
       +
       		if err := db.Close(); err != nil {

     

       253
       253
       +
       			t.Logf("Failed to close database: %v", err)

     

       254
       254
       +
       		}

     

       255
       255
       +
       	}()

     

       245
       256
        
       

     

       246
       257
        
       	userRepo := postgres.NewUserRepository(db)

     

       247
       258
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     
···

       265
       276
        
       			Handle: "different.test", // Different handle, same DID

     

       266
       277
        
       			PDSURL: "http://localhost:3001",

     

       267
       278
        
       		})

     

       268
       268
       -
       

     

       269
       279
        
       		// Should return existing user, not error

     

       270
       280
        
       		if err != nil {

     

       271
       281
        
       			t.Fatalf("Expected idempotent behavior, got error: %v", err)

     
···

       298
       308
        
       // TestHandleValidation tests atProto handle validation rules

     

       299
       309
        
       func TestHandleValidation(t *testing.T) {

     

       300
       310
        
       	db := setupTestDB(t)

     

       301
       301
       -
       	defer db.Close()

     

       311
       311
       +
       	defer func() {

     

       312
       312
       +
       		if err := db.Close(); err != nil {

     

       313
       313
       +
       			t.Logf("Failed to close database: %v", err)

     

       314
       314
       +
       		}

     

       315
       315
       +
       	}()

     

       302
       316
        
       

     

       303
       317
        
       	userRepo := postgres.NewUserRepository(db)

     

       304
       318
        
       	resolver := identity.NewResolver(db, identity.DefaultConfig())

     
···

       310
       324
        
       		did         string

     

       311
       325
        
       		handle      string

     

       312
       326
        
       		pdsURL      string

     

       313
       313
       -
       		shouldError bool

     

       314
       327
        
       		errorMsg    string

     

       328
       328
       +
       		shouldError bool

     

       315
       329
        
       	}{

     

       316
       330
        
       		{

     

       317
       331
        
       			name:        "Valid handle with hyphen",

+29 -23

tests/lexicon_validation_test.go

···

       40
       40
        
       	for _, filePath := range lexiconFiles {

     

       41
       41
        
       		// Convert file path to schema ID

     

       42
       42
        
       		// e.g., ../internal/atproto/lexicon/social/coves/actor/profile.json -> social.coves.actor.profile

     

       43
       43
       -
       		relPath, _ := filepath.Rel(schemaPath, filePath)

     

       43
       43
       +
       		relPath, err := filepath.Rel(schemaPath, filePath)

     

       44
       44
       +
       		if err != nil {

     

       45
       45
       +
       			t.Fatalf("Failed to get relative path for %s: %v", filePath, err)

     

       46
       46
       +
       		}

     

       44
       47
        
       		relPath = strings.TrimSuffix(relPath, ".json")

     

       45
       48
        
       		schemaID := strings.ReplaceAll(relPath, string(filepath.Separator), ".")

     

       46
       49
        
       

     

       47
       50
        
       		t.Run(schemaID, func(t *testing.T) {

     

       48
       48
       -
       			if _, err := catalog.Resolve(schemaID); err != nil {

     

       49
       49
       -
       				t.Errorf("Failed to resolve schema %s: %v", schemaID, err)

     

       51
       51
       +
       			if _, resolveErr := catalog.Resolve(schemaID); resolveErr != nil {

     

       52
       52
       +
       				t.Errorf("Failed to resolve schema %s: %v", schemaID, resolveErr)

     

       50
       53
        
       			}

     

       51
       54
        
       		})

     

       52
       55
        
       	}

     
···

       63
       66
        
       

     

       64
       67
        
       	// Test specific cross-references that should work

     

       65
       68
        
       	crossRefs := map[string]string{

     

       66
       66
       -
       		"social.coves.richtext.facet#byteSlice": "byteSlice definition in facet schema",

     

       69
       69
       +
       		"social.coves.richtext.facet#byteSlice":  "byteSlice definition in facet schema",

     

       67
       70
        
       		"social.coves.actor.profile#geoLocation": "geoLocation definition in actor profile",

     

       68
       71
        
       		"social.coves.community.rules#rule":      "rule definition in community rules",

     

       69
       72
        
       	}

     
···

       88
       91
        
       

     

       89
       92
        
       	// Test cases for ValidateRecord

     

       90
       93
        
       	tests := []struct {

     

       91
       91
       -
       		name        string

     

       92
       92
       -
       		recordType  string

     

       93
       93
       -
       		recordData  map[string]interface{}

     

       94
       94
       -
       		shouldFail  bool

     

       94
       94
       +
       		recordData    map[string]interface{}

     

       95
       95
       +
       		name          string

     

       96
       96
       +
       		recordType    string

     

       95
       97
        
       		errorContains string

     

       98
       98
       +
       		shouldFail    bool

     

       96
       99
        
       	}{

     

       97
       100
        
       		{

     

       98
       101
        
       			name:       "Valid actor profile",

     
···

       120
       123
        
       			recordType: "social.coves.community.profile",

     

       121
       124
        
       			recordData: map[string]interface{}{

     

       122
       125
        
       				"$type":          "social.coves.community.profile",

     

       126
       126
       +
       				"handle":         "programming.communities.coves.social",

     

       123
       127
        
       				"name":           "programming",

     

       124
       128
        
       				"displayName":    "Programming Community",

     

       125
       125
       -
       				"creator":        "did:plc:creator123",

     

       129
       129
       +
       				"createdBy":      "did:plc:creator123",

     

       130
       130
       +
       				"hostedBy":       "did:plc:coves123",

     

       131
       131
       +
       				"visibility":     "public",

     

       126
       132
        
       				"moderationType": "moderator",

     

       127
       133
        
       				"federatedFrom":  "coves",

     

       128
       134
        
       				"createdAt":      "2023-12-01T08:00:00Z",

     
···

       133
       139
        
       			name:       "Valid post record",

     

       134
       140
        
       			recordType: "social.coves.post.record",

     

       135
       141
        
       			recordData: map[string]interface{}{

     

       136
       136
       -
       				"$type":           "social.coves.post.record",

     

       137
       137
       -
       				"community":       "did:plc:programming123",

     

       138
       138
       -
       				"postType":        "text",

     

       139
       139
       -
       				"title":           "Test Post",

     

       140
       140
       -
       				"content":         "This is a test post",

     

       141
       141
       -
       				"createdAt":       "2025-01-09T14:30:00Z",

     

       142
       142
       +
       				"$type":     "social.coves.post.record",

     

       143
       143
       +
       				"community": "did:plc:programming123",

     

       144
       144
       +
       				"postType":  "text",

     

       145
       145
       +
       				"title":     "Test Post",

     

       146
       146
       +
       				"content":   "This is a test post",

     

       147
       147
       +
       				"createdAt": "2025-01-09T14:30:00Z",

     

       142
       148
        
       			},

     

       143
       149
        
       			shouldFail: false,

     

       144
       150
        
       		},

     
···

       146
       152
        
       			name:       "Invalid post record - invalid enum value",

     

       147
       153
        
       			recordType: "social.coves.post.record",

     

       148
       154
        
       			recordData: map[string]interface{}{

     

       149
       149
       -
       				"$type":           "social.coves.post.record",

     

       150
       150
       -
       				"community":       "did:plc:programming123",

     

       151
       151
       -
       				"postType":        "invalid-type",

     

       152
       152
       -
       				"title":           "Test Post",

     

       153
       153
       -
       				"content":         "This is a test post",

     

       154
       154
       -
       				"createdAt":       "2025-01-09T14:30:00Z",

     

       155
       155
       +
       				"$type":     "social.coves.post.record",

     

       156
       156
       +
       				"community": "did:plc:programming123",

     

       157
       157
       +
       				"postType":  "invalid-type",

     

       158
       158
       +
       				"title":     "Test Post",

     

       159
       159
       +
       				"content":   "This is a test post",

     

       160
       160
       +
       				"createdAt": "2025-01-09T14:30:00Z",

     

       155
       161
        
       			},

     

       156
       162
        
       			shouldFail:    true,

     

       157
       163
        
       			errorContains: "string val not in required enum",

     
···

       161
       167
        
       	for _, tt := range tests {

     

       162
       168
        
       		t.Run(tt.name, func(t *testing.T) {

     

       163
       169
        
       			err := lexicon.ValidateRecord(&catalog, tt.recordData, tt.recordType, lexicon.AllowLenientDatetime)

     

       164
       164
       -
       			

     

       170
       170
       +
       

     

       165
       171
        
       			if tt.shouldFail {

     

       166
       172
        
       				if err == nil {

     

       167
       173
        
       					t.Errorf("Expected validation to fail but it passed")

     
···

       209
       215
        
       	if err != nil {

     

       210
       216
        
       		t.Errorf("Expected lenient validation to pass, got error: %v", err)

     

       211
       217
        
       	}

     

       212
       212
       -
       }
     

       218
       218
       +
       }

+8 -5

tests/unit/community_service_test.go

···

       1
       1
        
       package unit

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/did"

     

       5
       5
       +
       	"Coves/internal/core/communities"

     

       4
       6
        
       	"context"

     

       5
       7
        
       	"fmt"

     

       6
       8
        
       	"net/http"

     
···

       9
       11
        
       	"sync/atomic"

     

       10
       12
        
       	"testing"

     

       11
       13
        
       	"time"

     

       12
       12
       -
       

     

       13
       13
       -
       	"Coves/internal/atproto/did"

     

       14
       14
       -
       	"Coves/internal/core/communities"

     

       15
       14
        
       )

     

       16
       15
        
       

     

       17
       16
        
       // mockCommunityRepo is a minimal mock for testing service layer

     
···

       157
       156
        
       			time.Sleep(15 * time.Second)

     

       158
       157
        
       

     

       159
       158
        
       			w.WriteHeader(http.StatusOK)

     

       160
       160
       -
       			w.Write([]byte(`{"uri":"at://did:plc:test/collection/self","cid":"bafyrei123"}`))

     

       159
       159
       +
       			if _, err := w.Write([]byte(`{"uri":"at://did:plc:test/collection/self","cid":"bafyrei123"}`)); err != nil {

     

       160
       160
       +
       				t.Errorf("Failed to write response: %v", err)

     

       161
       161
       +
       			}

     

       161
       162
        
       		}))

     

       162
       163
        
       		defer slowPDS.Close()

     

       163
       164
        
       

     
···

       205
       206
        
       			}

     

       206
       207
        
       

     

       207
       208
        
       			w.WriteHeader(http.StatusOK)

     

       208
       208
       -
       			w.Write([]byte(`{"uri":"at://did:plc:community/social.coves.community.profile/self","cid":"bafyrei456"}`))

     

       209
       209
       +
       			if _, err := w.Write([]byte(`{"uri":"at://did:plc:community/social.coves.community.profile/self","cid":"bafyrei456"}`)); err != nil {

     

       210
       210
       +
       				t.Errorf("Failed to write response: %v", err)

     

       211
       211
       +
       			}

     

       209
       212
        
       		}))

     

       210
       213
        
       		defer mockPDS.Close()

     

       211
       214