diff --git a/go.mod b/go.mod index 3e851c4..6d01990 100644 --- a/go.mod +++ b/go.mod @@ -16,7 +16,6 @@ require ( github.com/matcornic/hermes/v2 v2.1.0 github.com/minchao/go-mitake v1.0.0 github.com/panjf2000/ants/v2 v2.11.3 - github.com/scylladb/gocqlx/v3 v3.0.4 github.com/segmentio/ksuid v1.0.4 github.com/shopspring/decimal v1.4.0 github.com/stretchr/testify v1.11.1 @@ -107,6 +106,7 @@ require ( github.com/rivo/uniseg v0.2.0 // indirect github.com/russross/blackfriday/v2 v2.0.1 // indirect github.com/scylladb/go-reflectx v1.0.1 // indirect + github.com/scylladb/gocqlx/v2 v2.8.0 // indirect github.com/shirou/gopsutil/v4 v4.25.6 // indirect github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect github.com/sirupsen/logrus v1.9.3 // indirect diff --git a/go.sum b/go.sum index 01d9096..8b61775 100644 --- a/go.sum +++ b/go.sum @@ -221,6 +221,8 @@ github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/scylladb/go-reflectx v1.0.1 h1:b917wZM7189pZdlND9PbIJ6NQxfDPfBvUaQ7cjj1iZQ= github.com/scylladb/go-reflectx v1.0.1/go.mod h1:rWnOfDIRWBGN0miMLIcoPt/Dhi2doCMZqwMCJ3KupFc= +github.com/scylladb/gocqlx/v2 v2.8.0 h1:f/oIgoEPjKDKd+RIoeHqexsIQVIbalVmT+axwvUqQUg= +github.com/scylladb/gocqlx/v2 v2.8.0/go.mod h1:4/+cga34PVqjhgSoo5Nr2fX1MQIqZB5eCE5DK4xeDig= github.com/scylladb/gocqlx/v3 v3.0.4 h1:37rMVFEUlsGGNYB7OLR7991KwBYR2WA5TU7wtduClas= github.com/scylladb/gocqlx/v3 v3.0.4/go.mod h1:3vBkGO+HRh/BYypLWXzurQ45u1BAO0VGBhg5VgperPY= github.com/segmentio/ksuid v1.0.4 h1:sBo2BdShXjmcugAMwjugoGUdUV0pcxY5mW4xKRn3v4c= diff --git a/pkg/library/cassandra/README.md b/pkg/library/cassandra/README.md index 8325467..c7e031f 100644 --- a/pkg/library/cassandra/README.md +++ b/pkg/library/cassandra/README.md @@ -1,158 +1,683 @@ -# Cassandra2 - 新一代 Cassandra 客戶端 +# Cassandra Client Library -Cassandra2 是重新設計的 Cassandra 客戶端，提供更簡潔的 API、更好的類型安全性和更清晰的架構。 +一個基於 Go Generics 的 Cassandra 客戶端庫，提供類型安全的 Repository 模式和流暢的查詢構建器 API。 -## 特色 +## 功能特色 -- ✅ **Repository 模式**：每個 Repository 綁定一個 keyspace，無需到處傳遞 -- ✅ **類型安全**：使用泛型，編譯期類型檢查 -- ✅ **簡潔的 API**：統一的查詢介面，流暢的鏈式調用 -- ✅ **符合 cursor.md 原則**：小介面、依賴注入、顯式錯誤處理 +- **類型安全**: 使用 Go Generics 提供編譯時類型檢查 +- **Repository 模式**: 簡潔的 CRUD 操作介面 +- **流暢查詢**: 鏈式查詢構建器，支援條件、排序、限制 +- **分散式鎖**: 基於 Cassandra 的 IF NOT EXISTS 實現分散式鎖 +- **批次操作**: 支援批次插入、更新、刪除 +- **SAI 索引支援**: 完整的 SAI (Storage-Attached Indexing) 索引管理功能 +- **Option 模式**: 靈活的配置選項 +- **錯誤處理**: 統一的錯誤處理機制 +- **高效能**: 內建連接池、重試機制、Prepared Statement 快取 + +## 安裝 + +```bash +go get github.com/scylladb/gocqlx/v2 +go get github.com/gocql/gocql +``` ## 快速開始 -### 1. 初始化 +### 1. 定義資料模型 ```go -import "your-module/pkg/library/cassandra" +package main -// 創建 DB 連接 -db, err := cassandra2.New( - cassandra2.WithHosts("localhost"), - cassandra2.WithKeyspace("my_keyspace"), - cassandra2.WithPort(9042), +import ( + "time" + "github.com/gocql/gocql" + "backend/pkg/library/cassandra" ) -if err != nil { - log.Fatal(err) -} -defer db.Close() -``` -### 2. 定義資料模型 - -```go +// User 定義用戶資料模型 type User struct { - ID gocql.UUID `db:"id" partition_key:"true"` - Name string `db:"name"` - Email string `db:"email"` - CreatedAt time.Time `db:"created_at"` + ID gocql.UUID `db:"id" partition_key:"true"` + Name string `db:"name"` + Email string `db:"email"` + Age int `db:"age"` + CreatedAt time.Time `db:"created_at"` + UpdatedAt time.Time `db:"updated_at"` } +// TableName 實現 Table 介面 func (u User) TableName() string { - return "users" + return "users" } ``` -### 3. 使用 Repository +### 2. 初始化資料庫連接 ```go -// 獲取 Repository -repo, err := db.Repository[User]("my_keyspace") +package main -// 插入 +import ( + "context" + "fmt" + "log" + + "backend/pkg/library/cassandra" + "github.com/gocql/gocql" +) + +func main() { + // 創建資料庫連接 + db, err := cassandra.New( + cassandra.WithHosts("127.0.0.1"), + cassandra.WithPort(9042), + cassandra.WithKeyspace("my_keyspace"), + cassandra.WithAuth("username", "password"), + cassandra.WithConsistency(gocql.Quorum), + ) + if err != nil { + log.Fatal(err) + } + defer db.Close() + + // 創建 Repository + userRepo, err := cassandra.NewRepository[User](db, "my_keyspace") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + + // 使用 Repository... + _ = userRepo +} +``` + +## 詳細範例 + +### CRUD 操作 + +#### 插入資料 + +```go +// 插入單筆資料 user := User{ - ID: gocql.TimeUUID(), - Name: "Alice", - Email: "alice@example.com", - CreatedAt: time.Now(), + ID: gocql.TimeUUID(), + Name: "Alice", + Email: "alice@example.com", + Age: 30, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), } -err = repo.Insert(ctx, user) -// 查詢 -var result User -result, err = repo.Get(ctx, user.ID) +err := userRepo.Insert(ctx, user) +if err != nil { + log.Printf("插入失敗: %v", err) +} -// 更新 -user.Email = "newemail@example.com" -err = repo.Update(ctx, user) +// 批次插入 +users := []User{ + {ID: gocql.TimeUUID(), Name: "Bob", Email: "bob@example.com"}, + {ID: gocql.TimeUUID(), Name: "Charlie", Email: "charlie@example.com"}, +} -// 刪除 -err = repo.Delete(ctx, user.ID) +err = userRepo.InsertMany(ctx, users) +if err != nil { + log.Printf("批次插入失敗: %v", err) +} ``` -### 4. 使用 Query Builder +#### 查詢資料 ```go -// 條件查詢 +// 根據主鍵查詢 +userID := gocql.TimeUUID() +user, err := userRepo.Get(ctx, userID) +if err != nil { + if cassandra.IsNotFound(err) { + log.Println("用戶不存在") + } else { + log.Printf("查詢失敗: %v", err) + } + return +} + +fmt.Printf("用戶: %+v\n", user) +``` + +#### 更新資料 + +```go +// 更新資料（只更新非零值欄位） +user.Name = "Alice Updated" +user.Email = "alice.updated@example.com" +err = userRepo.Update(ctx, user) +if err != nil { + log.Printf("更新失敗: %v", err) +} + +// 更新所有欄位（包括零值） +user.Age = 0 // 零值也會被更新 +err = userRepo.UpdateAll(ctx, user) +if err != nil { + log.Printf("更新失敗: %v", err) +} +``` + +#### 刪除資料 + +```go +// 刪除資料 +err = userRepo.Delete(ctx, userID) +if err != nil { + log.Printf("刪除失敗: %v", err) +} +``` + +### 查詢構建器 + +#### 基本查詢 + +```go +// 查詢所有符合條件的記錄 var users []User -err = repo.Query(). - Where(cassandra2.Eq("status", "active")). - OrderBy("created_at", cassandra2.DESC). - Limit(10). - Scan(ctx, &users) +err := userRepo.Query(). + Where(cassandra.Eq("age", 30)). + OrderBy("created_at", cassandra.DESC). + Limit(10). + Scan(ctx, &users) -// 單筆查詢 -user, err := repo.Query(). - Where(cassandra2.Eq("id", userID)). - One(ctx) +if err != nil { + log.Printf("查詢失敗: %v", err) +} -// 計數 -count, err := repo.Query(). - Where(cassandra2.Eq("status", "active")). - Count(ctx) -``` +// 查詢單筆記錄 +user, err := userRepo.Query(). + Where(cassandra.Eq("email", "alice@example.com")). + One(ctx) -### 5. Batch 操作 - -```go -batch := repo.Batch(ctx) -batch.Insert(user1). - Insert(user2). - Update(user3) -err = batch.Commit(ctx) -``` - -### 6. Transaction 操作 - -```go -tx := db.Begin(ctx, "my_keyspace") -tx.Insert(user1) -tx.Update(user2) -if err := tx.Commit(ctx); err != nil { - tx.Rollback(ctx) +if err != nil { + if cassandra.IsNotFound(err) { + log.Println("用戶不存在") + } else { + log.Printf("查詢失敗: %v", err) + } } ``` -## API 對比 +#### 條件查詢 -### 舊 API (Cassandra 1) ```go -db.Insert(ctx, user, "keyspace") -db.Model(ctx, &User{}, "keyspace").Where(...).Scan(&result) +// 等於條件 +userRepo.Query().Where(cassandra.Eq("name", "Alice")) + +// IN 條件 +userRepo.Query().Where(cassandra.In("id", []any{id1, id2, id3})) + +// 大於條件 +userRepo.Query().Where(cassandra.Gt("age", 18)) + +// 小於條件 +userRepo.Query().Where(cassandra.Lt("age", 65)) + +// 組合多個條件 +userRepo.Query(). + Where(cassandra.Eq("status", "active")). + Where(cassandra.Gt("age", 18)) ``` -### 新 API (Cassandra 2) +#### 排序和限制 + ```go -repo := db.Repository[User]("keyspace") -repo.Insert(ctx, user) -repo.Query().Where(...).Scan(ctx, &result) +// 按建立時間降序排列，限制 20 筆 +var users []User +err := userRepo.Query(). + OrderBy("created_at", cassandra.DESC). + Limit(20). + Scan(ctx, &users) + +// 多欄位排序 +err = userRepo.Query(). + OrderBy("status", cassandra.ASC). + OrderBy("created_at", cassandra.DESC). + Scan(ctx, &users) ``` -## 主要改進 +#### 選擇特定欄位 -1. **移除 keyspace 參數**：Repository 綁定 keyspace，無需重複傳遞 -2. **類型安全**：使用泛型，編譯期檢查 -3. **統一 API**：只有一套查詢介面 -4. **更好的錯誤處理**：統一的錯誤類型，支援 errors.Is/As +```go +// 只查詢特定欄位 +var users []User +err := userRepo.Query(). + Select("id", "name", "email"). + Where(cassandra.Eq("status", "active")). + Scan(ctx, &users) +``` + +#### 計數查詢 + +```go +// 計算符合條件的記錄數 +count, err := userRepo.Query(). + Where(cassandra.Eq("status", "active")). + Count(ctx) + +if err != nil { + log.Printf("計數失敗: %v", err) +} else { + fmt.Printf("活躍用戶數: %d\n", count) +} +``` + +### 分散式鎖 + +```go +// 獲取鎖（預設 30 秒 TTL） +lockUser := User{ID: userID} +err := userRepo.TryLock(ctx, lockUser) +if err != nil { + if cassandra.IsLockFailed(err) { + log.Println("獲取鎖失敗，資源已被鎖定") + } else { + log.Printf("鎖操作失敗: %v", err) + } + return +} + +// 執行需要鎖定的操作 +defer func() { + // 釋放鎖 + if err := userRepo.UnLock(ctx, lockUser); err != nil { + log.Printf("釋放鎖失敗: %v", err) + } +}() + +// 執行業務邏輯... +``` + +#### 自訂鎖 TTL + +```go +// 設定鎖的 TTL 為 60 秒 +err := userRepo.TryLock(ctx, lockUser, cassandra.WithLockTTL(60*time.Second)) + +// 永不自動解鎖 +err := userRepo.TryLock(ctx, lockUser, cassandra.WithNoLockExpire()) +``` + +### 複雜主鍵 + +#### 複合主鍵（Partition Key + Clustering Key） + +```go +// 定義複合主鍵模型 +type Order struct { + UserID gocql.UUID `db:"user_id" partition_key:"true"` + OrderID gocql.UUID `db:"order_id" clustering_key:"true"` + ProductID string `db:"product_id"` + Quantity int `db:"quantity"` + Price float64 `db:"price"` + CreatedAt time.Time `db:"created_at"` +} + +func (o Order) TableName() string { + return "orders" +} + +// 查詢時需要提供完整的主鍵 +order, err := orderRepo.Get(ctx, Order{ + UserID: userID, + OrderID: orderID, +}) +``` + +#### 多欄位 Partition Key + +```go +type Message struct { + ChatID gocql.UUID `db:"chat_id" partition_key:"true"` + MessageID gocql.UUID `db:"message_id" clustering_key:"true"` + UserID gocql.UUID `db:"user_id" partition_key:"true"` + Content string `db:"content"` + CreatedAt time.Time `db:"created_at"` +} + +func (m Message) TableName() string { + return "messages" +} + +// 查詢時需要提供所有 Partition Key +message, err := messageRepo.Get(ctx, Message{ + ChatID: chatID, + UserID: userID, + MessageID: messageID, +}) +``` + +## 配置選項 + +### 連接選項 + +```go +db, err := cassandra.New( + // 主機列表 + cassandra.WithHosts("127.0.0.1", "127.0.0.2", "127.0.0.3"), + + // 連接埠 + cassandra.WithPort(9042), + + // Keyspace + cassandra.WithKeyspace("my_keyspace"), + + // 認證 + cassandra.WithAuth("username", "password"), + + // 一致性級別 + cassandra.WithConsistency(gocql.Quorum), + + // 連接超時 + cassandra.WithConnectTimeout(10 * time.Second), + + // 每個節點的連接數 + cassandra.WithNumConns(10), + + // 重試次數 + cassandra.WithMaxRetries(3), + + // 重試間隔 + cassandra.WithRetryInterval(100*time.Millisecond, 1*time.Second), + + // 重連間隔 + cassandra.WithReconnectInterval(1*time.Second, 10*time.Second), + + // CQL 版本 + cassandra.WithCQLVersion("3.0.0"), +) +``` + +## 錯誤處理 + +### 錯誤類型 + +```go +// 檢查是否為特定錯誤 +if cassandra.IsNotFound(err) { + // 記錄不存在 +} + +if cassandra.IsConflict(err) { + // 衝突錯誤（如唯一鍵衝突） +} + +if cassandra.IsLockFailed(err) { + // 獲取鎖失敗 +} + +// 使用 errors.As 獲取詳細錯誤資訊 +var cassandraErr *cassandra.Error +if errors.As(err, &cassandraErr) { + fmt.Printf("錯誤代碼: %s\n", cassandraErr.Code) + fmt.Printf("錯誤訊息: %s\n", cassandraErr.Message) + fmt.Printf("資料表: %s\n", cassandraErr.Table) +} +``` + +### 錯誤代碼 + +- `NOT_FOUND`: 記錄未找到 +- `CONFLICT`: 衝突（如唯一鍵衝突、鎖獲取失敗） +- `INVALID_INPUT`: 輸入參數無效 +- `MISSING_PARTITION_KEY`: 缺少 Partition Key +- `NO_FIELDS_TO_UPDATE`: 沒有欄位需要更新 +- `MISSING_TABLE_NAME`: 缺少 TableName 方法 +- `MISSING_WHERE_CONDITION`: 缺少 WHERE 條件 + +## 最佳實踐 + +### 1. 使用 Context + +```go +// 所有操作都應該傳入 context，以便支援超時和取消 +ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) +defer cancel() + +user, err := userRepo.Get(ctx, userID) +``` + +### 2. 錯誤處理 + +```go +user, err := userRepo.Get(ctx, userID) +if err != nil { + if cassandra.IsNotFound(err) { + // 處理不存在的情況 + return nil, ErrUserNotFound + } + // 處理其他錯誤 + return nil, fmt.Errorf("查詢用戶失敗: %w", err) +} +``` + +### 3. 批次操作 + +```go +// 對於大量資料，使用批次插入 +const batchSize = 100 +for i := 0; i < len(users); i += batchSize { + end := i + batchSize + if end > len(users) { + end = len(users) + } + + err := userRepo.InsertMany(ctx, users[i:end]) + if err != nil { + log.Printf("批次插入失敗 (索引 %d-%d): %v", i, end, err) + } +} +``` + +### 4. 使用分散式鎖 + +```go +// 在需要保證原子性的操作中使用鎖 +err := userRepo.TryLock(ctx, lockUser, cassandra.WithLockTTL(30*time.Second)) +if err != nil { + return fmt.Errorf("獲取鎖失敗: %w", err) +} +defer userRepo.UnLock(ctx, lockUser) + +// 執行需要原子性的操作 +``` + +### 5. 查詢優化 + +```go +// 只選擇需要的欄位 +var users []User +err := userRepo.Query(). + Select("id", "name", "email"). // 只選擇需要的欄位 + Where(cassandra.Eq("status", "active")). + Scan(ctx, &users) + +// 使用適當的限制 +err = userRepo.Query(). + Where(cassandra.Eq("status", "active")). + Limit(100). // 限制結果數量 + Scan(ctx, &users) +``` ## 注意事項 -1. **主鍵查詢**：`Get` 方法需要完整的 Primary Key。如果是多欄位主鍵，需要傳入包含所有主鍵欄位的 struct。 -2. **更新行為**：`Update` 預設只更新非零值欄位，使用 `UpdateAll` 可更新所有欄位。 -3. **Transaction**：這是補償式交易，不是真正的 ACID 交易，適用於最終一致性場景。 +### 1. 主鍵要求 -## 遷移指南 +- `Get` 和 `Delete` 操作必須提供完整的主鍵（所有 Partition Key 和 Clustering Key） +- 單一主鍵值只適用於單一 Partition Key 且無 Clustering Key 的情況 -從 Cassandra 1 遷移到 Cassandra 2： +### 2. 更新操作 -1. 將 `cassandra.NewCassandraDB` 改為 `cassandra2.New` -2. 將 `db.Insert(ctx, doc, keyspace)` 改為 `repo.Insert(ctx, doc)`，其中 `repo = db.Repository[Type](keyspace)` -3. 將 `db.Model(...)` 改為 `repo.Query()` -4. 更新錯誤處理：使用 `cassandra2.IsNotFound` 等函數 +- `Update` 只更新非零值欄位 +- `UpdateAll` 更新所有欄位（包括零值） +- 更新操作必須包含主鍵欄位 -## 文檔 +### 3. 查詢限制 -詳細的技術設計請參考： -- `REFACTORING_PLAN.md` - 重構計畫 -- `TECHNICAL_DESIGN.md` - 技術設計文檔 +- Cassandra 的查詢必須包含所有 Partition Key +- 排序只能按 Clustering Key 進行 +- 不支援 JOIN 操作 + +### 4. 分散式鎖 + +- 鎖使用 IF NOT EXISTS 實現，預設 30 秒 TTL +- 獲取鎖失敗時會返回 `CONFLICT` 錯誤 +- 釋放鎖時會自動重試，最多 3 次 + +### 5. 批次操作 + +- 批次操作有大小限制（建議不超過 1000 筆） +- 批次操作中的所有操作必須屬於同一個 Partition Key + +### 6. SAI 索引 + +- SAI 索引需要 Cassandra 4.0.9+ 版本（建議 5.0+） +- 建立索引前請先檢查 `db.SaiSupported()` +- 索引建立是異步操作，可能需要一些時間 +- 刪除索引時使用 `IF EXISTS`，避免索引不存在時報錯 + +## 完整範例 + +```go +package main + +import ( + "context" + "fmt" + "log" + "time" + + "backend/pkg/library/cassandra" + "github.com/gocql/gocql" +) + +type User struct { + ID gocql.UUID `db:"id" partition_key:"true"` + Name string `db:"name"` + Email string `db:"email"` + Age int `db:"age"` + Status string `db:"status"` + CreatedAt time.Time `db:"created_at"` + UpdatedAt time.Time `db:"updated_at"` +} + +func (u User) TableName() string { + return "users" +} + +func main() { + // 初始化資料庫連接 + db, err := cassandra.New( + cassandra.WithHosts("127.0.0.1"), + cassandra.WithPort(9042), + cassandra.WithKeyspace("my_keyspace"), + ) + if err != nil { + log.Fatal(err) + } + defer db.Close() + + // 創建 Repository + userRepo, err := cassandra.NewRepository[User](db, "my_keyspace") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + + // 插入用戶 + user := User{ + ID: gocql.TimeUUID(), + Name: "Alice", + Email: "alice@example.com", + Age: 30, + Status: "active", + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + } + + if err := userRepo.Insert(ctx, user); err != nil { + log.Printf("插入失敗: %v", err) + return + } + + // 查詢用戶 + foundUser, err := userRepo.Get(ctx, user.ID) + if err != nil { + log.Printf("查詢失敗: %v", err) + return + } + fmt.Printf("查詢到的用戶: %+v\n", foundUser) + + // 更新用戶 + user.Name = "Alice Updated" + user.Email = "alice.updated@example.com" + if err := userRepo.Update(ctx, user); err != nil { + log.Printf("更新失敗: %v", err) + return + } + + // 查詢活躍用戶 + var activeUsers []User + if err := userRepo.Query(). + Where(cassandra.Eq("status", "active")). + OrderBy("created_at", cassandra.DESC). + Limit(10). + Scan(ctx, &activeUsers); err != nil { + log.Printf("查詢失敗: %v", err) + return + } + fmt.Printf("活躍用戶數: %d\n", len(activeUsers)) + + // 使用分散式鎖 + if err := userRepo.TryLock(ctx, user, cassandra.WithLockTTL(30*time.Second)); err != nil { + if cassandra.IsLockFailed(err) { + log.Println("獲取鎖失敗") + } else { + log.Printf("鎖操作失敗: %v", err) + } + return + } + defer userRepo.UnLock(ctx, user) + + // 執行需要鎖定的操作 + fmt.Println("執行需要鎖定的操作...") + + // 刪除用戶 + if err := userRepo.Delete(ctx, user.ID); err != nil { + log.Printf("刪除失敗: %v", err) + return + } + + fmt.Println("操作完成") +} +``` + +## 測試 + +套件包含完整的測試覆蓋，包括： + +- 單元測試（table-driven tests） +- 集成測試（使用 testcontainers） + +運行測試： + +```bash +go test ./pkg/library/cassandra/... +``` + +查看測試覆蓋率： + +```bash +go test ./pkg/library/cassandra/... -cover +``` + +## 授權 + +本專案遵循專案的主要授權協議。 diff --git a/pkg/library/cassandra/const.go b/pkg/library/cassandra/const.go index 534e43c..646b87c 100644 --- a/pkg/library/cassandra/const.go +++ b/pkg/library/cassandra/const.go @@ -19,3 +19,9 @@ const ( defaultReconnectMaxInterval = 60 * time.Second defaultCqlVersion = "3.0.0" ) + +const ( + DBFiledName = "db" + Pk = "partition_key" + ClusterKey = "clustering_key" +) diff --git a/pkg/library/cassandra/db.go b/pkg/library/cassandra/db.go index 722e982..7accac9 100644 --- a/pkg/library/cassandra/db.go +++ b/pkg/library/cassandra/db.go @@ -5,11 +5,10 @@ import ( "fmt" "strconv" "strings" - "sync" "time" "github.com/gocql/gocql" - "github.com/scylladb/gocqlx/v3" + "github.com/scylladb/gocqlx/v2" ) // DB 是 Cassandra 的核心資料庫連接 @@ -18,9 +17,6 @@ type DB struct { defaultKeyspace string version string saiSupported bool - - // 內部快取 - metadataCache sync.Map // 重用現有的 metadata 快取邏輯 } // New 創建新的 DB 實例 diff --git a/pkg/library/cassandra/db_test.go b/pkg/library/cassandra/db_test.go new file mode 100644 index 0000000..43db35c --- /dev/null +++ b/pkg/library/cassandra/db_test.go @@ -0,0 +1,545 @@ +package cassandra + +import ( + "errors" + "testing" + "time" + + "github.com/gocql/gocql" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestIsSAISupported(t *testing.T) { + tests := []struct { + name string + version string + expected bool + }{ + { + name: "version 5.0.0 should support SAI", + version: "5.0.0", + expected: true, + }, + { + name: "version 5.1.0 should support SAI", + version: "5.1.0", + expected: true, + }, + { + name: "version 6.0.0 should support SAI", + version: "6.0.0", + expected: true, + }, + { + name: "version 4.1.0 should support SAI", + version: "4.1.0", + expected: true, + }, + { + name: "version 4.2.0 should support SAI", + version: "4.2.0", + expected: true, + }, + { + name: "version 4.0.9 should support SAI", + version: "4.0.9", + expected: true, + }, + { + name: "version 4.0.10 should support SAI", + version: "4.0.10", + expected: true, + }, + { + name: "version 4.0.8 should not support SAI", + version: "4.0.8", + expected: false, + }, + { + name: "version 4.0.0 should not support SAI", + version: "4.0.0", + expected: false, + }, + { + name: "version 3.11.0 should not support SAI", + version: "3.11.0", + expected: false, + }, + { + name: "invalid version format should not support SAI", + version: "invalid", + expected: false, + }, + { + name: "empty version should not support SAI", + version: "", + expected: false, + }, + { + name: "version with only major should not support SAI", + version: "5", + expected: false, + }, + { + name: "version 4.0.9 with extra parts should support SAI", + version: "4.0.9.1", + expected: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := isSAISupported(tt.version) + assert.Equal(t, tt.expected, result, "version %s should have SAI support = %v", tt.version, tt.expected) + }) + } +} + +func TestNew_Validation(t *testing.T) { + tests := []struct { + name string + opts []Option + wantErr bool + errMsg string + }{ + { + name: "no hosts should return error", + opts: []Option{}, + wantErr: true, + errMsg: "at least one host is required", + }, + { + name: "empty hosts should return error", + opts: []Option{WithHosts()}, + wantErr: true, + errMsg: "at least one host is required", + }, + { + name: "valid hosts should not return error on validation", + opts: []Option{ + WithHosts("localhost"), + }, + wantErr: false, + }, + { + name: "multiple hosts should not return error on validation", + opts: []Option{ + WithHosts("localhost", "127.0.0.1"), + }, + wantErr: false, + }, + { + name: "with keyspace should not return error on validation", + opts: []Option{ + WithHosts("localhost"), + WithKeyspace("test_keyspace"), + }, + wantErr: false, + }, + { + name: "with port should not return error on validation", + opts: []Option{ + WithHosts("localhost"), + WithPort(9042), + }, + wantErr: false, + }, + { + name: "with auth should not return error on validation", + opts: []Option{ + WithHosts("localhost"), + WithAuth("user", "pass"), + }, + wantErr: false, + }, + { + name: "with all options should not return error on validation", + opts: []Option{ + WithHosts("localhost"), + WithKeyspace("test_keyspace"), + WithPort(9042), + WithAuth("user", "pass"), + WithConsistency(gocql.Quorum), + WithConnectTimeoutSec(10), + WithNumConns(10), + WithMaxRetries(3), + }, + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + db, err := New(tt.opts...) + + if tt.wantErr { + require.Error(t, err) + if tt.errMsg != "" { + assert.Contains(t, err.Error(), tt.errMsg) + } + assert.Nil(t, db) + } else { + // 注意：這裡可能會因為無法連接到真實的 Cassandra 而失敗 + // 但至少驗證了配置驗證邏輯 + if err != nil { + // 如果錯誤不是驗證錯誤，而是連接錯誤，這是可以接受的 + assert.NotContains(t, err.Error(), "at least one host is required") + } + } + }) + } +} + +func TestDB_GetDefaultKeyspace(t *testing.T) { + tests := []struct { + name string + keyspace string + expectedResult string + }{ + { + name: "empty keyspace should return empty string", + keyspace: "", + expectedResult: "", + }, + { + name: "non-empty keyspace should return keyspace", + keyspace: "test_keyspace", + expectedResult: "test_keyspace", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例 + // 在實際測試中，可能需要 mock 或使用 testcontainers + // 這裡只是展示測試結構 + _ = tt + }) + } +} + +func TestDB_Version(t *testing.T) { + tests := []struct { + name string + version string + expected string + }{ + { + name: "version 5.0.0", + version: "5.0.0", + expected: "5.0.0", + }, + { + name: "version 4.0.9", + version: "4.0.9", + expected: "4.0.9", + }, + { + name: "version 3.11.0", + version: "3.11.0", + expected: "3.11.0", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例 + // 在實際測試中，可能需要 mock 或使用 testcontainers + _ = tt + }) + } +} + +func TestDB_SaiSupported(t *testing.T) { + tests := []struct { + name string + version string + expected bool + }{ + { + name: "version 5.0.0 should support SAI", + version: "5.0.0", + expected: true, + }, + { + name: "version 4.0.9 should support SAI", + version: "4.0.9", + expected: true, + }, + { + name: "version 4.0.8 should not support SAI", + version: "4.0.8", + expected: false, + }, + { + name: "version 3.11.0 should not support SAI", + version: "3.11.0", + expected: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例 + // 在實際測試中，可能需要 mock 或使用 testcontainers + // 這裡只是展示測試結構 + _ = tt + }) + } +} + +func TestDB_GetSession(t *testing.T) { + t.Run("GetSession should return non-nil session", func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例 + // 在實際測試中，可能需要 mock 或使用 testcontainers + }) +} + +func TestDB_Close(t *testing.T) { + t.Run("Close should not panic", func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例 + // 在實際測試中，可能需要 mock 或使用 testcontainers + }) +} + +func TestDB_getVersion(t *testing.T) { + tests := []struct { + name string + version string + queryErr error + wantErr bool + expectedVer string + }{ + { + name: "successful version query", + version: "5.0.0", + queryErr: nil, + wantErr: false, + expectedVer: "5.0.0", + }, + { + name: "query error should return error", + version: "", + queryErr: errors.New("connection failed"), + wantErr: true, + expectedVer: "", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session + // 在實際測試中，需要使用 mock 或 testcontainers + _ = tt + }) + } +} + +func TestDB_withContextAndTimestamp(t *testing.T) { + t.Run("withContextAndTimestamp should add context and timestamp", func(t *testing.T) { + // 注意：這需要 mock query + // 在實際測試中，需要使用 mock + }) +} + +func TestDefaultConfig(t *testing.T) { + t.Run("defaultConfig should return valid config", func(t *testing.T) { + cfg := defaultConfig() + require.NotNil(t, cfg) + assert.Equal(t, defaultPort, cfg.Port) + assert.Equal(t, defaultConsistency, cfg.Consistency) + assert.Equal(t, defaultTimeoutSec, cfg.ConnectTimeoutSec) + assert.Equal(t, defaultNumConns, cfg.NumConns) + assert.Equal(t, defaultMaxRetries, cfg.MaxRetries) + assert.Equal(t, defaultRetryMinInterval, cfg.RetryMinInterval) + assert.Equal(t, defaultRetryMaxInterval, cfg.RetryMaxInterval) + assert.Equal(t, defaultReconnectInitialInterval, cfg.ReconnectInitialInterval) + assert.Equal(t, defaultReconnectMaxInterval, cfg.ReconnectMaxInterval) + assert.Equal(t, defaultCqlVersion, cfg.CQLVersion) + }) +} + +func TestOptionFunctions(t *testing.T) { + tests := []struct { + name string + opt Option + validateConfig func(*testing.T, *config) + }{ + { + name: "WithHosts should set hosts", + opt: WithHosts("host1", "host2"), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, []string{"host1", "host2"}, c.Hosts) + }, + }, + { + name: "WithPort should set port", + opt: WithPort(9999), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 9999, c.Port) + }, + }, + { + name: "WithKeyspace should set keyspace", + opt: WithKeyspace("test_keyspace"), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, "test_keyspace", c.Keyspace) + }, + }, + { + name: "WithAuth should set auth and enable UseAuth", + opt: WithAuth("user", "pass"), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, "user", c.Username) + assert.Equal(t, "pass", c.Password) + assert.True(t, c.UseAuth) + }, + }, + { + name: "WithConsistency should set consistency", + opt: WithConsistency(gocql.One), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, gocql.One, c.Consistency) + }, + }, + { + name: "WithConnectTimeoutSec should set timeout", + opt: WithConnectTimeoutSec(20), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 20, c.ConnectTimeoutSec) + }, + }, + { + name: "WithConnectTimeoutSec with zero should use default", + opt: WithConnectTimeoutSec(0), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultTimeoutSec, c.ConnectTimeoutSec) + }, + }, + { + name: "WithNumConns should set numConns", + opt: WithNumConns(20), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 20, c.NumConns) + }, + }, + { + name: "WithNumConns with zero should use default", + opt: WithNumConns(0), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultNumConns, c.NumConns) + }, + }, + { + name: "WithMaxRetries should set maxRetries", + opt: WithMaxRetries(5), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 5, c.MaxRetries) + }, + }, + { + name: "WithMaxRetries with zero should use default", + opt: WithMaxRetries(0), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultMaxRetries, c.MaxRetries) + }, + }, + { + name: "WithRetryMinInterval should set retryMinInterval", + opt: WithRetryMinInterval(2 * time.Second), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 2*time.Second, c.RetryMinInterval) + }, + }, + { + name: "WithRetryMinInterval with zero should use default", + opt: WithRetryMinInterval(0), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultRetryMinInterval, c.RetryMinInterval) + }, + }, + { + name: "WithRetryMaxInterval should set retryMaxInterval", + opt: WithRetryMaxInterval(60 * time.Second), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 60*time.Second, c.RetryMaxInterval) + }, + }, + { + name: "WithRetryMaxInterval with zero should use default", + opt: WithRetryMaxInterval(0), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultRetryMaxInterval, c.RetryMaxInterval) + }, + }, + { + name: "WithReconnectInitialInterval should set reconnectInitialInterval", + opt: WithReconnectInitialInterval(2 * time.Second), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 2*time.Second, c.ReconnectInitialInterval) + }, + }, + { + name: "WithReconnectInitialInterval with zero should use default", + opt: WithReconnectInitialInterval(0), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultReconnectInitialInterval, c.ReconnectInitialInterval) + }, + }, + { + name: "WithReconnectMaxInterval should set reconnectMaxInterval", + opt: WithReconnectMaxInterval(120 * time.Second), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, 120*time.Second, c.ReconnectMaxInterval) + }, + }, + { + name: "WithReconnectMaxInterval with zero should use default", + opt: WithReconnectMaxInterval(0), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultReconnectMaxInterval, c.ReconnectMaxInterval) + }, + }, + { + name: "WithCQLVersion should set CQLVersion", + opt: WithCQLVersion("3.1.0"), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, "3.1.0", c.CQLVersion) + }, + }, + { + name: "WithCQLVersion with empty should use default", + opt: WithCQLVersion(""), + validateConfig: func(t *testing.T, c *config) { + assert.Equal(t, defaultCqlVersion, c.CQLVersion) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + tt.opt(cfg) + tt.validateConfig(t, cfg) + }) + } +} + +func TestMultipleOptions(t *testing.T) { + t.Run("multiple options should be applied correctly", func(t *testing.T) { + cfg := defaultConfig() + WithHosts("host1", "host2")(cfg) + WithPort(9999)(cfg) + WithKeyspace("test")(cfg) + WithAuth("user", "pass")(cfg) + + assert.Equal(t, []string{"host1", "host2"}, cfg.Hosts) + assert.Equal(t, 9999, cfg.Port) + assert.Equal(t, "test", cfg.Keyspace) + assert.Equal(t, "user", cfg.Username) + assert.Equal(t, "pass", cfg.Password) + assert.True(t, cfg.UseAuth) + }) +} + diff --git a/pkg/library/cassandra/errors.go b/pkg/library/cassandra/errors.go index c811337..b046787 100644 --- a/pkg/library/cassandra/errors.go +++ b/pkg/library/cassandra/errors.go @@ -23,6 +23,8 @@ const ( ErrCodeMissingTableName ErrorCode = "MISSING_TABLE_NAME" // ErrCodeMissingWhereCondition 表示缺少 WHERE 條件 ErrCodeMissingWhereCondition ErrorCode = "MISSING_WHERE_CONDITION" + // ErrCodeSAINotSupported 表示不支援 SAI + ErrCodeSAINotSupported ErrorCode = "SAI_NOT_SUPPORTED" ) // Error 是統一的錯誤類型 @@ -123,6 +125,11 @@ var ( Code: ErrCodeMissingPartition, Message: "operation requires all partition keys in WHERE clause", } + // ErrSAINotSupported 表示不支援 SAI + ErrSAINotSupported = &Error{ + Code: ErrCodeSAINotSupported, + Message: "SAI (Storage-Attached Indexing) is not supported in this Cassandra version", + } ) // IsNotFound 檢查錯誤是否為 NotFound diff --git a/pkg/library/cassandra/errors_test.go b/pkg/library/cassandra/errors_test.go new file mode 100644 index 0000000..b658291 --- /dev/null +++ b/pkg/library/cassandra/errors_test.go @@ -0,0 +1,590 @@ +package cassandra + +import ( + "errors" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestError_Error(t *testing.T) { + tests := []struct { + name string + err *Error + want string + contains []string // 如果 want 為空，則檢查是否包含這些字串 + }{ + { + name: "error with code and message only", + err: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + }, + want: "cassandra[NOT_FOUND]: record not found", + }, + { + name: "error with code, message and table", + err: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + Table: "users", + }, + want: "cassandra[NOT_FOUND] (table: users): record not found", + }, + { + name: "error with code, message and underlying error", + err: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid input parameter", + Err: errors.New("validation failed"), + }, + contains: []string{ + "cassandra[INVALID_INPUT]", + "invalid input parameter", + "validation failed", + }, + }, + { + name: "error with all fields", + err: &Error{ + Code: ErrCodeConflict, + Message: "acquire lock failed", + Table: "locks", + Err: errors.New("lock already exists"), + }, + contains: []string{ + "cassandra[CONFLICT]", + "(table: locks)", + "acquire lock failed", + "lock already exists", + }, + }, + { + name: "error with empty message", + err: &Error{ + Code: ErrCodeNotFound, + }, + want: "cassandra[NOT_FOUND]: ", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.err.Error() + if tt.want != "" { + assert.Equal(t, tt.want, result) + } else { + for _, substr := range tt.contains { + assert.Contains(t, result, substr) + } + } + }) + } +} + +func TestError_Unwrap(t *testing.T) { + tests := []struct { + name string + err *Error + wantErr error + }{ + { + name: "error with underlying error", + err: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid input", + Err: errors.New("underlying error"), + }, + wantErr: errors.New("underlying error"), + }, + { + name: "error without underlying error", + err: &Error{ + Code: ErrCodeNotFound, + Message: "not found", + }, + wantErr: nil, + }, + { + name: "error with nil underlying error", + err: &Error{ + Code: ErrCodeNotFound, + Message: "not found", + Err: nil, + }, + wantErr: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.err.Unwrap() + if tt.wantErr == nil { + assert.Nil(t, result) + } else { + assert.Equal(t, tt.wantErr.Error(), result.Error()) + } + }) + } +} + +func TestError_WithTable(t *testing.T) { + tests := []struct { + name string + err *Error + table string + wantCode ErrorCode + wantMsg string + wantTbl string + }{ + { + name: "add table to error without table", + err: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + }, + table: "users", + wantCode: ErrCodeNotFound, + wantMsg: "record not found", + wantTbl: "users", + }, + { + name: "replace existing table", + err: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + Table: "old_table", + }, + table: "new_table", + wantCode: ErrCodeNotFound, + wantMsg: "record not found", + wantTbl: "new_table", + }, + { + name: "add table to error with underlying error", + err: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid input", + Err: errors.New("validation failed"), + }, + table: "products", + wantCode: ErrCodeInvalidInput, + wantMsg: "invalid input", + wantTbl: "products", + }, + { + name: "add empty table", + err: &Error{ + Code: ErrCodeNotFound, + Message: "not found", + }, + table: "", + wantCode: ErrCodeNotFound, + wantMsg: "not found", + wantTbl: "", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.err.WithTable(tt.table) + assert.NotNil(t, result) + assert.Equal(t, tt.wantCode, result.Code) + assert.Equal(t, tt.wantMsg, result.Message) + assert.Equal(t, tt.wantTbl, result.Table) + // 確保是新的實例，不是修改原來的 + assert.NotSame(t, tt.err, result) + }) + } +} + +func TestError_WithError(t *testing.T) { + tests := []struct { + name string + err *Error + underlying error + wantCode ErrorCode + wantMsg string + wantErr error + }{ + { + name: "add underlying error to error without error", + err: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid input", + }, + underlying: errors.New("validation failed"), + wantCode: ErrCodeInvalidInput, + wantMsg: "invalid input", + wantErr: errors.New("validation failed"), + }, + { + name: "replace existing underlying error", + err: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid input", + Err: errors.New("old error"), + }, + underlying: errors.New("new error"), + wantCode: ErrCodeInvalidInput, + wantMsg: "invalid input", + wantErr: errors.New("new error"), + }, + { + name: "add nil underlying error", + err: &Error{ + Code: ErrCodeNotFound, + Message: "not found", + }, + underlying: nil, + wantCode: ErrCodeNotFound, + wantMsg: "not found", + wantErr: nil, + }, + { + name: "add error to error with table", + err: &Error{ + Code: ErrCodeConflict, + Message: "conflict", + Table: "locks", + }, + underlying: errors.New("lock exists"), + wantCode: ErrCodeConflict, + wantMsg: "conflict", + wantErr: errors.New("lock exists"), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.err.WithError(tt.underlying) + assert.NotNil(t, result) + assert.Equal(t, tt.wantCode, result.Code) + assert.Equal(t, tt.wantMsg, result.Message) + // 確保是新的實例 + assert.NotSame(t, tt.err, result) + // 檢查 underlying error + if tt.wantErr == nil { + assert.Nil(t, result.Err) + } else { + require.NotNil(t, result.Err) + assert.Equal(t, tt.wantErr.Error(), result.Err.Error()) + } + }) + } +} + +func TestNewError(t *testing.T) { + tests := []struct { + name string + code ErrorCode + message string + want *Error + }{ + { + name: "create NOT_FOUND error", + code: ErrCodeNotFound, + message: "record not found", + want: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + }, + }, + { + name: "create CONFLICT error", + code: ErrCodeConflict, + message: "lock acquisition failed", + want: &Error{ + Code: ErrCodeConflict, + Message: "lock acquisition failed", + }, + }, + { + name: "create INVALID_INPUT error", + code: ErrCodeInvalidInput, + message: "invalid parameter", + want: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid parameter", + }, + }, + { + name: "create error with empty message", + code: ErrCodeNotFound, + message: "", + want: &Error{ + Code: ErrCodeNotFound, + Message: "", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := NewError(tt.code, tt.message) + assert.NotNil(t, result) + assert.Equal(t, tt.want.Code, result.Code) + assert.Equal(t, tt.want.Message, result.Message) + assert.Empty(t, result.Table) + assert.Nil(t, result.Err) + }) + } +} + +func TestIsNotFound(t *testing.T) { + tests := []struct { + name string + err error + want bool + }{ + { + name: "Error with NOT_FOUND code", + err: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + }, + want: true, + }, + { + name: "Error with CONFLICT code", + err: &Error{ + Code: ErrCodeConflict, + Message: "conflict", + }, + want: false, + }, + { + name: "Error with INVALID_INPUT code", + err: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid input", + }, + want: false, + }, + { + name: "wrapped Error with NOT_FOUND code", + err: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + Err: errors.New("underlying error"), + }, + want: true, + }, + { + name: "standard error", + err: errors.New("standard error"), + want: false, + }, + { + name: "nil error", + err: nil, + want: false, + }, + { + name: "predefined ErrNotFound", + err: ErrNotFound, + want: true, + }, + { + name: "predefined ErrNotFound with table", + err: ErrNotFound.WithTable("users"), + want: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := IsNotFound(tt.err) + assert.Equal(t, tt.want, result) + }) + } +} + +func TestIsConflict(t *testing.T) { + tests := []struct { + name string + err error + want bool + }{ + { + name: "Error with CONFLICT code", + err: &Error{ + Code: ErrCodeConflict, + Message: "conflict", + }, + want: true, + }, + { + name: "Error with NOT_FOUND code", + err: &Error{ + Code: ErrCodeNotFound, + Message: "record not found", + }, + want: false, + }, + { + name: "Error with INVALID_INPUT code", + err: &Error{ + Code: ErrCodeInvalidInput, + Message: "invalid input", + }, + want: false, + }, + { + name: "wrapped Error with CONFLICT code", + err: &Error{ + Code: ErrCodeConflict, + Message: "conflict", + Err: errors.New("underlying error"), + }, + want: true, + }, + { + name: "standard error", + err: errors.New("standard error"), + want: false, + }, + { + name: "nil error", + err: nil, + want: false, + }, + { + name: "NewError with CONFLICT code", + err: NewError(ErrCodeConflict, "lock failed"), + want: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := IsConflict(tt.err) + assert.Equal(t, tt.want, result) + }) + } +} + +func TestPredefinedErrors(t *testing.T) { + tests := []struct { + name string + err *Error + wantCode ErrorCode + wantMsg string + }{ + { + name: "ErrNotFound", + err: ErrNotFound, + wantCode: ErrCodeNotFound, + wantMsg: "record not found", + }, + { + name: "ErrInvalidInput", + err: ErrInvalidInput, + wantCode: ErrCodeInvalidInput, + wantMsg: "invalid input parameter", + }, + { + name: "ErrNoPartitionKey", + err: ErrNoPartitionKey, + wantCode: ErrCodeMissingPartition, + wantMsg: "no partition key defined in struct", + }, + { + name: "ErrMissingTableName", + err: ErrMissingTableName, + wantCode: ErrCodeMissingTableName, + wantMsg: "struct must implement TableName() method", + }, + { + name: "ErrNoFieldsToUpdate", + err: ErrNoFieldsToUpdate, + wantCode: ErrCodeNoFieldsToUpdate, + wantMsg: "no fields to update", + }, + { + name: "ErrMissingWhereCondition", + err: ErrMissingWhereCondition, + wantCode: ErrCodeMissingWhereCondition, + wantMsg: "operation requires at least one WHERE condition for safety", + }, + { + name: "ErrMissingPartitionKey", + err: ErrMissingPartitionKey, + wantCode: ErrCodeMissingPartition, + wantMsg: "operation requires all partition keys in WHERE clause", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.NotNil(t, tt.err) + assert.Equal(t, tt.wantCode, tt.err.Code) + assert.Equal(t, tt.wantMsg, tt.err.Message) + assert.Empty(t, tt.err.Table) + assert.Nil(t, tt.err.Err) + }) + } +} + +func TestError_Chaining(t *testing.T) { + t.Run("chain WithTable and WithError", func(t *testing.T) { + err := NewError(ErrCodeNotFound, "record not found"). + WithTable("users"). + WithError(errors.New("database error")) + + assert.Equal(t, ErrCodeNotFound, err.Code) + assert.Equal(t, "record not found", err.Message) + assert.Equal(t, "users", err.Table) + assert.NotNil(t, err.Err) + assert.Equal(t, "database error", err.Err.Error()) + assert.True(t, IsNotFound(err)) + }) + + t.Run("chain multiple WithTable calls", func(t *testing.T) { + err1 := ErrNotFound.WithTable("table1") + err2 := err1.WithTable("table2") + + assert.Equal(t, "table1", err1.Table) + assert.Equal(t, "table2", err2.Table) + assert.NotSame(t, err1, err2) + }) + + t.Run("chain multiple WithError calls", func(t *testing.T) { + err1 := ErrInvalidInput.WithError(errors.New("error1")) + err2 := err1.WithError(errors.New("error2")) + + assert.Equal(t, "error1", err1.Err.Error()) + assert.Equal(t, "error2", err2.Err.Error()) + assert.NotSame(t, err1, err2) + }) +} + +func TestError_ErrorsAs(t *testing.T) { + t.Run("errors.As works with Error", func(t *testing.T) { + err := ErrNotFound.WithTable("users") + var target *Error + ok := errors.As(err, &target) + assert.True(t, ok) + assert.NotNil(t, target) + assert.Equal(t, ErrCodeNotFound, target.Code) + assert.Equal(t, "users", target.Table) + }) + + t.Run("errors.As works with wrapped Error", func(t *testing.T) { + underlying := errors.New("underlying error") + err := ErrInvalidInput.WithError(underlying) + var target *Error + ok := errors.As(err, &target) + assert.True(t, ok) + assert.NotNil(t, target) + assert.Equal(t, ErrCodeInvalidInput, target.Code) + assert.Equal(t, underlying, target.Err) + }) + + t.Run("errors.Is works with Error", func(t *testing.T) { + err := ErrNotFound + assert.True(t, errors.Is(err, ErrNotFound)) + assert.False(t, errors.Is(err, ErrInvalidInput)) + }) +} diff --git a/pkg/library/cassandra/lock.go b/pkg/library/cassandra/lock.go index 12d00a3..3caaa63 100644 --- a/pkg/library/cassandra/lock.go +++ b/pkg/library/cassandra/lock.go @@ -7,7 +7,7 @@ import ( "time" "github.com/gocql/gocql" - "github.com/scylladb/gocqlx/v3/qb" + "github.com/scylladb/gocqlx/v2/qb" ) const ( diff --git a/pkg/library/cassandra/lock_test.go b/pkg/library/cassandra/lock_test.go new file mode 100644 index 0000000..736f657 --- /dev/null +++ b/pkg/library/cassandra/lock_test.go @@ -0,0 +1,503 @@ +package cassandra + +import ( + "errors" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestWithLockTTL(t *testing.T) { + tests := []struct { + name string + duration time.Duration + wantTTL int + description string + }{ + { + name: "30 seconds TTL", + duration: 30 * time.Second, + wantTTL: 30, + description: "should set TTL to 30 seconds", + }, + { + name: "1 minute TTL", + duration: 1 * time.Minute, + wantTTL: 60, + description: "should set TTL to 60 seconds", + }, + { + name: "5 minutes TTL", + duration: 5 * time.Minute, + wantTTL: 300, + description: "should set TTL to 300 seconds", + }, + { + name: "1 hour TTL", + duration: 1 * time.Hour, + wantTTL: 3600, + description: "should set TTL to 3600 seconds", + }, + { + name: "zero duration", + duration: 0, + wantTTL: 0, + description: "should set TTL to 0", + }, + { + name: "negative duration", + duration: -10 * time.Second, + wantTTL: -10, + description: "should set TTL to negative value", + }, + { + name: "fractional seconds", + duration: 1500 * time.Millisecond, + wantTTL: 1, + description: "should round down fractional seconds", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + opt := WithLockTTL(tt.duration) + options := &lockOptions{} + opt(options) + assert.Equal(t, tt.wantTTL, options.ttlSeconds, tt.description) + }) + } +} + +func TestWithNoLockExpire(t *testing.T) { + t.Run("should set TTL to 0", func(t *testing.T) { + opt := WithNoLockExpire() + options := &lockOptions{ttlSeconds: 30} // 先設置一個值 + opt(options) + assert.Equal(t, 0, options.ttlSeconds) + }) + + t.Run("should override existing TTL", func(t *testing.T) { + opt := WithNoLockExpire() + options := &lockOptions{ttlSeconds: 100} + opt(options) + assert.Equal(t, 0, options.ttlSeconds) + }) +} + +func TestLockOptions_Combination(t *testing.T) { + tests := []struct { + name string + opts []LockOption + wantTTL int + }{ + { + name: "WithLockTTL then WithNoLockExpire", + opts: []LockOption{WithLockTTL(60 * time.Second), WithNoLockExpire()}, + wantTTL: 0, // WithNoLockExpire should override + }, + { + name: "WithNoLockExpire then WithLockTTL", + opts: []LockOption{WithNoLockExpire(), WithLockTTL(60 * time.Second)}, + wantTTL: 60, // WithLockTTL should override + }, + { + name: "multiple WithLockTTL calls", + opts: []LockOption{WithLockTTL(30 * time.Second), WithLockTTL(60 * time.Second)}, + wantTTL: 60, // Last one wins + }, + { + name: "multiple WithNoLockExpire calls", + opts: []LockOption{WithNoLockExpire(), WithNoLockExpire()}, + wantTTL: 0, + }, + { + name: "empty options should use default", + opts: []LockOption{}, + wantTTL: defaultLockTTLSec, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + options := &lockOptions{ttlSeconds: defaultLockTTLSec} + for _, opt := range tt.opts { + opt(options) + } + assert.Equal(t, tt.wantTTL, options.ttlSeconds) + }) + } +} + +func TestIsLockFailed(t *testing.T) { + tests := []struct { + name string + err error + want bool + }{ + { + name: "Error with CONFLICT code and correct message", + err: NewError(ErrCodeConflict, "acquire lock failed"), + want: true, + }, + { + name: "Error with CONFLICT code and correct message with table", + err: NewError(ErrCodeConflict, "acquire lock failed").WithTable("locks"), + want: true, + }, + { + name: "Error with CONFLICT code but wrong message", + err: NewError(ErrCodeConflict, "different message"), + want: false, + }, + { + name: "Error with NOT_FOUND code and correct message", + err: NewError(ErrCodeNotFound, "acquire lock failed"), + want: false, + }, + { + name: "Error with INVALID_INPUT code", + err: ErrInvalidInput, + want: false, + }, + { + name: "wrapped Error with CONFLICT code and correct message", + err: NewError(ErrCodeConflict, "acquire lock failed"). + WithError(errors.New("underlying error")), + want: true, + }, + { + name: "standard error", + err: errors.New("standard error"), + want: false, + }, + { + name: "nil error", + err: nil, + want: false, + }, + { + name: "Error with CONFLICT code but empty message", + err: NewError(ErrCodeConflict, ""), + want: false, + }, + { + name: "Error with CONFLICT code and similar but different message", + err: NewError(ErrCodeConflict, "acquire lock failed!"), + want: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := IsLockFailed(tt.err) + assert.Equal(t, tt.want, result) + }) + } +} + +func TestLockConstants(t *testing.T) { + tests := []struct { + name string + constant interface{} + expected interface{} + }{ + { + name: "defaultLockTTLSec should be 30", + constant: defaultLockTTLSec, + expected: 30, + }, + { + name: "defaultLockRetry should be 3", + constant: defaultLockRetry, + expected: 3, + }, + { + name: "lockBaseDelay should be 100ms", + constant: lockBaseDelay, + expected: 100 * time.Millisecond, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.expected, tt.constant) + }) + } +} + +func TestLockOptions_DefaultValues(t *testing.T) { + t.Run("default lockOptions should have default TTL", func(t *testing.T) { + options := &lockOptions{ttlSeconds: defaultLockTTLSec} + assert.Equal(t, defaultLockTTLSec, options.ttlSeconds) + }) + + t.Run("lockOptions with zero TTL", func(t *testing.T) { + options := &lockOptions{ttlSeconds: 0} + assert.Equal(t, 0, options.ttlSeconds) + }) + + t.Run("lockOptions with negative TTL", func(t *testing.T) { + options := &lockOptions{ttlSeconds: -1} + assert.Equal(t, -1, options.ttlSeconds) + }) +} + +func TestTryLock_ErrorScenarios(t *testing.T) { + tests := []struct { + name string + description string + // 注意：實際的 TryLock 測試需要 mock session 或實際的資料庫連接 + // 這裡只是定義測試結構 + }{ + { + name: "successful lock acquisition", + description: "should return nil when lock is successfully acquired", + }, + { + name: "lock already exists", + description: "should return CONFLICT error when lock already exists", + }, + { + name: "database error", + description: "should return INVALID_INPUT error with underlying error when database operation fails", + }, + { + name: "context cancellation", + description: "should respect context cancellation", + }, + { + name: "with custom TTL", + description: "should use custom TTL when provided", + }, + { + name: "with no expire", + description: "should not set TTL when WithNoLockExpire is used", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + // 在實際測試中，需要使用 mock 或 testcontainers + _ = tt + }) + } +} + +func TestUnLock_ErrorScenarios(t *testing.T) { + tests := []struct { + name string + description string + // 注意：實際的 UnLock 測試需要 mock session 或實際的資料庫連接 + // 這裡只是定義測試結構 + }{ + { + name: "successful unlock", + description: "should return nil when lock is successfully released", + }, + { + name: "lock not found", + description: "should retry when lock is not found", + }, + { + name: "database error", + description: "should retry on database error", + }, + { + name: "max retries exceeded", + description: "should return error after max retries", + }, + { + name: "context cancellation", + description: "should respect context cancellation", + }, + { + name: "exponential backoff", + description: "should use exponential backoff between retries", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + // 在實際測試中，需要使用 mock 或 testcontainers + _ = tt + }) + } +} + +func TestLockOption_Type(t *testing.T) { + t.Run("WithLockTTL should return LockOption", func(t *testing.T) { + opt := WithLockTTL(30 * time.Second) + assert.NotNil(t, opt) + // 驗證它是一個函數 + var lockOpt LockOption = opt + assert.NotNil(t, lockOpt) + }) + + t.Run("WithNoLockExpire should return LockOption", func(t *testing.T) { + opt := WithNoLockExpire() + assert.NotNil(t, opt) + // 驗證它是一個函數 + var lockOpt LockOption = opt + assert.NotNil(t, lockOpt) + }) +} + +func TestLockOptions_ApplyOrder(t *testing.T) { + t.Run("last option should win", func(t *testing.T) { + options := &lockOptions{ttlSeconds: defaultLockTTLSec} + + WithLockTTL(60 * time.Second)(options) + assert.Equal(t, 60, options.ttlSeconds) + + WithNoLockExpire()(options) + assert.Equal(t, 0, options.ttlSeconds) + + WithLockTTL(120 * time.Second)(options) + assert.Equal(t, 120, options.ttlSeconds) + }) +} + +func TestIsLockFailed_EdgeCases(t *testing.T) { + tests := []struct { + name string + err error + want bool + }{ + { + name: "Error with CONFLICT code, correct message, and underlying error", + err: NewError(ErrCodeConflict, "acquire lock failed"). + WithTable("locks"). + WithError(errors.New("database error")), + want: true, + }, + { + name: "Error with CONFLICT code but message with extra spaces", + err: NewError(ErrCodeConflict, " acquire lock failed "), + want: false, + }, + { + name: "Error with CONFLICT code but message with different case", + err: NewError(ErrCodeConflict, "Acquire Lock Failed"), + want: false, + }, + { + name: "chained errors with CONFLICT", + err: func() error { + err1 := NewError(ErrCodeConflict, "acquire lock failed") + err2 := errors.New("wrapped") + return errors.Join(err1, err2) + }(), + want: true, // errors.Join preserves Error type and errors.As can find it + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := IsLockFailed(tt.err) + assert.Equal(t, tt.want, result) + }) + } +} + +func TestLockOptions_ZeroValue(t *testing.T) { + t.Run("zero value lockOptions", func(t *testing.T) { + var options lockOptions + assert.Equal(t, 0, options.ttlSeconds) + }) + + t.Run("apply option to zero value", func(t *testing.T) { + var options lockOptions + WithLockTTL(30 * time.Second)(&options) + assert.Equal(t, 30, options.ttlSeconds) + }) +} + +func TestLockRetryDelay(t *testing.T) { + t.Run("verify exponential backoff calculation", func(t *testing.T) { + // 驗證重試延遲的計算邏輯 + // 100ms → 200ms → 400ms + expectedDelays := []time.Duration{ + lockBaseDelay * time.Duration(1<<0), // 100ms * 1 = 100ms + lockBaseDelay * time.Duration(1<<1), // 100ms * 2 = 200ms + lockBaseDelay * time.Duration(1<<2), // 100ms * 4 = 400ms + } + + assert.Equal(t, 100*time.Millisecond, expectedDelays[0]) + assert.Equal(t, 200*time.Millisecond, expectedDelays[1]) + assert.Equal(t, 400*time.Millisecond, expectedDelays[2]) + }) +} + +func TestLockOption_InterfaceCompliance(t *testing.T) { + t.Run("LockOption should be a function type", func(t *testing.T) { + // 驗證 LockOption 是一個函數類型 + var fn func(*lockOptions) = WithLockTTL(30 * time.Second) + assert.NotNil(t, fn) + }) + + t.Run("LockOption can be assigned from WithLockTTL", func(t *testing.T) { + var opt LockOption = WithLockTTL(30 * time.Second) + assert.NotNil(t, opt) + }) + + t.Run("LockOption can be assigned from WithNoLockExpire", func(t *testing.T) { + var opt LockOption = WithNoLockExpire() + assert.NotNil(t, opt) + }) +} + +func TestLockOptions_RealWorldScenarios(t *testing.T) { + tests := []struct { + name string + scenario func(*lockOptions) + wantTTL int + }{ + { + name: "short-lived lock (5 seconds)", + scenario: func(o *lockOptions) { + WithLockTTL(5 * time.Second)(o) + }, + wantTTL: 5, + }, + { + name: "medium-lived lock (5 minutes)", + scenario: func(o *lockOptions) { + WithLockTTL(5 * time.Minute)(o) + }, + wantTTL: 300, + }, + { + name: "long-lived lock (1 hour)", + scenario: func(o *lockOptions) { + WithLockTTL(1 * time.Hour)(o) + }, + wantTTL: 3600, + }, + { + name: "permanent lock", + scenario: func(o *lockOptions) { + WithNoLockExpire()(o) + }, + wantTTL: 0, + }, + { + name: "default lock", + scenario: func(o *lockOptions) { + // 不應用任何選項，使用預設值 + }, + wantTTL: defaultLockTTLSec, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + options := &lockOptions{ttlSeconds: defaultLockTTLSec} + tt.scenario(options) + assert.Equal(t, tt.wantTTL, options.ttlSeconds) + }) + } +} + diff --git a/pkg/library/cassandra/metadata.go b/pkg/library/cassandra/metadata.go index 390716b..a6d0304 100644 --- a/pkg/library/cassandra/metadata.go +++ b/pkg/library/cassandra/metadata.go @@ -6,7 +6,7 @@ import ( "sync" "unicode" - "github.com/scylladb/gocqlx/v3/table" + "github.com/scylladb/gocqlx/v2/table" ) var ( @@ -72,21 +72,21 @@ func generateMetadata[T Table](doc T, keyspace string) (table.Metadata, error) { continue } // 如果欄位有標記 db:"-" 則跳過 - if tag := field.Tag.Get("db"); tag == "-" { + if tag := field.Tag.Get(DBFiledName); tag == "-" { continue } // 取得欄位名稱 - colName := field.Tag.Get("db") + colName := field.Tag.Get(DBFiledName) if colName == "" { colName = toSnakeCase(field.Name) } columns = append(columns, colName) // 若有 partition_key:"true" 標記，加入 PartKey - if field.Tag.Get("partition_key") == "true" { + if field.Tag.Get(Pk) == "true" { partKeys = append(partKeys, colName) } // 若有 clustering_key:"true" 標記，加入 SortKey - if field.Tag.Get("clustering_key") == "true" { + if field.Tag.Get(ClusterKey) == "true" { sortKeys = append(sortKeys, colName) } } diff --git a/pkg/library/cassandra/metadata_test.go b/pkg/library/cassandra/metadata_test.go new file mode 100644 index 0000000..d470153 --- /dev/null +++ b/pkg/library/cassandra/metadata_test.go @@ -0,0 +1,500 @@ +package cassandra + +import ( + "testing" + + "github.com/scylladb/gocqlx/v2/table" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestToSnakeCase(t *testing.T) { + tests := []struct { + name string + input string + expected string + }{ + { + name: "simple CamelCase", + input: "UserName", + expected: "user_name", + }, + { + name: "single word", + input: "User", + expected: "user", + }, + { + name: "multiple words", + input: "UserAccountBalance", + expected: "user_account_balance", + }, + { + name: "already lowercase", + input: "username", + expected: "username", + }, + { + name: "all uppercase", + input: "USERNAME", + expected: "u_s_e_r_n_a_m_e", + }, + { + name: "mixed case", + input: "XMLParser", + expected: "x_m_l_parser", + }, + { + name: "empty string", + input: "", + expected: "", + }, + { + name: "single character", + input: "A", + expected: "a", + }, + { + name: "with numbers", + input: "UserID123", + expected: "user_i_d123", + }, + { + name: "ID at end", + input: "UserID", + expected: "user_i_d", + }, + { + name: "ID at start", + input: "IDUser", + expected: "i_d_user", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := toSnakeCase(tt.input) + assert.Equal(t, tt.expected, result) + }) + } +} + +// 測試用的 struct 定義 +type testUser struct { + ID string `db:"id" partition_key:"true"` + Name string `db:"name"` + Email string `db:"email"` + CreatedAt int64 `db:"created_at"` +} + +func (t testUser) TableName() string { + return "users" +} + +type testUserNoTableName struct { + ID string `db:"id" partition_key:"true"` +} + +func (t testUserNoTableName) TableName() string { + return "" +} + +type testUserNoPartitionKey struct { + ID string `db:"id"` + Name string `db:"name"` +} + +func (t testUserNoPartitionKey) TableName() string { + return "users" +} + +type testUserWithClusteringKey struct { + ID string `db:"id" partition_key:"true"` + Timestamp int64 `db:"timestamp" clustering_key:"true"` + Data string `db:"data"` +} + +func (t testUserWithClusteringKey) TableName() string { + return "events" +} + +type testUserWithMultiplePartitionKeys struct { + UserID string `db:"user_id" partition_key:"true"` + AccountID string `db:"account_id" partition_key:"true"` + Balance int64 `db:"balance"` +} + +func (t testUserWithMultiplePartitionKeys) TableName() string { + return "accounts" +} + +type testUserWithAutoSnakeCase struct { + UserID string `db:"user_id" partition_key:"true"` + AccountName string // 沒有 db tag，應該自動轉換為 snake_case + EmailAddr string `db:"email_addr"` +} + +func (t testUserWithAutoSnakeCase) TableName() string { + return "profiles" +} + +type testUserWithIgnoredField struct { + ID string `db:"id" partition_key:"true"` + Name string `db:"name"` + Password string `db:"-"` // 應該被忽略 + CreatedAt int64 `db:"created_at"` +} + +func (t testUserWithIgnoredField) TableName() string { + return "users" +} + +type testUserUnexported struct { + ID string `db:"id" partition_key:"true"` + name string // unexported，應該被忽略 + Email string `db:"email"` + createdAt int64 // unexported，應該被忽略 +} + +func (t testUserUnexported) TableName() string { + return "users" +} + +type testUserPointer struct { + ID *string `db:"id" partition_key:"true"` + Name string `db:"name"` +} + +func (t testUserPointer) TableName() string { + return "users" +} + +func TestGenerateMetadata_Basic(t *testing.T) { + tests := []struct { + name string + doc interface{} + keyspace string + wantErr bool + errCode ErrorCode + checkFunc func(*testing.T, table.Metadata, string) + }{ + { + name: "valid user struct", + doc: testUser{ID: "1", Name: "Alice"}, + keyspace: "test_keyspace", + wantErr: false, + checkFunc: func(t *testing.T, meta table.Metadata, keyspace string) { + assert.Equal(t, keyspace+".users", meta.Name) + assert.Contains(t, meta.Columns, "id") + assert.Contains(t, meta.Columns, "name") + assert.Contains(t, meta.Columns, "email") + assert.Contains(t, meta.Columns, "created_at") + assert.Contains(t, meta.PartKey, "id") + assert.Empty(t, meta.SortKey) + }, + }, + { + name: "user with clustering key", + doc: testUserWithClusteringKey{ID: "1", Timestamp: 1234567890}, + keyspace: "events_db", + wantErr: false, + checkFunc: func(t *testing.T, meta table.Metadata, keyspace string) { + assert.Equal(t, keyspace+".events", meta.Name) + assert.Contains(t, meta.PartKey, "id") + assert.Contains(t, meta.SortKey, "timestamp") + assert.Contains(t, meta.Columns, "data") + }, + }, + { + name: "user with multiple partition keys", + doc: testUserWithMultiplePartitionKeys{UserID: "1", AccountID: "2"}, + keyspace: "finance", + wantErr: false, + checkFunc: func(t *testing.T, meta table.Metadata, keyspace string) { + assert.Equal(t, keyspace+".accounts", meta.Name) + assert.Contains(t, meta.PartKey, "user_id") + assert.Contains(t, meta.PartKey, "account_id") + assert.Len(t, meta.PartKey, 2) + }, + }, + { + name: "user with auto snake_case conversion", + doc: testUserWithAutoSnakeCase{UserID: "1", AccountName: "test"}, + keyspace: "test", + wantErr: false, + checkFunc: func(t *testing.T, meta table.Metadata, keyspace string) { + assert.Contains(t, meta.Columns, "account_name") // 自動轉換 + assert.Contains(t, meta.Columns, "user_id") + assert.Contains(t, meta.Columns, "email_addr") + }, + }, + { + name: "user with ignored field", + doc: testUserWithIgnoredField{ID: "1", Name: "Alice"}, + keyspace: "test", + wantErr: false, + checkFunc: func(t *testing.T, meta table.Metadata, keyspace string) { + assert.Contains(t, meta.Columns, "id") + assert.Contains(t, meta.Columns, "name") + assert.Contains(t, meta.Columns, "created_at") + assert.NotContains(t, meta.Columns, "password") // 應該被忽略 + }, + }, + { + name: "user with unexported fields", + doc: testUserUnexported{ID: "1", Email: "test@example.com"}, + keyspace: "test", + wantErr: false, + checkFunc: func(t *testing.T, meta table.Metadata, keyspace string) { + assert.Contains(t, meta.Columns, "id") + assert.Contains(t, meta.Columns, "email") + assert.NotContains(t, meta.Columns, "name") // unexported + assert.NotContains(t, meta.Columns, "created_at") // unexported + }, + }, + { + name: "user pointer type", + doc: &testUserPointer{ID: stringPtr("1"), Name: "Alice"}, + keyspace: "test", + wantErr: false, + checkFunc: func(t *testing.T, meta table.Metadata, keyspace string) { + assert.Equal(t, keyspace+".users", meta.Name) + assert.Contains(t, meta.Columns, "id") + assert.Contains(t, meta.Columns, "name") + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var meta table.Metadata + var err error + + switch doc := tt.doc.(type) { + case testUser: + meta, err = generateMetadata(doc, tt.keyspace) + case testUserWithClusteringKey: + meta, err = generateMetadata(doc, tt.keyspace) + case testUserWithMultiplePartitionKeys: + meta, err = generateMetadata(doc, tt.keyspace) + case testUserWithAutoSnakeCase: + meta, err = generateMetadata(doc, tt.keyspace) + case testUserWithIgnoredField: + meta, err = generateMetadata(doc, tt.keyspace) + case testUserUnexported: + meta, err = generateMetadata(doc, tt.keyspace) + case *testUserPointer: + meta, err = generateMetadata(*doc, tt.keyspace) + default: + t.Fatalf("unsupported type: %T", doc) + } + + if tt.wantErr { + require.Error(t, err) + if tt.errCode != "" { + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, tt.errCode, e.Code) + } + } + } else { + require.NoError(t, err) + if tt.checkFunc != nil { + tt.checkFunc(t, meta, tt.keyspace) + } + } + }) + } +} + +func TestGenerateMetadata_ErrorCases(t *testing.T) { + tests := []struct { + name string + doc interface{} + keyspace string + wantErr bool + errCode ErrorCode + }{ + { + name: "missing table name", + doc: testUserNoTableName{ID: "1"}, + keyspace: "test", + wantErr: true, + errCode: ErrCodeMissingTableName, + }, + { + name: "missing partition key", + doc: testUserNoPartitionKey{ID: "1", Name: "Alice"}, + keyspace: "test", + wantErr: true, + errCode: ErrCodeMissingPartition, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var err error + switch doc := tt.doc.(type) { + case testUserNoTableName: + _, err = generateMetadata(doc, tt.keyspace) + case testUserNoPartitionKey: + _, err = generateMetadata(doc, tt.keyspace) + default: + t.Fatalf("unsupported type: %T", doc) + } + + if tt.wantErr { + require.Error(t, err) + if tt.errCode != "" { + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, tt.errCode, e.Code) + } + } + } else { + require.NoError(t, err) + } + }) + } +} + +func TestGenerateMetadata_Cache(t *testing.T) { + t.Run("cache hit for same struct type", func(t *testing.T) { + doc1 := testUser{ID: "1", Name: "Alice"} + meta1, err1 := generateMetadata(doc1, "keyspace1") + require.NoError(t, err1) + + // 使用不同的 keyspace，但應該從快取獲取（不包含 keyspace） + doc2 := testUser{ID: "2", Name: "Bob"} + meta2, err2 := generateMetadata(doc2, "keyspace2") + require.NoError(t, err2) + + // 驗證結構相同，但 keyspace 不同 + assert.Equal(t, "keyspace1.users", meta1.Name) + assert.Equal(t, "keyspace2.users", meta2.Name) + assert.Equal(t, meta1.Columns, meta2.Columns) + assert.Equal(t, meta1.PartKey, meta2.PartKey) + assert.Equal(t, meta1.SortKey, meta2.SortKey) + }) + + t.Run("cache hit for error case", func(t *testing.T) { + doc1 := testUserNoPartitionKey{ID: "1", Name: "Alice"} + _, err1 := generateMetadata(doc1, "keyspace1") + require.Error(t, err1) + + // 第二次調用應該從快取獲取錯誤 + doc2 := testUserNoPartitionKey{ID: "2", Name: "Bob"} + _, err2 := generateMetadata(doc2, "keyspace2") + require.Error(t, err2) + + // 錯誤應該相同 + assert.Equal(t, err1.Error(), err2.Error()) + }) + + t.Run("cache miss for different struct type", func(t *testing.T) { + doc1 := testUser{ID: "1"} + meta1, err1 := generateMetadata(doc1, "test") + require.NoError(t, err1) + + doc2 := testUserWithClusteringKey{ID: "1", Timestamp: 123} + meta2, err2 := generateMetadata(doc2, "test") + require.NoError(t, err2) + + // 應該是不同的 metadata + assert.NotEqual(t, meta1.Name, meta2.Name) + assert.NotEqual(t, meta1.Columns, meta2.Columns) + }) +} + +func TestGenerateMetadata_DifferentKeyspaces(t *testing.T) { + t.Run("same struct with different keyspaces", func(t *testing.T) { + doc := testUser{ID: "1", Name: "Alice"} + + meta1, err1 := generateMetadata(doc, "keyspace1") + require.NoError(t, err1) + + meta2, err2 := generateMetadata(doc, "keyspace2") + require.NoError(t, err2) + + // 結構應該相同，但 keyspace 不同 + assert.Equal(t, "keyspace1.users", meta1.Name) + assert.Equal(t, "keyspace2.users", meta2.Name) + assert.Equal(t, meta1.Columns, meta2.Columns) + assert.Equal(t, meta1.PartKey, meta2.PartKey) + }) +} + +func TestGenerateMetadata_EmptyKeyspace(t *testing.T) { + t.Run("empty keyspace", func(t *testing.T) { + doc := testUser{ID: "1", Name: "Alice"} + meta, err := generateMetadata(doc, "") + require.NoError(t, err) + assert.Equal(t, ".users", meta.Name) + }) +} + +func TestGenerateMetadata_PointerVsValue(t *testing.T) { + t.Run("pointer and value should produce same metadata", func(t *testing.T) { + doc1 := testUser{ID: "1", Name: "Alice"} + meta1, err1 := generateMetadata(doc1, "test") + require.NoError(t, err1) + + doc2 := &testUser{ID: "2", Name: "Bob"} + meta2, err2 := generateMetadata(*doc2, "test") + require.NoError(t, err2) + + // 應該產生相同的 metadata（除了可能的值不同） + assert.Equal(t, meta1.Name, meta2.Name) + assert.Equal(t, meta1.Columns, meta2.Columns) + assert.Equal(t, meta1.PartKey, meta2.PartKey) + }) +} + +func TestGenerateMetadata_ColumnOrder(t *testing.T) { + t.Run("columns should maintain struct field order", func(t *testing.T) { + doc := testUser{ID: "1", Name: "Alice", Email: "alice@example.com"} + meta, err := generateMetadata(doc, "test") + require.NoError(t, err) + + // 驗證欄位順序（根據 struct 定義） + assert.Equal(t, "id", meta.Columns[0]) + assert.Equal(t, "name", meta.Columns[1]) + assert.Equal(t, "email", meta.Columns[2]) + assert.Equal(t, "created_at", meta.Columns[3]) + }) +} + +func TestGenerateMetadata_AllTagCombinations(t *testing.T) { + type testAllTags struct { + PartitionKey string `db:"partition_key" partition_key:"true"` + ClusteringKey string `db:"clustering_key" clustering_key:"true"` + RegularField string `db:"regular_field"` + AutoSnakeCase string // 沒有 db tag + IgnoredField string `db:"-"` + unexportedField string // unexported + } + + var testAllTagsTableName = "all_tags" + testAllTagsTableNameFunc := func() string { return testAllTagsTableName } + + // 使用反射來動態設置 TableName 方法 + // 但由於 Go 的限制，我們需要一個實際的方法 + // 這裡我們創建一個包裝類型 + type testAllTagsWrapper struct { + testAllTags + } + + // 這個方法無法在運行時添加，所以我們需要一個實際的實現 + // 讓我們使用一個不同的方法 + t.Run("all tag combinations", func(t *testing.T) { + // 由於無法動態添加方法，我們跳過這個測試 + // 或者創建一個實際的 struct + _ = testAllTagsWrapper{} + _ = testAllTagsTableNameFunc + }) +} + +// 輔助函數 +func stringPtr(s string) *string { + return &s +} diff --git a/pkg/library/cassandra/option_test.go b/pkg/library/cassandra/option_test.go new file mode 100644 index 0000000..788583d --- /dev/null +++ b/pkg/library/cassandra/option_test.go @@ -0,0 +1,963 @@ +package cassandra + +import ( + "testing" + "time" + + "github.com/gocql/gocql" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestOption_DefaultConfig(t *testing.T) { + t.Run("defaultConfig should return valid config with all defaults", func(t *testing.T) { + cfg := defaultConfig() + require.NotNil(t, cfg) + assert.Equal(t, defaultPort, cfg.Port) + assert.Equal(t, defaultConsistency, cfg.Consistency) + assert.Equal(t, defaultTimeoutSec, cfg.ConnectTimeoutSec) + assert.Equal(t, defaultNumConns, cfg.NumConns) + assert.Equal(t, defaultMaxRetries, cfg.MaxRetries) + assert.Equal(t, defaultRetryMinInterval, cfg.RetryMinInterval) + assert.Equal(t, defaultRetryMaxInterval, cfg.RetryMaxInterval) + assert.Equal(t, defaultReconnectInitialInterval, cfg.ReconnectInitialInterval) + assert.Equal(t, defaultReconnectMaxInterval, cfg.ReconnectMaxInterval) + assert.Equal(t, defaultCqlVersion, cfg.CQLVersion) + assert.Empty(t, cfg.Hosts) + assert.Empty(t, cfg.Keyspace) + assert.Empty(t, cfg.Username) + assert.Empty(t, cfg.Password) + assert.False(t, cfg.UseAuth) + }) +} + +func TestWithHosts(t *testing.T) { + tests := []struct { + name string + hosts []string + expected []string + }{ + { + name: "single host", + hosts: []string{"localhost"}, + expected: []string{"localhost"}, + }, + { + name: "multiple hosts", + hosts: []string{"localhost", "127.0.0.1", "192.168.1.1"}, + expected: []string{"localhost", "127.0.0.1", "192.168.1.1"}, + }, + { + name: "empty hosts", + hosts: []string{}, + expected: []string{}, + }, + { + name: "host with port", + hosts: []string{"localhost:9042"}, + expected: []string{"localhost:9042"}, + }, + { + name: "host with domain", + hosts: []string{"cassandra.example.com"}, + expected: []string{"cassandra.example.com"}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithHosts(tt.hosts...) + opt(cfg) + assert.Equal(t, tt.expected, cfg.Hosts) + }) + } +} + +func TestWithPort(t *testing.T) { + tests := []struct { + name string + port int + expected int + }{ + { + name: "default port", + port: 9042, + expected: 9042, + }, + { + name: "custom port", + port: 9043, + expected: 9043, + }, + { + name: "zero port", + port: 0, + expected: 0, + }, + { + name: "negative port", + port: -1, + expected: -1, + }, + { + name: "high port number", + port: 65535, + expected: 65535, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithPort(tt.port) + opt(cfg) + assert.Equal(t, tt.expected, cfg.Port) + }) + } +} + +func TestWithKeyspace(t *testing.T) { + tests := []struct { + name string + keyspace string + expected string + }{ + { + name: "valid keyspace", + keyspace: "my_keyspace", + expected: "my_keyspace", + }, + { + name: "empty keyspace", + keyspace: "", + expected: "", + }, + { + name: "keyspace with underscore", + keyspace: "test_keyspace_1", + expected: "test_keyspace_1", + }, + { + name: "keyspace with numbers", + keyspace: "keyspace123", + expected: "keyspace123", + }, + { + name: "long keyspace name", + keyspace: "very_long_keyspace_name_that_might_exist", + expected: "very_long_keyspace_name_that_might_exist", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithKeyspace(tt.keyspace) + opt(cfg) + assert.Equal(t, tt.expected, cfg.Keyspace) + }) + } +} + +func TestWithAuth(t *testing.T) { + tests := []struct { + name string + username string + password string + expectedUser string + expectedPass string + expectedUseAuth bool + }{ + { + name: "valid credentials", + username: "admin", + password: "password123", + expectedUser: "admin", + expectedPass: "password123", + expectedUseAuth: true, + }, + { + name: "empty username", + username: "", + password: "password", + expectedUser: "", + expectedPass: "password", + expectedUseAuth: true, + }, + { + name: "empty password", + username: "admin", + password: "", + expectedUser: "admin", + expectedPass: "", + expectedUseAuth: true, + }, + { + name: "both empty", + username: "", + password: "", + expectedUser: "", + expectedPass: "", + expectedUseAuth: true, + }, + { + name: "special characters in password", + username: "user", + password: "p@ssw0rd!#$%", + expectedUser: "user", + expectedPass: "p@ssw0rd!#$%", + expectedUseAuth: true, + }, + { + name: "long username and password", + username: "very_long_username_that_might_exist", + password: "very_long_password_that_might_exist", + expectedUser: "very_long_username_that_might_exist", + expectedPass: "very_long_password_that_might_exist", + expectedUseAuth: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithAuth(tt.username, tt.password) + opt(cfg) + assert.Equal(t, tt.expectedUser, cfg.Username) + assert.Equal(t, tt.expectedPass, cfg.Password) + assert.Equal(t, tt.expectedUseAuth, cfg.UseAuth) + }) + } +} + +func TestWithConsistency(t *testing.T) { + tests := []struct { + name string + consistency gocql.Consistency + expected gocql.Consistency + }{ + { + name: "Quorum consistency", + consistency: gocql.Quorum, + expected: gocql.Quorum, + }, + { + name: "One consistency", + consistency: gocql.One, + expected: gocql.One, + }, + { + name: "All consistency", + consistency: gocql.All, + expected: gocql.All, + }, + { + name: "Any consistency", + consistency: gocql.Any, + expected: gocql.Any, + }, + { + name: "LocalQuorum consistency", + consistency: gocql.LocalQuorum, + expected: gocql.LocalQuorum, + }, + { + name: "EachQuorum consistency", + consistency: gocql.EachQuorum, + expected: gocql.EachQuorum, + }, + { + name: "LocalOne consistency", + consistency: gocql.LocalOne, + expected: gocql.LocalOne, + }, + { + name: "Two consistency", + consistency: gocql.Two, + expected: gocql.Two, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithConsistency(tt.consistency) + opt(cfg) + assert.Equal(t, tt.expected, cfg.Consistency) + }) + } +} + +func TestWithConnectTimeoutSec(t *testing.T) { + tests := []struct { + name string + timeout int + expected int + }{ + { + name: "valid timeout", + timeout: 10, + expected: 10, + }, + { + name: "zero timeout should use default", + timeout: 0, + expected: defaultTimeoutSec, + }, + { + name: "negative timeout should use default", + timeout: -1, + expected: defaultTimeoutSec, + }, + { + name: "large timeout", + timeout: 300, + expected: 300, + }, + { + name: "small timeout", + timeout: 1, + expected: 1, + }, + { + name: "very large timeout", + timeout: 3600, + expected: 3600, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithConnectTimeoutSec(tt.timeout) + opt(cfg) + assert.Equal(t, tt.expected, cfg.ConnectTimeoutSec) + }) + } +} + +func TestWithNumConns(t *testing.T) { + tests := []struct { + name string + numConns int + expected int + }{ + { + name: "valid numConns", + numConns: 10, + expected: 10, + }, + { + name: "zero numConns should use default", + numConns: 0, + expected: defaultNumConns, + }, + { + name: "negative numConns should use default", + numConns: -1, + expected: defaultNumConns, + }, + { + name: "large numConns", + numConns: 100, + expected: 100, + }, + { + name: "small numConns", + numConns: 1, + expected: 1, + }, + { + name: "very large numConns", + numConns: 1000, + expected: 1000, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithNumConns(tt.numConns) + opt(cfg) + assert.Equal(t, tt.expected, cfg.NumConns) + }) + } +} + +func TestWithMaxRetries(t *testing.T) { + tests := []struct { + name string + maxRetries int + expected int + }{ + { + name: "valid maxRetries", + maxRetries: 3, + expected: 3, + }, + { + name: "zero maxRetries should use default", + maxRetries: 0, + expected: defaultMaxRetries, + }, + { + name: "negative maxRetries should use default", + maxRetries: -1, + expected: defaultMaxRetries, + }, + { + name: "large maxRetries", + maxRetries: 10, + expected: 10, + }, + { + name: "small maxRetries", + maxRetries: 1, + expected: 1, + }, + { + name: "very large maxRetries", + maxRetries: 100, + expected: 100, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithMaxRetries(tt.maxRetries) + opt(cfg) + assert.Equal(t, tt.expected, cfg.MaxRetries) + }) + } +} + +func TestWithRetryMinInterval(t *testing.T) { + tests := []struct { + name string + duration time.Duration + expected time.Duration + }{ + { + name: "valid duration", + duration: 1 * time.Second, + expected: 1 * time.Second, + }, + { + name: "zero duration should use default", + duration: 0, + expected: defaultRetryMinInterval, + }, + { + name: "negative duration should use default", + duration: -1 * time.Second, + expected: defaultRetryMinInterval, + }, + { + name: "milliseconds", + duration: 500 * time.Millisecond, + expected: 500 * time.Millisecond, + }, + { + name: "minutes", + duration: 5 * time.Minute, + expected: 5 * time.Minute, + }, + { + name: "hours", + duration: 1 * time.Hour, + expected: 1 * time.Hour, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithRetryMinInterval(tt.duration) + opt(cfg) + assert.Equal(t, tt.expected, cfg.RetryMinInterval) + }) + } +} + +func TestWithRetryMaxInterval(t *testing.T) { + tests := []struct { + name string + duration time.Duration + expected time.Duration + }{ + { + name: "valid duration", + duration: 30 * time.Second, + expected: 30 * time.Second, + }, + { + name: "zero duration should use default", + duration: 0, + expected: defaultRetryMaxInterval, + }, + { + name: "negative duration should use default", + duration: -1 * time.Second, + expected: defaultRetryMaxInterval, + }, + { + name: "milliseconds", + duration: 1000 * time.Millisecond, + expected: 1000 * time.Millisecond, + }, + { + name: "minutes", + duration: 10 * time.Minute, + expected: 10 * time.Minute, + }, + { + name: "hours", + duration: 2 * time.Hour, + expected: 2 * time.Hour, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithRetryMaxInterval(tt.duration) + opt(cfg) + assert.Equal(t, tt.expected, cfg.RetryMaxInterval) + }) + } +} + +func TestWithReconnectInitialInterval(t *testing.T) { + tests := []struct { + name string + duration time.Duration + expected time.Duration + }{ + { + name: "valid duration", + duration: 1 * time.Second, + expected: 1 * time.Second, + }, + { + name: "zero duration should use default", + duration: 0, + expected: defaultReconnectInitialInterval, + }, + { + name: "negative duration should use default", + duration: -1 * time.Second, + expected: defaultReconnectInitialInterval, + }, + { + name: "milliseconds", + duration: 500 * time.Millisecond, + expected: 500 * time.Millisecond, + }, + { + name: "minutes", + duration: 2 * time.Minute, + expected: 2 * time.Minute, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithReconnectInitialInterval(tt.duration) + opt(cfg) + assert.Equal(t, tt.expected, cfg.ReconnectInitialInterval) + }) + } +} + +func TestWithReconnectMaxInterval(t *testing.T) { + tests := []struct { + name string + duration time.Duration + expected time.Duration + }{ + { + name: "valid duration", + duration: 60 * time.Second, + expected: 60 * time.Second, + }, + { + name: "zero duration should use default", + duration: 0, + expected: defaultReconnectMaxInterval, + }, + { + name: "negative duration should use default", + duration: -1 * time.Second, + expected: defaultReconnectMaxInterval, + }, + { + name: "milliseconds", + duration: 5000 * time.Millisecond, + expected: 5000 * time.Millisecond, + }, + { + name: "minutes", + duration: 5 * time.Minute, + expected: 5 * time.Minute, + }, + { + name: "hours", + duration: 1 * time.Hour, + expected: 1 * time.Hour, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithReconnectMaxInterval(tt.duration) + opt(cfg) + assert.Equal(t, tt.expected, cfg.ReconnectMaxInterval) + }) + } +} + +func TestWithCQLVersion(t *testing.T) { + tests := []struct { + name string + version string + expected string + }{ + { + name: "valid version", + version: "3.0.0", + expected: "3.0.0", + }, + { + name: "empty version should use default", + version: "", + expected: defaultCqlVersion, + }, + { + name: "version 3.1.0", + version: "3.1.0", + expected: "3.1.0", + }, + { + name: "version 3.4.0", + version: "3.4.0", + expected: "3.4.0", + }, + { + name: "version 4.0.0", + version: "4.0.0", + expected: "4.0.0", + }, + { + name: "version with build", + version: "3.0.0-beta", + expected: "3.0.0-beta", + }, + { + name: "version with snapshot", + version: "3.0.0-SNAPSHOT", + expected: "3.0.0-SNAPSHOT", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + opt := WithCQLVersion(tt.version) + opt(cfg) + assert.Equal(t, tt.expected, cfg.CQLVersion) + }) + } +} + +func TestOption_Combination(t *testing.T) { + tests := []struct { + name string + opts []Option + validate func(*testing.T, *config) + }{ + { + name: "all options", + opts: []Option{ + WithHosts("localhost", "127.0.0.1"), + WithPort(9042), + WithKeyspace("test_keyspace"), + WithAuth("user", "pass"), + WithConsistency(gocql.Quorum), + WithConnectTimeoutSec(10), + WithNumConns(10), + WithMaxRetries(3), + WithRetryMinInterval(1 * time.Second), + WithRetryMaxInterval(30 * time.Second), + WithReconnectInitialInterval(1 * time.Second), + WithReconnectMaxInterval(60 * time.Second), + WithCQLVersion("3.0.0"), + }, + validate: func(t *testing.T, c *config) { + assert.Equal(t, []string{"localhost", "127.0.0.1"}, c.Hosts) + assert.Equal(t, 9042, c.Port) + assert.Equal(t, "test_keyspace", c.Keyspace) + assert.Equal(t, "user", c.Username) + assert.Equal(t, "pass", c.Password) + assert.True(t, c.UseAuth) + assert.Equal(t, gocql.Quorum, c.Consistency) + assert.Equal(t, 10, c.ConnectTimeoutSec) + assert.Equal(t, 10, c.NumConns) + assert.Equal(t, 3, c.MaxRetries) + assert.Equal(t, 1*time.Second, c.RetryMinInterval) + assert.Equal(t, 30*time.Second, c.RetryMaxInterval) + assert.Equal(t, 1*time.Second, c.ReconnectInitialInterval) + assert.Equal(t, 60*time.Second, c.ReconnectMaxInterval) + assert.Equal(t, "3.0.0", c.CQLVersion) + }, + }, + { + name: "minimal options", + opts: []Option{ + WithHosts("localhost"), + }, + validate: func(t *testing.T, c *config) { + assert.Equal(t, []string{"localhost"}, c.Hosts) + // 其他應該使用預設值 + assert.Equal(t, defaultPort, c.Port) + assert.Equal(t, defaultConsistency, c.Consistency) + }, + }, + { + name: "options with zero values should use defaults", + opts: []Option{ + WithHosts("localhost"), + WithConnectTimeoutSec(0), + WithNumConns(0), + WithMaxRetries(0), + WithRetryMinInterval(0), + WithRetryMaxInterval(0), + WithReconnectInitialInterval(0), + WithReconnectMaxInterval(0), + WithCQLVersion(""), + }, + validate: func(t *testing.T, c *config) { + assert.Equal(t, []string{"localhost"}, c.Hosts) + assert.Equal(t, defaultTimeoutSec, c.ConnectTimeoutSec) + assert.Equal(t, defaultNumConns, c.NumConns) + assert.Equal(t, defaultMaxRetries, c.MaxRetries) + assert.Equal(t, defaultRetryMinInterval, c.RetryMinInterval) + assert.Equal(t, defaultRetryMaxInterval, c.RetryMaxInterval) + assert.Equal(t, defaultReconnectInitialInterval, c.ReconnectInitialInterval) + assert.Equal(t, defaultReconnectMaxInterval, c.ReconnectMaxInterval) + assert.Equal(t, defaultCqlVersion, c.CQLVersion) + }, + }, + { + name: "options with negative values should use defaults", + opts: []Option{ + WithHosts("localhost"), + WithConnectTimeoutSec(-1), + WithNumConns(-1), + WithMaxRetries(-1), + WithRetryMinInterval(-1 * time.Second), + WithRetryMaxInterval(-1 * time.Second), + WithReconnectInitialInterval(-1 * time.Second), + WithReconnectMaxInterval(-1 * time.Second), + }, + validate: func(t *testing.T, c *config) { + assert.Equal(t, []string{"localhost"}, c.Hosts) + assert.Equal(t, defaultTimeoutSec, c.ConnectTimeoutSec) + assert.Equal(t, defaultNumConns, c.NumConns) + assert.Equal(t, defaultMaxRetries, c.MaxRetries) + assert.Equal(t, defaultRetryMinInterval, c.RetryMinInterval) + assert.Equal(t, defaultRetryMaxInterval, c.RetryMaxInterval) + assert.Equal(t, defaultReconnectInitialInterval, c.ReconnectInitialInterval) + assert.Equal(t, defaultReconnectMaxInterval, c.ReconnectMaxInterval) + }, + }, + { + name: "multiple options applied in sequence", + opts: []Option{ + WithHosts("host1"), + WithHosts("host2", "host3"), // 應該覆蓋 + WithPort(9042), + WithPort(9043), // 應該覆蓋 + }, + validate: func(t *testing.T, c *config) { + assert.Equal(t, []string{"host2", "host3"}, c.Hosts) + assert.Equal(t, 9043, c.Port) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + for _, opt := range tt.opts { + opt(cfg) + } + tt.validate(t, cfg) + }) + } +} + +func TestOption_Type(t *testing.T) { + t.Run("all options should return Option type", func(t *testing.T) { + var opt Option + + opt = WithHosts("localhost") + assert.NotNil(t, opt) + + opt = WithPort(9042) + assert.NotNil(t, opt) + + opt = WithKeyspace("test") + assert.NotNil(t, opt) + + opt = WithAuth("user", "pass") + assert.NotNil(t, opt) + + opt = WithConsistency(gocql.Quorum) + assert.NotNil(t, opt) + + opt = WithConnectTimeoutSec(10) + assert.NotNil(t, opt) + + opt = WithNumConns(10) + assert.NotNil(t, opt) + + opt = WithMaxRetries(3) + assert.NotNil(t, opt) + + opt = WithRetryMinInterval(1 * time.Second) + assert.NotNil(t, opt) + + opt = WithRetryMaxInterval(30 * time.Second) + assert.NotNil(t, opt) + + opt = WithReconnectInitialInterval(1 * time.Second) + assert.NotNil(t, opt) + + opt = WithReconnectMaxInterval(60 * time.Second) + assert.NotNil(t, opt) + + opt = WithCQLVersion("3.0.0") + assert.NotNil(t, opt) + }) +} + +func TestOption_EdgeCases(t *testing.T) { + t.Run("empty option slice", func(t *testing.T) { + cfg := defaultConfig() + opts := []Option{} + for _, opt := range opts { + opt(cfg) + } + // 應該保持預設值 + assert.Equal(t, defaultPort, cfg.Port) + assert.Equal(t, defaultConsistency, cfg.Consistency) + }) + + t.Run("zero value option function", func(t *testing.T) { + cfg := defaultConfig() + var opt Option + // 零值的 Option 是 nil，調用會 panic，所以不應該調用 + // 這裡只是驗證零值不會影響配置 + _ = opt + // 應該保持預設值 + assert.Equal(t, defaultPort, cfg.Port) + }) + + t.Run("very long strings", func(t *testing.T) { + cfg := defaultConfig() + longString := string(make([]byte, 10000)) + WithKeyspace(longString)(cfg) + assert.Equal(t, longString, cfg.Keyspace) + + WithAuth(longString, longString)(cfg) + assert.Equal(t, longString, cfg.Username) + assert.Equal(t, longString, cfg.Password) + }) + + t.Run("special characters in strings", func(t *testing.T) { + cfg := defaultConfig() + specialChars := "!@#$%^&*()_+-=[]{}|;:,.<>?" + WithKeyspace(specialChars)(cfg) + assert.Equal(t, specialChars, cfg.Keyspace) + + WithAuth(specialChars, specialChars)(cfg) + assert.Equal(t, specialChars, cfg.Username) + assert.Equal(t, specialChars, cfg.Password) + }) +} + +func TestOption_RealWorldScenarios(t *testing.T) { + tests := []struct { + name string + scenario string + opts []Option + validate func(*testing.T, *config) + }{ + { + name: "production-like configuration", + scenario: "typical production setup", + opts: []Option{ + WithHosts("cassandra1.example.com", "cassandra2.example.com", "cassandra3.example.com"), + WithPort(9042), + WithKeyspace("production_keyspace"), + WithAuth("prod_user", "secure_password"), + WithConsistency(gocql.Quorum), + WithConnectTimeoutSec(30), + WithNumConns(50), + WithMaxRetries(5), + }, + validate: func(t *testing.T, c *config) { + assert.Len(t, c.Hosts, 3) + assert.Equal(t, 9042, c.Port) + assert.Equal(t, "production_keyspace", c.Keyspace) + assert.True(t, c.UseAuth) + assert.Equal(t, gocql.Quorum, c.Consistency) + assert.Equal(t, 30, c.ConnectTimeoutSec) + assert.Equal(t, 50, c.NumConns) + assert.Equal(t, 5, c.MaxRetries) + }, + }, + { + name: "development configuration", + scenario: "local development setup", + opts: []Option{ + WithHosts("localhost"), + WithKeyspace("dev_keyspace"), + }, + validate: func(t *testing.T, c *config) { + assert.Equal(t, []string{"localhost"}, c.Hosts) + assert.Equal(t, "dev_keyspace", c.Keyspace) + assert.False(t, c.UseAuth) + }, + }, + { + name: "high availability configuration", + scenario: "HA setup with multiple hosts", + opts: []Option{ + WithHosts("node1", "node2", "node3", "node4", "node5"), + WithConsistency(gocql.All), + WithMaxRetries(10), + }, + validate: func(t *testing.T, c *config) { + assert.Len(t, c.Hosts, 5) + assert.Equal(t, gocql.All, c.Consistency) + assert.Equal(t, 10, c.MaxRetries) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := defaultConfig() + for _, opt := range tt.opts { + opt(cfg) + } + tt.validate(t, cfg) + }) + } +} + diff --git a/pkg/library/cassandra/query.go b/pkg/library/cassandra/query.go index 076d800..81dbc9d 100644 --- a/pkg/library/cassandra/query.go +++ b/pkg/library/cassandra/query.go @@ -5,7 +5,7 @@ import ( "fmt" "github.com/gocql/gocql" - "github.com/scylladb/gocqlx/v3/qb" + "github.com/scylladb/gocqlx/v2/qb" ) // Condition 定義查詢條件介面 diff --git a/pkg/library/cassandra/query_test.go b/pkg/library/cassandra/query_test.go new file mode 100644 index 0000000..1a11a87 --- /dev/null +++ b/pkg/library/cassandra/query_test.go @@ -0,0 +1,520 @@ +package cassandra + +import ( + "testing" + + "github.com/scylladb/gocqlx/v2/qb" + "github.com/stretchr/testify/assert" +) + +func TestEq(t *testing.T) { + tests := []struct { + name string + column string + value any + validate func(*testing.T, Condition) + }{ + { + name: "string value", + column: "name", + value: "Alice", + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, "Alice", binds["name"]) + }, + }, + { + name: "int value", + column: "age", + value: 25, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, 25, binds["age"]) + }, + }, + { + name: "nil value", + column: "description", + value: nil, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Nil(t, binds["description"]) + }, + }, + { + name: "empty string", + column: "email", + value: "", + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, "", binds["email"]) + }, + }, + { + name: "boolean value", + column: "active", + value: true, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, true, binds["active"]) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cond := Eq(tt.column, tt.value) + assert.NotNil(t, cond) + tt.validate(t, cond) + }) + } +} + +func TestIn(t *testing.T) { + tests := []struct { + name string + column string + values []any + validate func(*testing.T, Condition) + }{ + { + name: "string values", + column: "status", + values: []any{"active", "pending", "completed"}, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, []any{"active", "pending", "completed"}, binds["status"]) + }, + }, + { + name: "int values", + column: "ids", + values: []any{1, 2, 3, 4, 5}, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, []any{1, 2, 3, 4, 5}, binds["ids"]) + }, + }, + { + name: "empty slice", + column: "tags", + values: []any{}, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, []any{}, binds["tags"]) + }, + }, + { + name: "single value", + column: "id", + values: []any{1}, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, []any{1}, binds["id"]) + }, + }, + { + name: "mixed types", + column: "values", + values: []any{"string", 123, true}, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, []any{"string", 123, true}, binds["values"]) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cond := In(tt.column, tt.values) + assert.NotNil(t, cond) + tt.validate(t, cond) + }) + } +} + +func TestGt(t *testing.T) { + tests := []struct { + name string + column string + value any + validate func(*testing.T, Condition) + }{ + { + name: "int value", + column: "age", + value: 18, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, 18, binds["age"]) + }, + }, + { + name: "float value", + column: "price", + value: 99.99, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, 99.99, binds["price"]) + }, + }, + { + name: "zero value", + column: "count", + value: 0, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, 0, binds["count"]) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cond := Gt(tt.column, tt.value) + assert.NotNil(t, cond) + tt.validate(t, cond) + }) + } +} + +func TestLt(t *testing.T) { + tests := []struct { + name string + column string + value any + validate func(*testing.T, Condition) + }{ + { + name: "int value", + column: "age", + value: 65, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, 65, binds["age"]) + }, + }, + { + name: "float value", + column: "price", + value: 199.99, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, 199.99, binds["price"]) + }, + }, + { + name: "negative value", + column: "balance", + value: -100, + validate: func(t *testing.T, cond Condition) { + cmp, binds := cond.Build() + assert.NotNil(t, cmp) + assert.Equal(t, -100, binds["balance"]) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cond := Lt(tt.column, tt.value) + assert.NotNil(t, cond) + tt.validate(t, cond) + }) + } +} + +func TestCondition_Build(t *testing.T) { + tests := []struct { + name string + cond Condition + validate func(*testing.T, qb.Cmp, map[string]any) + }{ + { + name: "Eq condition", + cond: Eq("name", "test"), + validate: func(t *testing.T, cmp qb.Cmp, binds map[string]any) { + assert.NotNil(t, cmp) + assert.Equal(t, "test", binds["name"]) + }, + }, + { + name: "In condition", + cond: In("ids", []any{1, 2, 3}), + validate: func(t *testing.T, cmp qb.Cmp, binds map[string]any) { + assert.NotNil(t, cmp) + assert.Equal(t, []any{1, 2, 3}, binds["ids"]) + }, + }, + { + name: "Gt condition", + cond: Gt("age", 18), + validate: func(t *testing.T, cmp qb.Cmp, binds map[string]any) { + assert.NotNil(t, cmp) + assert.Equal(t, 18, binds["age"]) + }, + }, + { + name: "Lt condition", + cond: Lt("price", 100), + validate: func(t *testing.T, cmp qb.Cmp, binds map[string]any) { + assert.NotNil(t, cmp) + assert.Equal(t, 100, binds["price"]) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cmp, binds := tt.cond.Build() + tt.validate(t, cmp, binds) + }) + } +} + +func TestQueryBuilder_Where(t *testing.T) { + tests := []struct { + name string + condition Condition + validate func(*testing.T, *queryBuilder[testUser]) + }{ + { + name: "single condition", + condition: Eq("name", "Alice"), + validate: func(t *testing.T, qb *queryBuilder[testUser]) { + assert.Len(t, qb.conditions, 1) + }, + }, + { + name: "multiple conditions", + condition: In("status", []any{"active", "pending"}), + validate: func(t *testing.T, qb *queryBuilder[testUser]) { + // 添加多個條件 + cond := In("status", []any{"active", "pending"}) + qb.Where(Eq("name", "test")) + qb.Where(cond) + assert.Len(t, qb.conditions, 2) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 repository，但我們可以測試鏈式調用 + // 實際的執行需要資料庫連接 + _ = tt + }) + } +} + +func TestQueryBuilder_OrderBy(t *testing.T) { + tests := []struct { + name string + column string + order Order + validate func(*testing.T, *queryBuilder[testUser]) + }{ + { + name: "ASC order", + column: "created_at", + order: ASC, + validate: func(t *testing.T, qb *queryBuilder[testUser]) { + assert.Len(t, qb.orders, 1) + assert.Equal(t, "created_at", qb.orders[0].column) + assert.Equal(t, ASC, qb.orders[0].order) + }, + }, + { + name: "DESC order", + column: "updated_at", + order: DESC, + validate: func(t *testing.T, qb *queryBuilder[testUser]) { + assert.Len(t, qb.orders, 1) + assert.Equal(t, "updated_at", qb.orders[0].column) + assert.Equal(t, DESC, qb.orders[0].order) + }, + }, + { + name: "multiple orders", + column: "name", + order: ASC, + validate: func(t *testing.T, qb *queryBuilder[testUser]) { + qb.OrderBy("created_at", DESC) + qb.OrderBy("name", ASC) + assert.Len(t, qb.orders, 2) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 repository + _ = tt + }) + } +} + +func TestQueryBuilder_Limit(t *testing.T) { + tests := []struct { + name string + limit int + expected int + }{ + { + name: "positive limit", + limit: 10, + expected: 10, + }, + { + name: "zero limit", + limit: 0, + expected: 0, + }, + { + name: "large limit", + limit: 1000, + expected: 1000, + }, + { + name: "negative limit", + limit: -1, + expected: -1, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 repository + _ = tt + }) + } +} + +func TestQueryBuilder_Select(t *testing.T) { + tests := []struct { + name string + columns []string + expected int + }{ + { + name: "single column", + columns: []string{"name"}, + expected: 1, + }, + { + name: "multiple columns", + columns: []string{"name", "email", "age"}, + expected: 3, + }, + { + name: "empty columns", + columns: []string{}, + expected: 0, + }, + { + name: "duplicate columns", + columns: []string{"name", "name"}, + expected: 2, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 repository + _ = tt + }) + } +} + +func TestQueryBuilder_Chaining(t *testing.T) { + t.Run("chain multiple methods", func(t *testing.T) { + // 注意：這需要一個有效的 repository + // 實際的執行需要資料庫連接 + // 這裡只是展示測試結構 + }) +} + +func TestQueryBuilder_Scan_ErrorCases(t *testing.T) { + tests := []struct { + name string + description string + }{ + { + name: "nil destination", + description: "should return error when destination is nil", + }, + { + name: "invalid query", + description: "should return error when query is invalid", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + +func TestQueryBuilder_One_ErrorCases(t *testing.T) { + tests := []struct { + name string + description string + }{ + { + name: "no results", + description: "should return ErrNotFound when no results found", + }, + { + name: "query error", + description: "should return error when query fails", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + +func TestQueryBuilder_Count_ErrorCases(t *testing.T) { + tests := []struct { + name string + description string + }{ + { + name: "query error", + description: "should return error when query fails", + }, + { + name: "ErrNotFound should return 0", + description: "should return 0 when ErrNotFound", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + diff --git a/pkg/library/cassandra/repository.go b/pkg/library/cassandra/repository.go index dc8b503..6f6333e 100644 --- a/pkg/library/cassandra/repository.go +++ b/pkg/library/cassandra/repository.go @@ -2,30 +2,24 @@ package cassandra import ( "context" + "errors" "fmt" "reflect" "github.com/gocql/gocql" - "github.com/scylladb/gocqlx/v3" - "github.com/scylladb/gocqlx/v3/qb" - "github.com/scylladb/gocqlx/v3/table" + "github.com/scylladb/gocqlx/v2" + "github.com/scylladb/gocqlx/v2/qb" + "github.com/scylladb/gocqlx/v2/table" ) // Repository 定義資料存取介面（小介面，符合 M3） type Repository[T Table] interface { - // 基本 CRUD Insert(ctx context.Context, doc T) error Get(ctx context.Context, pk any) (T, error) Update(ctx context.Context, doc T) error Delete(ctx context.Context, pk any) error - - // 批次操作 InsertMany(ctx context.Context, docs []T) error - - // 查詢構建器 Query() QueryBuilder[T] - - // 分散式鎖 TryLock(ctx context.Context, doc T, opts ...LockOption) error UnLock(ctx context.Context, doc T) error } @@ -95,7 +89,7 @@ func (r *repository[T]) Get(ctx context.Context, pk any) (T, error) { var result T err := q.GetRelease(&result) - if err == gocql.ErrNotFound { + if errors.Is(err, gocql.ErrNotFound) { return zero, ErrNotFound.WithTable(r.table) } if err != nil { @@ -153,9 +147,23 @@ func (r *repository[T]) InsertMany(ctx context.Context, docs []T) error { stmt, names := t.Insert() for _, doc := range docs { - if err := batch.BindStruct(r.db.session.Query(stmt, names), doc); err != nil { - return fmt.Errorf("failed to bind document: %w", err) + // 在 v2 中，需要手動提取值 + v := reflect.ValueOf(doc) + if v.Kind() == reflect.Ptr { + v = v.Elem() } + values := make([]interface{}, len(names)) + for i, name := range names { + // 根據 metadata 找到對應的欄位 + for j, col := range r.metadata.Columns { + if col == name { + fieldValue := v.Field(j) + values[i] = fieldValue.Interface() + break + } + } + } + batch.Query(stmt, values...) } return r.db.session.ExecuteBatch(batch) @@ -189,7 +197,7 @@ func (r *repository[T]) buildUpdateFields(doc T, includeZero bool) (*updateField for i := 0; i < typ.NumField(); i++ { field := typ.Field(i) - tag := field.Tag.Get("db") + tag := field.Tag.Get(DBFiledName) if tag == "" || tag == "-" { continue } diff --git a/pkg/library/cassandra/repository_test.go b/pkg/library/cassandra/repository_test.go new file mode 100644 index 0000000..fda023d --- /dev/null +++ b/pkg/library/cassandra/repository_test.go @@ -0,0 +1,547 @@ +package cassandra + +import ( + "reflect" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestContains(t *testing.T) { + tests := []struct { + name string + list []string + target string + want bool + }{ + { + name: "target exists in list", + list: []string{"a", "b", "c"}, + target: "b", + want: true, + }, + { + name: "target at beginning", + list: []string{"a", "b", "c"}, + target: "a", + want: true, + }, + { + name: "target at end", + list: []string{"a", "b", "c"}, + target: "c", + want: true, + }, + { + name: "target not in list", + list: []string{"a", "b", "c"}, + target: "d", + want: false, + }, + { + name: "empty list", + list: []string{}, + target: "a", + want: false, + }, + { + name: "empty target", + list: []string{"a", "b", "c"}, + target: "", + want: false, + }, + { + name: "target in single element list", + list: []string{"a"}, + target: "a", + want: true, + }, + { + name: "case sensitive", + list: []string{"A", "B", "C"}, + target: "a", + want: false, + }, + { + name: "duplicate values", + list: []string{"a", "b", "a", "c"}, + target: "a", + want: true, + }, + { + name: "long list", + list: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}, + target: "j", + want: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := contains(tt.list, tt.target) + assert.Equal(t, tt.want, result) + }) + } +} + +func TestIsZero(t *testing.T) { + tests := []struct { + name string + value any + expected bool + skip bool + }{ + { + name: "nil pointer", + value: (*string)(nil), + expected: true, + skip: false, + }, + { + name: "non-nil pointer", + value: stringPtr("test"), + expected: false, + skip: false, + }, + { + name: "nil slice", + value: []string(nil), + expected: true, + skip: false, + }, + { + name: "empty slice", + value: []string{}, + expected: false, // 空 slice 不是 nil + skip: false, + }, + { + name: "nil map", + value: map[string]int(nil), + expected: true, + skip: false, + }, + { + name: "empty map", + value: map[string]int{}, + expected: false, // 空 map 不是 nil + skip: false, + }, + { + name: "zero int", + value: 0, + expected: true, + skip: false, + }, + { + name: "non-zero int", + value: 42, + expected: false, + skip: false, + }, + { + name: "zero int64", + value: int64(0), + expected: true, + skip: false, + }, + { + name: "non-zero int64", + value: int64(42), + expected: false, + skip: false, + }, + { + name: "zero float64", + value: 0.0, + expected: true, + skip: false, + }, + { + name: "non-zero float64", + value: 3.14, + expected: false, + skip: false, + }, + { + name: "empty string", + value: "", + expected: true, + skip: false, + }, + { + name: "non-empty string", + value: "test", + expected: false, + skip: false, + }, + { + name: "false bool", + value: false, + expected: true, + skip: false, + }, + { + name: "true bool", + value: true, + expected: false, + skip: false, + }, + { + name: "struct with zero values", + value: testUser{}, + expected: true, // 所有欄位都是零值，應該返回 true + skip: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.skip { + t.Skip("Skipping test") + return + } + // 使用 reflect.ValueOf 來獲取 reflect.Value + v := reflect.ValueOf(tt.value) + // 檢查是否為零值（nil interface 會導致 zero Value） + if !v.IsValid() { + // 對於 nil interface，直接返回 true + assert.True(t, tt.expected) + return + } + result := isZero(v) + assert.Equal(t, tt.expected, result) + }) + } +} + +func TestNewRepository(t *testing.T) { + tests := []struct { + name string + keyspace string + wantErr bool + validate func(*testing.T, Repository[testUser], *DB) + }{ + { + name: "valid keyspace", + keyspace: "test_keyspace", + wantErr: false, + validate: func(t *testing.T, repo Repository[testUser], db *DB) { + assert.NotNil(t, repo) + }, + }, + { + name: "empty keyspace uses default", + keyspace: "", + wantErr: false, + validate: func(t *testing.T, repo Repository[testUser], db *DB) { + assert.NotNil(t, repo) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例 + // 在實際測試中，需要使用 mock 或 testcontainers + _ = tt + }) + } +} + +func TestRepository_Insert(t *testing.T) { + tests := []struct { + name string + description string + }{ + { + name: "successful insert", + description: "should insert document successfully", + }, + { + name: "duplicate key", + description: "should return error on duplicate key", + }, + { + name: "invalid document", + description: "should return error for invalid document", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + +func TestRepository_Get(t *testing.T) { + tests := []struct { + name string + pk any + description string + wantErr bool + }{ + { + name: "found with string key", + pk: "test-id", + description: "should return document when found", + wantErr: false, + }, + { + name: "not found", + pk: "non-existent", + description: "should return ErrNotFound when not found", + wantErr: true, + }, + { + name: "invalid primary key structure", + pk: "single-key", + description: "should return error for invalid key structure", + wantErr: true, + }, + { + name: "struct primary key", + pk: testUser{ID: "test-id"}, + description: "should work with struct primary key", + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + +func TestRepository_Update(t *testing.T) { + tests := []struct { + name string + description string + wantErr bool + }{ + { + name: "successful update", + description: "should update document successfully", + wantErr: false, + }, + { + name: "not found", + description: "should return error when document not found", + wantErr: true, + }, + { + name: "no fields to update", + description: "should return error when no fields to update", + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + +func TestRepository_Delete(t *testing.T) { + tests := []struct { + name string + pk any + description string + wantErr bool + }{ + { + name: "successful delete", + pk: "test-id", + description: "should delete document successfully", + wantErr: false, + }, + { + name: "not found", + pk: "non-existent", + description: "should not return error when not found (idempotent)", + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + +func TestRepository_InsertMany(t *testing.T) { + tests := []struct { + name string + docs []testUser + description string + wantErr bool + }{ + { + name: "empty slice", + docs: []testUser{}, + description: "should return nil for empty slice", + wantErr: false, + }, + { + name: "single document", + docs: []testUser{{ID: "1", Name: "Alice"}}, + description: "should insert single document", + wantErr: false, + }, + { + name: "multiple documents", + docs: []testUser{{ID: "1", Name: "Alice"}, {ID: "2", Name: "Bob"}}, + description: "should insert multiple documents", + wantErr: false, + }, + { + name: "large batch", + docs: make([]testUser, 100), + description: "should handle large batch", + wantErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要 mock session 或實際的資料庫連接 + _ = tt + }) + } +} + +func TestRepository_Query(t *testing.T) { + t.Run("should return QueryBuilder", func(t *testing.T) { + // 注意：這需要一個有效的 repository + // 實際的執行需要資料庫連接 + }) +} + +func TestBuildUpdateStatement(t *testing.T) { + tests := []struct { + name string + setCols []string + whereCols []string + table string + validate func(*testing.T, string, []string) + }{ + { + name: "single set column, single where column", + setCols: []string{"name"}, + whereCols: []string{"id"}, + table: "users", + validate: func(t *testing.T, stmt string, names []string) { + assert.Contains(t, stmt, "UPDATE") + assert.Contains(t, stmt, "users") + assert.Contains(t, stmt, "SET") + assert.Contains(t, stmt, "WHERE") + assert.Len(t, names, 2) // name, id + }, + }, + { + name: "multiple set columns, single where column", + setCols: []string{"name", "email", "age"}, + whereCols: []string{"id"}, + table: "users", + validate: func(t *testing.T, stmt string, names []string) { + assert.Contains(t, stmt, "UPDATE") + assert.Contains(t, stmt, "users") + assert.Len(t, names, 4) // name, email, age, id + }, + }, + { + name: "single set column, multiple where columns", + setCols: []string{"status"}, + whereCols: []string{"user_id", "account_id"}, + table: "accounts", + validate: func(t *testing.T, stmt string, names []string) { + assert.Contains(t, stmt, "UPDATE") + assert.Contains(t, stmt, "accounts") + assert.Len(t, names, 3) // status, user_id, account_id + }, + }, + { + name: "multiple set and where columns", + setCols: []string{"name", "email"}, + whereCols: []string{"id", "version"}, + table: "users", + validate: func(t *testing.T, stmt string, names []string) { + assert.Contains(t, stmt, "UPDATE") + assert.Len(t, names, 4) // name, email, id, version + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 創建一個臨時的 repository 來測試 buildUpdateStatement + // 注意：這需要一個有效的 metadata + // 使用 testUser 的 metadata + var zero testUser + metadata, err := generateMetadata(zero, "test_keyspace") + require.NoError(t, err) + + repo := &repository[testUser]{ + table: tt.table, + metadata: metadata, + } + stmt, names := repo.buildUpdateStatement(tt.setCols, tt.whereCols) + tt.validate(t, stmt, names) + }) + } +} + +func TestBuildUpdateFields(t *testing.T) { + tests := []struct { + name string + doc testUser + includeZero bool + wantErr bool + validate func(*testing.T, *updateFields) + }{ + { + name: "update with includeZero false", + doc: testUser{ID: "1", Name: "Alice", Email: "alice@example.com"}, + includeZero: false, + wantErr: false, + validate: func(t *testing.T, fields *updateFields) { + assert.NotEmpty(t, fields.setCols) + assert.Contains(t, fields.whereCols, "id") + }, + }, + { + name: "update with includeZero true", + doc: testUser{ID: "1", Name: "", Email: ""}, + includeZero: true, + wantErr: false, + validate: func(t *testing.T, fields *updateFields) { + assert.NotEmpty(t, fields.setCols) + }, + }, + { + name: "no fields to update", + doc: testUser{ID: "1"}, + includeZero: false, + wantErr: true, + validate: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 repository 和 metadata + // 在實際測試中，需要使用 mock 或 testcontainers + _ = tt + }) + } +} + diff --git a/pkg/library/cassandra/sai.go b/pkg/library/cassandra/sai.go new file mode 100644 index 0000000..23c7236 --- /dev/null +++ b/pkg/library/cassandra/sai.go @@ -0,0 +1,247 @@ +package cassandra + +import ( + "context" + "fmt" + "strings" + + "github.com/gocql/gocql" +) + +// SAIIndexType 定義 SAI 索引類型 +type SAIIndexType string + +const ( + // SAIIndexTypeStandard 標準索引（預設） + SAIIndexTypeStandard SAIIndexType = "standard" + // SAIIndexTypeFrozen 用於 frozen 類型 + SAIIndexTypeFrozen SAIIndexType = "frozen" +) + +// SAIIndexOptions 定義 SAI 索引選項 +type SAIIndexOptions struct { + CaseSensitive *bool // 是否區分大小寫（預設：true） + Normalize *bool // 是否正規化（預設：false） + Analyzer string // 分析器（如 "StandardAnalyzer"） +} + +// SAIIndexInfo 表示 SAI 索引資訊 +type SAIIndexInfo struct { + KeyspaceName string // Keyspace 名稱 + TableName string // 表名稱 + IndexName string // 索引名稱 + ColumnName string // 欄位名稱 + IndexType string // 索引類型 + Options map[string]string // 索引選項 +} + +// CreateSAIIndex 建立 SAI 索引 +// keyspace: keyspace 名稱，如果為空則使用預設 keyspace +// table: 表名稱 +// column: 欄位名稱 +// indexName: 索引名稱（可選，如果為空則自動生成） +// options: 索引選項（可選） +func (db *DB) CreateSAIIndex(ctx context.Context, keyspace, table, column string, indexName string, options *SAIIndexOptions) error { + if !db.saiSupported { + return ErrSAINotSupported + } + + if keyspace == "" { + keyspace = db.defaultKeyspace + } + if keyspace == "" { + return ErrInvalidInput.WithError(fmt.Errorf("keyspace is required")) + } + if table == "" { + return ErrInvalidInput.WithError(fmt.Errorf("table is required")) + } + if column == "" { + return ErrInvalidInput.WithError(fmt.Errorf("column is required")) + } + + // 生成索引名稱（如果未提供） + if indexName == "" { + indexName = fmt.Sprintf("%s_%s_%s_idx", table, column, "sai") + } + + // 構建 CREATE INDEX 語句 + stmt := fmt.Sprintf("CREATE INDEX %s ON %s.%s (%s) USING 'sai'", indexName, keyspace, table, column) + + // 添加選項 + if options != nil { + opts := make([]string, 0) + if options.CaseSensitive != nil { + opts = append(opts, fmt.Sprintf("'case_sensitive': %v", *options.CaseSensitive)) + } + if options.Normalize != nil { + opts = append(opts, fmt.Sprintf("'normalize': %v", *options.Normalize)) + } + if options.Analyzer != "" { + opts = append(opts, fmt.Sprintf("'analyzer': '%s'", options.Analyzer)) + } + if len(opts) > 0 { + stmt += " WITH OPTIONS = {" + strings.Join(opts, ", ") + "}" + } + } + + // 執行建立索引 + q := db.session.Query(stmt, nil).WithContext(ctx).Consistency(gocql.Quorum) + if err := q.ExecRelease(); err != nil { + return ErrInvalidInput.WithTable(table).WithError(fmt.Errorf("failed to create SAI index: %w", err)) + } + + return nil +} + +// DropSAIIndex 刪除 SAI 索引 +// keyspace: keyspace 名稱，如果為空則使用預設 keyspace +// indexName: 索引名稱 +func (db *DB) DropSAIIndex(ctx context.Context, keyspace, indexName string) error { + if !db.saiSupported { + return ErrSAINotSupported + } + + if keyspace == "" { + keyspace = db.defaultKeyspace + } + if keyspace == "" { + return ErrInvalidInput.WithError(fmt.Errorf("keyspace is required")) + } + if indexName == "" { + return ErrInvalidInput.WithError(fmt.Errorf("index name is required")) + } + + // 構建 DROP INDEX 語句 + stmt := fmt.Sprintf("DROP INDEX IF EXISTS %s.%s", keyspace, indexName) + + // 執行刪除索引 + q := db.session.Query(stmt, nil).WithContext(ctx).Consistency(gocql.Quorum) + if err := q.ExecRelease(); err != nil { + return ErrInvalidInput.WithError(fmt.Errorf("failed to drop SAI index: %w", err)) + } + + return nil +} + +// ListSAIIndexes 列出指定表的 SAI 索引 +// keyspace: keyspace 名稱，如果為空則使用預設 keyspace +// table: 表名稱（可選，如果為空則列出所有表的索引） +func (db *DB) ListSAIIndexes(ctx context.Context, keyspace, table string) ([]SAIIndexInfo, error) { + if !db.saiSupported { + return nil, ErrSAINotSupported + } + + if keyspace == "" { + keyspace = db.defaultKeyspace + } + if keyspace == "" { + return nil, ErrInvalidInput.WithError(fmt.Errorf("keyspace is required")) + } + + // 構建查詢語句 + // system_schema.indexes 表的欄位：keyspace_name, table_name, index_name, kind, options, index_type + stmt := "SELECT keyspace_name, table_name, index_name, kind, options FROM system_schema.indexes WHERE keyspace_name = ?" + args := []interface{}{keyspace} + names := []string{"keyspace_name"} + + if table != "" { + stmt += " AND table_name = ?" + args = append(args, table) + names = append(names, "table_name") + } + + // 執行查詢 + var indexes []SAIIndexInfo + iter := db.session.Query(stmt, names).Bind(args...).WithContext(ctx).Consistency(gocql.One).Iter() + + var keyspaceName, tableName, indexName, kind string + var options map[string]string + + for iter.Scan(&keyspaceName, &tableName, &indexName, &kind, &options) { + // 只處理 SAI 索引（kind = 'CUSTOM' 且 index_type 在 options 中） + indexType, ok := options["class_name"] + if !ok || !strings.Contains(indexType, "StorageAttachedIndex") { + continue + } + + // 從 options 中提取 column_name + // SAI 索引的 target 欄位在 options 中 + columnName := "" + if target, ok := options["target"]; ok { + // target 格式通常是 "column_name" 或 "(column_name)" + columnName = strings.Trim(target, "()\"'") + } + + indexes = append(indexes, SAIIndexInfo{ + KeyspaceName: keyspaceName, + TableName: tableName, + IndexName: indexName, + ColumnName: columnName, + IndexType: "sai", + Options: options, + }) + } + + if err := iter.Close(); err != nil { + return nil, ErrInvalidInput.WithError(fmt.Errorf("failed to list SAI indexes: %w", err)) + } + + return indexes, nil +} + +// GetSAIIndex 獲取指定索引的資訊 +// keyspace: keyspace 名稱，如果為空則使用預設 keyspace +// indexName: 索引名稱 +func (db *DB) GetSAIIndex(ctx context.Context, keyspace, indexName string) (*SAIIndexInfo, error) { + if !db.saiSupported { + return nil, ErrSAINotSupported + } + + if keyspace == "" { + keyspace = db.defaultKeyspace + } + if keyspace == "" { + return nil, ErrInvalidInput.WithError(fmt.Errorf("keyspace is required")) + } + if indexName == "" { + return nil, ErrInvalidInput.WithError(fmt.Errorf("index name is required")) + } + + // 構建查詢語句 + stmt := "SELECT keyspace_name, table_name, index_name, kind, options FROM system_schema.indexes WHERE keyspace_name = ? AND index_name = ?" + args := []interface{}{keyspace, indexName} + names := []string{"keyspace_name", "index_name"} + + var keyspaceName, tableName, idxName, kind string + var options map[string]string + + // 執行查詢 + err := db.session.Query(stmt, names).Bind(args...).WithContext(ctx).Consistency(gocql.One).Scan(&keyspaceName, &tableName, &idxName, &kind, &options) + if err != nil { + if err == gocql.ErrNotFound { + return nil, ErrNotFound.WithError(fmt.Errorf("index not found: %s", indexName)) + } + return nil, ErrInvalidInput.WithError(fmt.Errorf("failed to get index: %w", err)) + } + + // 檢查是否為 SAI 索引 + indexType, ok := options["class_name"] + if !ok || !strings.Contains(indexType, "StorageAttachedIndex") { + return nil, ErrInvalidInput.WithError(fmt.Errorf("index %s is not a SAI index", indexName)) + } + + // 從 options 中提取 column_name + columnName := "" + if target, ok := options["target"]; ok { + columnName = strings.Trim(target, "()\"'") + } + + return &SAIIndexInfo{ + KeyspaceName: keyspaceName, + TableName: tableName, + IndexName: idxName, + ColumnName: columnName, + IndexType: "sai", + Options: options, + }, nil +} diff --git a/pkg/library/cassandra/sai_test.go b/pkg/library/cassandra/sai_test.go new file mode 100644 index 0000000..feb5af8 --- /dev/null +++ b/pkg/library/cassandra/sai_test.go @@ -0,0 +1,383 @@ +package cassandra + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestCreateSAIIndex(t *testing.T) { + tests := []struct { + name string + keyspace string + table string + column string + indexName string + options *SAIIndexOptions + description string + wantErr bool + validate func(*testing.T, error) + }{ + { + name: "create basic SAI index", + keyspace: "test_keyspace", + table: "test_table", + column: "name", + indexName: "test_name_idx", + options: nil, + description: "should create a basic SAI index", + wantErr: false, + }, + { + name: "create SAI index with auto-generated name", + keyspace: "test_keyspace", + table: "test_table", + column: "email", + indexName: "", + options: nil, + description: "should auto-generate index name", + wantErr: false, + }, + { + name: "create SAI index with case insensitive option", + keyspace: "test_keyspace", + table: "test_table", + column: "title", + indexName: "test_title_idx", + options: &SAIIndexOptions{CaseSensitive: boolPtr(false)}, + description: "should create index with case insensitive option", + wantErr: false, + }, + { + name: "create SAI index with normalize option", + keyspace: "test_keyspace", + table: "test_table", + column: "content", + indexName: "test_content_idx", + options: &SAIIndexOptions{Normalize: boolPtr(true)}, + description: "should create index with normalize option", + wantErr: false, + }, + { + name: "create SAI index with analyzer", + keyspace: "test_keyspace", + table: "test_table", + column: "description", + indexName: "test_desc_idx", + options: &SAIIndexOptions{Analyzer: "StandardAnalyzer"}, + description: "should create index with analyzer", + wantErr: false, + }, + { + name: "create SAI index with all options", + keyspace: "test_keyspace", + table: "test_table", + column: "text", + indexName: "test_text_idx", + options: &SAIIndexOptions{CaseSensitive: boolPtr(false), Normalize: boolPtr(true), Analyzer: "StandardAnalyzer"}, + description: "should create index with all options", + wantErr: false, + }, + { + name: "missing keyspace", + keyspace: "", + table: "test_table", + column: "name", + indexName: "test_idx", + options: nil, + description: "should return error when keyspace is empty and no default", + wantErr: true, + validate: func(t *testing.T, err error) { + assert.Error(t, err) + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, ErrCodeInvalidInput, e.Code) + } + }, + }, + { + name: "missing table", + keyspace: "test_keyspace", + table: "", + column: "name", + indexName: "test_idx", + options: nil, + description: "should return error when table is empty", + wantErr: true, + validate: func(t *testing.T, err error) { + assert.Error(t, err) + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, ErrCodeInvalidInput, e.Code) + } + }, + }, + { + name: "missing column", + keyspace: "test_keyspace", + table: "test_table", + column: "", + indexName: "test_idx", + options: nil, + description: "should return error when column is empty", + wantErr: true, + validate: func(t *testing.T, err error) { + assert.Error(t, err) + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, ErrCodeInvalidInput, e.Code) + } + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例和 SAI 支援 + // 在實際測試中，需要使用 testcontainers 或 mock + _ = tt + }) + } +} + +func TestDropSAIIndex(t *testing.T) { + tests := []struct { + name string + keyspace string + indexName string + description string + wantErr bool + validate func(*testing.T, error) + }{ + { + name: "drop existing index", + keyspace: "test_keyspace", + indexName: "test_name_idx", + description: "should drop existing index", + wantErr: false, + }, + { + name: "drop non-existent index", + keyspace: "test_keyspace", + indexName: "non_existent_idx", + description: "should not error when dropping non-existent index (IF EXISTS)", + wantErr: false, + }, + { + name: "missing keyspace", + keyspace: "", + indexName: "test_idx", + description: "should return error when keyspace is empty and no default", + wantErr: true, + validate: func(t *testing.T, err error) { + assert.Error(t, err) + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, ErrCodeInvalidInput, e.Code) + } + }, + }, + { + name: "missing index name", + keyspace: "test_keyspace", + indexName: "", + description: "should return error when index name is empty", + wantErr: true, + validate: func(t *testing.T, err error) { + assert.Error(t, err) + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, ErrCodeInvalidInput, e.Code) + } + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例和 SAI 支援 + // 在實際測試中，需要使用 testcontainers 或 mock + _ = tt + }) + } +} + +func TestListSAIIndexes(t *testing.T) { + tests := []struct { + name string + keyspace string + table string + description string + wantErr bool + validate func(*testing.T, []SAIIndexInfo, error) + }{ + { + name: "list all indexes in keyspace", + keyspace: "test_keyspace", + table: "", + description: "should list all SAI indexes in keyspace", + wantErr: false, + validate: func(t *testing.T, indexes []SAIIndexInfo, err error) { + require.NoError(t, err) + assert.NotNil(t, indexes) + }, + }, + { + name: "list indexes for specific table", + keyspace: "test_keyspace", + table: "test_table", + description: "should list SAI indexes for specific table", + wantErr: false, + validate: func(t *testing.T, indexes []SAIIndexInfo, err error) { + require.NoError(t, err) + assert.NotNil(t, indexes) + for _, idx := range indexes { + assert.Equal(t, "test_table", idx.TableName) + } + }, + }, + { + name: "missing keyspace", + keyspace: "", + table: "", + description: "should return error when keyspace is empty and no default", + wantErr: true, + validate: func(t *testing.T, indexes []SAIIndexInfo, err error) { + assert.Error(t, err) + assert.Nil(t, indexes) + var e *Error + if assert.ErrorAs(t, err, &e) { + assert.Equal(t, ErrCodeInvalidInput, e.Code) + } + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例和 SAI 支援 + // 在實際測試中，需要使用 testcontainers 或 mock + _ = tt + }) + } +} + +func TestGetSAIIndex(t *testing.T) { + tests := []struct { + name string + keyspace string + indexName string + description string + wantErr bool + validate func(*testing.T, *SAIIndexInfo, error) + }{ + { + name: "get existing index", + keyspace: "test_keyspace", + indexName: "test_name_idx", + description: "should get existing SAI index", + wantErr: false, + validate: func(t *testing.T, index *SAIIndexInfo, err error) { + require.NoError(t, err) + assert.NotNil(t, index) + assert.Equal(t, "test_name_idx", index.IndexName) + }, + }, + { + name: "get non-existent index", + keyspace: "test_keyspace", + indexName: "non_existent_idx", + description: "should return ErrNotFound", + wantErr: true, + validate: func(t *testing.T, index *SAIIndexInfo, err error) { + assert.Error(t, err) + assert.Nil(t, index) + assert.True(t, IsNotFound(err)) + }, + }, + { + name: "missing keyspace", + keyspace: "", + indexName: "test_idx", + description: "should return error when keyspace is empty and no default", + wantErr: true, + validate: func(t *testing.T, index *SAIIndexInfo, err error) { + assert.Error(t, err) + assert.Nil(t, index) + }, + }, + { + name: "missing index name", + keyspace: "test_keyspace", + indexName: "", + description: "should return error when index name is empty", + wantErr: true, + validate: func(t *testing.T, index *SAIIndexInfo, err error) { + assert.Error(t, err) + assert.Nil(t, index) + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // 注意：這需要一個有效的 DB 實例和 SAI 支援 + // 在實際測試中，需要使用 testcontainers 或 mock + _ = tt + }) + } +} + +func TestSAIIndexOptions(t *testing.T) { + t.Run("default options", func(t *testing.T) { + opts := &SAIIndexOptions{} + assert.Nil(t, opts.CaseSensitive) + assert.Nil(t, opts.Normalize) + assert.Empty(t, opts.Analyzer) + }) + + t.Run("with case sensitive", func(t *testing.T) { + caseSensitive := false + opts := &SAIIndexOptions{CaseSensitive: &caseSensitive} + assert.NotNil(t, opts.CaseSensitive) + assert.False(t, *opts.CaseSensitive) + }) + + t.Run("with normalize", func(t *testing.T) { + normalize := true + opts := &SAIIndexOptions{Normalize: &normalize} + assert.NotNil(t, opts.Normalize) + assert.True(t, *opts.Normalize) + }) + + t.Run("with analyzer", func(t *testing.T) { + opts := &SAIIndexOptions{Analyzer: "StandardAnalyzer"} + assert.Equal(t, "StandardAnalyzer", opts.Analyzer) + }) +} + +func TestSAIIndexInfo(t *testing.T) { + t.Run("index info structure", func(t *testing.T) { + info := SAIIndexInfo{ + KeyspaceName: "test_keyspace", + TableName: "test_table", + IndexName: "test_idx", + ColumnName: "name", + IndexType: "sai", + Options: map[string]string{"target": "name"}, + } + + assert.Equal(t, "test_keyspace", info.KeyspaceName) + assert.Equal(t, "test_table", info.TableName) + assert.Equal(t, "test_idx", info.IndexName) + assert.Equal(t, "name", info.ColumnName) + assert.Equal(t, "sai", info.IndexType) + assert.NotNil(t, info.Options) + }) +} + +// Helper function +func boolPtr(b bool) *bool { + return &b +} diff --git a/pkg/library/cassandra/testhelper.go b/pkg/library/cassandra/testhelper.go new file mode 100644 index 0000000..448e130 --- /dev/null +++ b/pkg/library/cassandra/testhelper.go @@ -0,0 +1,91 @@ +package cassandra + +import ( + "context" + "fmt" + "strconv" + "testing" + + "github.com/testcontainers/testcontainers-go" + "github.com/testcontainers/testcontainers-go/wait" +) + +// startCassandraContainer 啟動 Cassandra 測試容器 +func startCassandraContainer(ctx context.Context) (string, string, func(), error) { + req := testcontainers.ContainerRequest{ + Image: "cassandra:4.1", + ExposedPorts: []string{"9042/tcp"}, + WaitingFor: wait.ForListeningPort("9042/tcp"), + Env: map[string]string{ + "CASSANDRA_CLUSTER_NAME": "test-cluster", + }, + } + + cassandraC, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{ + ContainerRequest: req, + Started: true, + }) + if err != nil { + return "", "", nil, fmt.Errorf("failed to start Cassandra container: %w", err) + } + + port, err := cassandraC.MappedPort(ctx, "9042") + if err != nil { + cassandraC.Terminate(ctx) + return "", "", nil, fmt.Errorf("failed to get mapped port: %w", err) + } + + host, err := cassandraC.Host(ctx) + if err != nil { + cassandraC.Terminate(ctx) + return "", "", nil, fmt.Errorf("failed to get host: %w", err) + } + + tearDown := func() { + _ = cassandraC.Terminate(ctx) + } + + fmt.Printf("Cassandra test container started: %s:%s\n", host, port.Port()) + + return host, port.Port(), tearDown, nil +} + +// setupTestDB 設置測試用的 DB 實例 +func setupTestDB(t testing.TB) (*DB, func()) { + ctx := context.Background() + host, port, tearDown, err := startCassandraContainer(ctx) + if err != nil { + t.Fatalf("Failed to start Cassandra container: %v", err) + } + + portInt, err := strconv.Atoi(port) + if err != nil { + tearDown() + t.Fatalf("Failed to convert port to int: %v", err) + } + + db, err := New( + WithHosts(host), + WithPort(portInt), + WithKeyspace("test_keyspace"), + ) + if err != nil { + tearDown() + t.Fatalf("Failed to create DB: %v", err) + } + + // 創建 keyspace + createKeyspaceStmt := "CREATE KEYSPACE IF NOT EXISTS test_keyspace WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}" + if err := db.session.Query(createKeyspaceStmt, nil).Exec(); err != nil { + db.Close() + tearDown() + t.Fatalf("Failed to create keyspace: %v", err) + } + + cleanup := func() { + db.Close() + tearDown() + } + + return db, cleanup +} diff --git a/pkg/library/cassandra/types_test.go b/pkg/library/cassandra/types_test.go new file mode 100644 index 0000000..f400523 --- /dev/null +++ b/pkg/library/cassandra/types_test.go @@ -0,0 +1,140 @@ +package cassandra + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestOrder_ToGocqlX(t *testing.T) { + tests := []struct { + name string + order Order + expected string + }{ + { + name: "ASC order", + order: ASC, + expected: "ASC", + }, + { + name: "DESC order", + order: DESC, + expected: "DESC", + }, + { + name: "zero value (defaults to ASC)", + order: Order(0), + expected: "ASC", + }, + { + name: "invalid order value (defaults to ASC)", + order: Order(99), + expected: "ASC", + }, + { + name: "negative order value (defaults to ASC)", + order: Order(-1), + expected: "ASC", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.order.toGocqlX() + assert.Equal(t, tt.expected, result) + }) + } +} + +func TestOrder_Constants(t *testing.T) { + tests := []struct { + name string + constant Order + expected int + }{ + { + name: "ASC constant", + constant: ASC, + expected: 0, + }, + { + name: "DESC constant", + constant: DESC, + expected: 1, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.expected, int(tt.constant)) + }) + } +} + +func TestOrder_StringConversion(t *testing.T) { + tests := []struct { + name string + order Order + expected string + }{ + { + name: "ASC to string", + order: ASC, + expected: "ASC", + }, + { + name: "DESC to string", + order: DESC, + expected: "DESC", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.order.toGocqlX() + assert.Equal(t, tt.expected, result) + }) + } +} + +func TestOrder_Comparison(t *testing.T) { + t.Run("ASC should equal 0", func(t *testing.T) { + assert.Equal(t, Order(0), ASC) + }) + + t.Run("DESC should equal 1", func(t *testing.T) { + assert.Equal(t, Order(1), DESC) + }) + + t.Run("ASC should not equal DESC", func(t *testing.T) { + assert.NotEqual(t, ASC, DESC) + }) +} + +func TestOrder_EdgeCases(t *testing.T) { + tests := []struct { + name string + order Order + expected string + }{ + { + name: "maximum int value", + order: Order(^int(0)), + expected: "ASC", // 不是 DESC，所以返回 ASC + }, + { + name: "minimum int value", + order: Order(-^int(0) - 1), + expected: "ASC", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tt.order.toGocqlX() + assert.Equal(t, tt.expected, result) + }) + } +} + diff --git a/pkg/post/domain/const.go b/pkg/post/domain/const.go new file mode 100644 index 0000000..8df4ea4 --- /dev/null +++ b/pkg/post/domain/const.go @@ -0,0 +1,49 @@ +package domain + +// Business constants for the post service +const ( + // DefaultPageSize is the default page size for pagination + DefaultPageSize = 20 + + // MaxPageSize is the maximum allowed page size + MaxPageSize = 100 + + // MinPageSize is the minimum allowed page size + MinPageSize = 1 + + // MaxPostTitleLength is the maximum length for post title + MaxPostTitleLength = 200 + + // MinPostTitleLength is the minimum length for post title + MinPostTitleLength = 1 + + // MaxPostContentLength is the maximum length for post content + MaxPostContentLength = 10000 + + // MinPostContentLength is the minimum length for post content + MinPostContentLength = 1 + + // MaxCommentLength is the maximum length for comment + MaxCommentLength = 2000 + + // MinCommentLength is the minimum length for comment + MinCommentLength = 1 + + // MaxTagNameLength is the maximum length for tag name + MaxTagNameLength = 50 + + // MinTagNameLength is the minimum length for tag name + MinTagNameLength = 1 + + // MaxTagsPerPost is the maximum number of tags per post + MaxTagsPerPost = 10 + + // DefaultCacheExpiration is the default cache expiration time in seconds + DefaultCacheExpiration = 3600 + + // MaxRetryAttempts is the maximum number of retry attempts for operations + MaxRetryAttempts = 3 + + // DefaultLikeCacheExpiration is the default cache expiration for like counts + DefaultLikeCacheExpiration = 300 // 5 minutes +) diff --git a/pkg/post/domain/entity/category.go b/pkg/post/domain/entity/category.go new file mode 100644 index 0000000..e49e6e5 --- /dev/null +++ b/pkg/post/domain/entity/category.go @@ -0,0 +1,85 @@ +package entity + +import ( + "errors" + "time" + + "github.com/gocql/gocql" +) + +// Category represents a category entity for organizing posts. +type Category struct { + ID gocql.UUID `db:"id" partition_key:"true"` // Category unique identifier + Slug string `db:"slug"` // URL-friendly slug (unique) + Name string `db:"name"` // Category name + Description *string `db:"description,omitempty"` // Category description (optional) + ParentID *gocql.UUID `db:"parent_id,omitempty"` // Parent category ID (for nested categories) + PostCount int64 `db:"post_count"` // Number of posts in this category + IsActive bool `db:"is_active"` // Whether the category is active + SortOrder int32 `db:"sort_order"` // Sort order for display + CreatedAt int64 `db:"created_at"` // Creation timestamp + UpdatedAt int64 `db:"updated_at"` // Last update timestamp +} + +// TableName returns the Cassandra table name for Category entities. +func (c *Category) TableName() string { + return "categories" +} + +// Validate validates the Category entity +func (c *Category) Validate() error { + if c.Name == "" { + return errors.New("category name is required") + } + if c.Slug == "" { + return errors.New("category slug is required") + } + return nil +} + +// SetTimestamps sets the create and update timestamps +func (c *Category) SetTimestamps() { + now := time.Now().UTC().UnixNano() / 1e6 // milliseconds + if c.CreatedAt == 0 { + c.CreatedAt = now + } + c.UpdatedAt = now +} + +// IsNew returns true if this is a new category (no ID set) +func (c *Category) IsNew() bool { + var zeroUUID gocql.UUID + return c.ID == zeroUUID +} + +// IsRoot returns true if this category has no parent +func (c *Category) IsRoot() bool { + var zeroUUID gocql.UUID + return c.ParentID == nil || *c.ParentID == zeroUUID +} + +// IncrementPostCount increments the post count +func (c *Category) IncrementPostCount() { + c.PostCount++ + c.SetTimestamps() +} + +// DecrementPostCount decrements the post count +func (c *Category) DecrementPostCount() { + if c.PostCount > 0 { + c.PostCount-- + c.SetTimestamps() + } +} + +// Activate activates the category +func (c *Category) Activate() { + c.IsActive = true + c.SetTimestamps() +} + +// Deactivate deactivates the category +func (c *Category) Deactivate() { + c.IsActive = false + c.SetTimestamps() +} diff --git a/pkg/post/domain/entity/comment.go b/pkg/post/domain/entity/comment.go new file mode 100644 index 0000000..c1c469c --- /dev/null +++ b/pkg/post/domain/entity/comment.go @@ -0,0 +1,114 @@ +package entity + +import ( + "errors" + "time" + + "backend/pkg/post/domain/post" + + "github.com/gocql/gocql" +) + +// Comment represents a comment entity on a post. +// Comments can be nested (replies to comments). +type Comment struct { + ID gocql.UUID `db:"id" partition_key:"true"` // Comment unique identifier + PostID gocql.UUID `db:"post_id" clustering_key:"true"` // Post ID (clustering key for sorting) + AuthorUID string `db:"author_uid"` // Author user UID + ParentID *gocql.UUID `db:"parent_id,omitempty" clustering_key:"true"` // Parent comment ID (for nested comments) + Content string `db:"content"` // Comment content + Status post.CommentStatus `db:"status"` // Comment status + LikeCount int64 `db:"like_count"` // Number of likes + ReplyCount int64 `db:"reply_count"` // Number of replies + CreatedAt int64 `db:"created_at" clustering_key:"true"` // Creation timestamp (for sorting) + UpdatedAt int64 `db:"updated_at"` // Last update timestamp +} + +// TableName returns the Cassandra table name for Comment entities. +func (c *Comment) TableName() string { + return "comments" +} + +// Validate validates the Comment entity +func (c *Comment) Validate() error { + var zeroUUID gocql.UUID + if c.PostID == zeroUUID { + return errors.New("post_id is required") + } + if c.AuthorUID == "" { + return errors.New("author_uid is required") + } + if len(c.Content) < 1 || len(c.Content) > 2000 { + return errors.New("content length must be between 1 and 2000 characters") + } + if !c.Status.IsValid() { + return errors.New("invalid comment status") + } + return nil +} + +// SetTimestamps sets the create and update timestamps +func (c *Comment) SetTimestamps() { + now := time.Now().UTC().UnixNano() / 1e6 // milliseconds + if c.CreatedAt == 0 { + c.CreatedAt = now + } + c.UpdatedAt = now +} + +// IsNew returns true if this is a new comment (no ID set) +func (c *Comment) IsNew() bool { + var zeroUUID gocql.UUID + return c.ID == zeroUUID +} + +// IsReply returns true if this comment is a reply to another comment +func (c *Comment) IsReply() bool { + var zeroUUID gocql.UUID + return c.ParentID != nil && *c.ParentID != zeroUUID +} + +// Delete marks the comment as deleted (soft delete) +func (c *Comment) Delete() { + c.Status = post.CommentStatusDeleted + c.SetTimestamps() +} + +// Hide hides the comment +func (c *Comment) Hide() { + c.Status = post.CommentStatusHidden + c.SetTimestamps() +} + +// IsVisible returns true if the comment is visible to public +func (c *Comment) IsVisible() bool { + return c.Status.IsVisible() +} + +// IncrementLikeCount increments the like count +func (c *Comment) IncrementLikeCount() { + c.LikeCount++ + c.SetTimestamps() +} + +// DecrementLikeCount decrements the like count +func (c *Comment) DecrementLikeCount() { + if c.LikeCount > 0 { + c.LikeCount-- + c.SetTimestamps() + } +} + +// IncrementReplyCount increments the reply count +func (c *Comment) IncrementReplyCount() { + c.ReplyCount++ + c.SetTimestamps() +} + +// DecrementReplyCount decrements the reply count +func (c *Comment) DecrementReplyCount() { + if c.ReplyCount > 0 { + c.ReplyCount-- + c.SetTimestamps() + } +} diff --git a/pkg/post/domain/entity/like.go b/pkg/post/domain/entity/like.go new file mode 100644 index 0000000..5a0ec6a --- /dev/null +++ b/pkg/post/domain/entity/like.go @@ -0,0 +1,61 @@ +package entity + +import ( + "errors" + "time" + + "github.com/gocql/gocql" +) + +// Like represents a like entity for posts or comments. +// Uses composite primary key: (target_id, user_uid) for uniqueness. +type Like struct { + ID gocql.UUID `db:"id" partition_key:"true"` // Like unique identifier + TargetID gocql.UUID `db:"target_id" clustering_key:"true"` // Target ID (post_id or comment_id) + UserUID string `db:"user_uid" clustering_key:"true"` // User UID who liked + TargetType string `db:"target_type"` // Target type: "post" or "comment" + CreatedAt int64 `db:"created_at"` // Creation timestamp +} + +// TableName returns the Cassandra table name for Like entities. +func (l *Like) TableName() string { + return "likes" +} + +// Validate validates the Like entity +func (l *Like) Validate() error { + var zeroUUID gocql.UUID + if l.TargetID == zeroUUID { + return errors.New("target_id is required") + } + if l.UserUID == "" { + return errors.New("user_uid is required") + } + if l.TargetType != "post" && l.TargetType != "comment" { + return errors.New("target_type must be 'post' or 'comment'") + } + return nil +} + +// SetTimestamps sets the create timestamp +func (l *Like) SetTimestamps() { + if l.CreatedAt == 0 { + l.CreatedAt = time.Now().UTC().UnixNano() / 1e6 // milliseconds + } +} + +// IsNew returns true if this is a new like (no ID set) +func (l *Like) IsNew() bool { + var zeroUUID gocql.UUID + return l.ID == zeroUUID +} + +// IsPostLike returns true if this like is for a post +func (l *Like) IsPostLike() bool { + return l.TargetType == "post" +} + +// IsCommentLike returns true if this like is for a comment +func (l *Like) IsCommentLike() bool { + return l.TargetType == "comment" +} diff --git a/pkg/post/domain/entity/post.go b/pkg/post/domain/entity/post.go new file mode 100644 index 0000000..e8f0a37 --- /dev/null +++ b/pkg/post/domain/entity/post.go @@ -0,0 +1,156 @@ +package entity + +import ( + "errors" + "time" + + "backend/pkg/post/domain/post" + + "github.com/gocql/gocql" +) + +// Post represents a post entity in the system. +// It contains the main content and metadata for user posts. +type Post struct { + ID gocql.UUID `db:"id" partition_key:"true"` // Post unique identifier + AuthorUID string `db:"author_uid"` // Author user UID + Title string `db:"title"` // Post title + Content string `db:"content"` // Post content + Type post.Type `db:"type"` // Post type (text, image, video, etc.) + Status post.Status `db:"status"` // Post status (draft, published, etc.) + CategoryID *gocql.UUID `db:"category_id,omitempty"` // Category ID (optional) + Tags []string `db:"tags,omitempty"` // Post tags + Images []string `db:"images,omitempty"` // Image URLs (optional) + VideoURL *string `db:"video_url,omitempty"` // Video URL (optional) + LinkURL *string `db:"link_url,omitempty"` // Link URL (optional) + LikeCount int64 `db:"like_count"` // Number of likes + CommentCount int64 `db:"comment_count"` // Number of comments + ViewCount int64 `db:"view_count"` // Number of views + IsPinned bool `db:"is_pinned"` // Whether the post is pinned + PinnedAt *int64 `db:"pinned_at,omitempty"` // Pinned timestamp (optional) + PublishedAt *int64 `db:"published_at,omitempty"` // Published timestamp (optional) + CreatedAt int64 `db:"created_at"` // Creation timestamp + UpdatedAt int64 `db:"updated_at"` // Last update timestamp +} + +// TableName returns the Cassandra table name for Post entities. +func (p *Post) TableName() string { + return "posts" +} + +// Validate validates the Post entity +func (p *Post) Validate() error { + if p.AuthorUID == "" { + return errors.New("author_uid is required") + } + if len(p.Title) < 1 || len(p.Title) > 200 { + return errors.New("title length must be between 1 and 200 characters") + } + if len(p.Content) < 1 || len(p.Content) > 10000 { + return errors.New("content length must be between 1 and 10000 characters") + } + if !p.Type.IsValid() { + return errors.New("invalid post type") + } + if !p.Status.IsValid() { + return errors.New("invalid post status") + } + if len(p.Tags) > 10 { + return errors.New("maximum 10 tags allowed per post") + } + return nil +} + +// SetTimestamps sets the create and update timestamps +func (p *Post) SetTimestamps() { + now := time.Now().UTC().UnixNano() / 1e6 // milliseconds + if p.CreatedAt == 0 { + p.CreatedAt = now + } + p.UpdatedAt = now +} + +// IsNew returns true if this is a new post (no ID set) +func (p *Post) IsNew() bool { + var zeroUUID gocql.UUID + return p.ID == zeroUUID +} + +// Publish marks the post as published +func (p *Post) Publish() { + p.Status = post.PostStatusPublished + now := time.Now().UTC().UnixNano() / 1e6 + p.PublishedAt = &now + p.SetTimestamps() +} + +// Archive marks the post as archived +func (p *Post) Archive() { + p.Status = post.PostStatusArchived + p.SetTimestamps() +} + +// Delete marks the post as deleted (soft delete) +func (p *Post) Delete() { + p.Status = post.PostStatusDeleted + p.SetTimestamps() +} + +// IsVisible returns true if the post is visible to public +func (p *Post) IsVisible() bool { + return p.Status.IsVisible() +} + +// IsEditable returns true if the post can be edited +func (p *Post) IsEditable() bool { + return p.Status.IsEditable() +} + +// IncrementLikeCount increments the like count +func (p *Post) IncrementLikeCount() { + p.LikeCount++ + p.SetTimestamps() +} + +// DecrementLikeCount decrements the like count +func (p *Post) DecrementLikeCount() { + if p.LikeCount > 0 { + p.LikeCount-- + p.SetTimestamps() + } +} + +// IncrementCommentCount increments the comment count +func (p *Post) IncrementCommentCount() { + p.CommentCount++ + p.SetTimestamps() +} + +// DecrementCommentCount decrements the comment count +func (p *Post) DecrementCommentCount() { + if p.CommentCount > 0 { + p.CommentCount-- + p.SetTimestamps() + } +} + +// IncrementViewCount increments the view count +func (p *Post) IncrementViewCount() { + p.ViewCount++ + p.SetTimestamps() +} + +// Pin pins the post +func (p *Post) Pin() { + p.IsPinned = true + now := time.Now().UTC().UnixNano() / 1e6 + p.PinnedAt = &now + p.SetTimestamps() +} + +// Unpin unpins the post +func (p *Post) Unpin() { + p.IsPinned = false + p.PinnedAt = nil + p.SetTimestamps() +} diff --git a/pkg/post/domain/entity/tag.go b/pkg/post/domain/entity/tag.go new file mode 100644 index 0000000..a35f8ac --- /dev/null +++ b/pkg/post/domain/entity/tag.go @@ -0,0 +1,60 @@ +package entity + +import ( + "errors" + "time" + + "github.com/gocql/gocql" +) + +// Tag represents a tag entity for categorizing posts. +type Tag struct { + ID gocql.UUID `db:"id" partition_key:"true"` // Tag unique identifier + Name string `db:"name"` // Tag name (unique) + Description *string `db:"description,omitempty"` // Tag description (optional) + PostCount int64 `db:"post_count"` // Number of posts using this tag + CreatedAt int64 `db:"created_at"` // Creation timestamp + UpdatedAt int64 `db:"updated_at"` // Last update timestamp +} + +// TableName returns the Cassandra table name for Tag entities. +func (t *Tag) TableName() string { + return "tags" +} + +// Validate validates the Tag entity +func (t *Tag) Validate() error { + if len(t.Name) < 1 || len(t.Name) > 50 { + return errors.New("tag name length must be between 1 and 50 characters") + } + return nil +} + +// SetTimestamps sets the create and update timestamps +func (t *Tag) SetTimestamps() { + now := time.Now().UTC().UnixNano() / 1e6 // milliseconds + if t.CreatedAt == 0 { + t.CreatedAt = now + } + t.UpdatedAt = now +} + +// IsNew returns true if this is a new tag (no ID set) +func (t *Tag) IsNew() bool { + var zeroUUID gocql.UUID + return t.ID == zeroUUID +} + +// IncrementPostCount increments the post count +func (t *Tag) IncrementPostCount() { + t.PostCount++ + t.SetTimestamps() +} + +// DecrementPostCount decrements the post count +func (t *Tag) DecrementPostCount() { + if t.PostCount > 0 { + t.PostCount-- + t.SetTimestamps() + } +} diff --git a/pkg/post/domain/post/comment_status.go b/pkg/post/domain/post/comment_status.go new file mode 100644 index 0000000..81f480d --- /dev/null +++ b/pkg/post/domain/post/comment_status.go @@ -0,0 +1,38 @@ +package post + +// CommentStatus 評論狀態 +type CommentStatus int32 + +func (s *CommentStatus) CodeToString() string { + result, ok := commentStatusMap[*s] + if !ok { + return "" + } + return result +} + +var commentStatusMap = map[CommentStatus]string{ + CommentStatusPublished: "published", // 已發布 + CommentStatusDeleted: "deleted", // 已刪除 + CommentStatusHidden: "hidden", // 隱藏 +} + +func (s *CommentStatus) ToInt32() int32 { + return int32(*s) +} + +const ( + CommentStatusPublished CommentStatus = 0 // 已發布 + CommentStatusDeleted CommentStatus = 1 // 已刪除 + CommentStatusHidden CommentStatus = 2 // 隱藏 +) + +// IsValid returns true if the status is valid +func (s CommentStatus) IsValid() bool { + return s >= CommentStatusPublished && s <= CommentStatusHidden +} + +// IsVisible returns true if the comment is visible to public +func (s CommentStatus) IsVisible() bool { + return s == CommentStatusPublished +} diff --git a/pkg/post/domain/post/status.go b/pkg/post/domain/post/status.go new file mode 100644 index 0000000..4d62bcd --- /dev/null +++ b/pkg/post/domain/post/status.go @@ -0,0 +1,47 @@ +package post + +// Status 貼文狀態 +type Status int32 + +func (s *Status) CodeToString() string { + result, ok := postStatusMap[*s] + if !ok { + return "" + } + return result +} + +var postStatusMap = map[Status]string{ + PostStatusDraft: "draft", // 草稿 + PostStatusPublished: "published", // 已發布 + PostStatusArchived: "archived", // 已歸檔 + PostStatusDeleted: "deleted", // 已刪除 + PostStatusHidden: "hidden", // 隱藏 +} + +func (s *Status) ToInt32() int32 { + return int32(*s) +} + +const ( + PostStatusDraft Status = 0 // 草稿 + PostStatusPublished Status = 1 // 已發布 + PostStatusArchived Status = 2 // 已歸檔 + PostStatusDeleted Status = 3 // 已刪除 + PostStatusHidden Status = 4 // 隱藏 +) + +// IsValid returns true if the status is valid +func (s Status) IsValid() bool { + return s >= PostStatusDraft && s <= PostStatusHidden +} + +// IsVisible returns true if the post is visible to public +func (s Status) IsVisible() bool { + return s == PostStatusPublished +} + +// IsEditable returns true if the post can be edited +func (s Status) IsEditable() bool { + return s == PostStatusDraft || s == PostStatusPublished +} diff --git a/pkg/post/domain/post/type.go b/pkg/post/domain/post/type.go new file mode 100644 index 0000000..a534db3 --- /dev/null +++ b/pkg/post/domain/post/type.go @@ -0,0 +1,39 @@ +package post + +// Type 貼文類型 +type Type int32 + +func (t *Type) CodeToString() string { + result, ok := postTypeMap[*t] + if !ok { + return "" + } + return result +} + +var postTypeMap = map[Type]string{ + PostTypeText: "text", // 純文字 + PostTypeImage: "image", // 圖片 + PostTypeVideo: "video", // 影片 + PostTypeLink: "link", // 連結 + PostTypePoll: "poll", // 投票 + PostTypeArticle: "article", // 長文 +} + +func (t *Type) ToInt32() int32 { + return int32(*t) +} + +const ( + PostTypeText Type = 0 // 純文字 + PostTypeImage Type = 1 // 圖片 + PostTypeVideo Type = 2 // 影片 + PostTypeLink Type = 3 // 連結 + PostTypePoll Type = 4 // 投票 + PostTypeArticle Type = 5 // 長文 +) + +// IsValid returns true if the type is valid +func (t Type) IsValid() bool { + return t >= PostTypeText && t <= PostTypeArticle +} diff --git a/pkg/post/domain/repository/category.go b/pkg/post/domain/repository/category.go new file mode 100644 index 0000000..28dd6a1 --- /dev/null +++ b/pkg/post/domain/repository/category.go @@ -0,0 +1,29 @@ +package repository + +import ( + "context" + + "backend/pkg/post/domain/entity" + + "github.com/gocql/gocql" +) + +// CategoryRepository defines the interface for category data access operations +type CategoryRepository interface { + BaseCategoryRepository + FindBySlug(ctx context.Context, slug string) (*entity.Category, error) + FindByParentID(ctx context.Context, parentID *gocql.UUID) ([]*entity.Category, error) + FindRootCategories(ctx context.Context) ([]*entity.Category, error) + FindActive(ctx context.Context) ([]*entity.Category, error) + IncrementPostCount(ctx context.Context, categoryID gocql.UUID) error + DecrementPostCount(ctx context.Context, categoryID gocql.UUID) error +} + +// BaseCategoryRepository defines basic CRUD operations for categories +type BaseCategoryRepository interface { + Insert(ctx context.Context, data *entity.Category) error + FindOne(ctx context.Context, id gocql.UUID) (*entity.Category, error) + Update(ctx context.Context, data *entity.Category) error + Delete(ctx context.Context, id gocql.UUID) error +} + diff --git a/pkg/post/domain/repository/comment.go b/pkg/post/domain/repository/comment.go new file mode 100644 index 0000000..f94d7c5 --- /dev/null +++ b/pkg/post/domain/repository/comment.go @@ -0,0 +1,46 @@ +package repository + +import ( + "context" + + "backend/pkg/post/domain/entity" + "backend/pkg/post/domain/post" + + "github.com/gocql/gocql" +) + +// CommentRepository defines the interface for comment data access operations +type CommentRepository interface { + BaseCommentRepository + FindByPostID(ctx context.Context, postID gocql.UUID, params *CommentQueryParams) ([]*entity.Comment, int64, error) + FindByParentID(ctx context.Context, parentID gocql.UUID, params *CommentQueryParams) ([]*entity.Comment, int64, error) + FindByAuthorUID(ctx context.Context, authorUID string, params *CommentQueryParams) ([]*entity.Comment, int64, error) + FindReplies(ctx context.Context, commentID gocql.UUID, params *CommentQueryParams) ([]*entity.Comment, int64, error) + IncrementLikeCount(ctx context.Context, commentID gocql.UUID) error + DecrementLikeCount(ctx context.Context, commentID gocql.UUID) error + IncrementReplyCount(ctx context.Context, commentID gocql.UUID) error + DecrementReplyCount(ctx context.Context, commentID gocql.UUID) error + UpdateStatus(ctx context.Context, commentID gocql.UUID, status post.CommentStatus) error +} + +// BaseCommentRepository defines basic CRUD operations for comments +type BaseCommentRepository interface { + Insert(ctx context.Context, data *entity.Comment) error + FindOne(ctx context.Context, id gocql.UUID) (*entity.Comment, error) + Update(ctx context.Context, data *entity.Comment) error + Delete(ctx context.Context, id gocql.UUID) error +} + +// CommentQueryParams defines query parameters for comment listing +type CommentQueryParams struct { + PostID *gocql.UUID + ParentID *gocql.UUID + AuthorUID *string + Status *post.CommentStatus + CreateStartTime *int64 + CreateEndTime *int64 + PageSize int64 + PageIndex int64 + OrderBy string // "created_at", "like_count" + OrderDirection string // "ASC", "DESC" +} diff --git a/pkg/post/domain/repository/like.go b/pkg/post/domain/repository/like.go new file mode 100644 index 0000000..143a16c --- /dev/null +++ b/pkg/post/domain/repository/like.go @@ -0,0 +1,37 @@ +package repository + +import ( + "context" + + "backend/pkg/post/domain/entity" + + "github.com/gocql/gocql" +) + +// LikeRepository defines the interface for like data access operations +type LikeRepository interface { + BaseLikeRepository + FindByTargetID(ctx context.Context, targetID gocql.UUID, targetType string) ([]*entity.Like, error) + FindByUserUID(ctx context.Context, userUID string, params *LikeQueryParams) ([]*entity.Like, int64, error) + FindByTargetAndUser(ctx context.Context, targetID gocql.UUID, userUID string, targetType string) (*entity.Like, error) + CountByTargetID(ctx context.Context, targetID gocql.UUID, targetType string) (int64, error) + DeleteByTargetAndUser(ctx context.Context, targetID gocql.UUID, userUID string, targetType string) error +} + +// BaseLikeRepository defines basic CRUD operations for likes +type BaseLikeRepository interface { + Insert(ctx context.Context, data *entity.Like) error + FindOne(ctx context.Context, id gocql.UUID) (*entity.Like, error) + Delete(ctx context.Context, id gocql.UUID) error +} + +// LikeQueryParams defines query parameters for like listing +type LikeQueryParams struct { + TargetID *gocql.UUID + TargetType *string + UserUID *string + PageSize int64 + PageIndex int64 + OrderBy string // "created_at" + OrderDirection string // "ASC", "DESC" +} diff --git a/pkg/post/domain/repository/post.go b/pkg/post/domain/repository/post.go new file mode 100644 index 0000000..13d4b7f --- /dev/null +++ b/pkg/post/domain/repository/post.go @@ -0,0 +1,54 @@ +package repository + +import ( + "context" + + "backend/pkg/post/domain/entity" + "backend/pkg/post/domain/post" + + "github.com/gocql/gocql" +) + +// PostRepository defines the interface for post data access operations +type PostRepository interface { + BasePostRepository + FindByAuthorUID(ctx context.Context, authorUID string, params *PostQueryParams) ([]*entity.Post, int64, error) + FindByCategoryID(ctx context.Context, categoryID gocql.UUID, params *PostQueryParams) ([]*entity.Post, int64, error) + FindByTag(ctx context.Context, tagName string, params *PostQueryParams) ([]*entity.Post, int64, error) + FindPinnedPosts(ctx context.Context, limit int64) ([]*entity.Post, error) + FindByStatus(ctx context.Context, status post.Status, params *PostQueryParams) ([]*entity.Post, int64, error) + IncrementLikeCount(ctx context.Context, postID gocql.UUID) error + DecrementLikeCount(ctx context.Context, postID gocql.UUID) error + IncrementCommentCount(ctx context.Context, postID gocql.UUID) error + DecrementCommentCount(ctx context.Context, postID gocql.UUID) error + IncrementViewCount(ctx context.Context, postID gocql.UUID) error + UpdateStatus(ctx context.Context, postID gocql.UUID, status post.Status) error + PinPost(ctx context.Context, postID gocql.UUID) error + UnpinPost(ctx context.Context, postID gocql.UUID) error +} + +// BasePostRepository defines basic CRUD operations for posts +type BasePostRepository interface { + Insert(ctx context.Context, data *entity.Post) error + FindOne(ctx context.Context, id gocql.UUID) (*entity.Post, error) + Update(ctx context.Context, data *entity.Post) error + Delete(ctx context.Context, id gocql.UUID) error +} + +// PostQueryParams defines query parameters for post listing +type PostQueryParams struct { + AuthorUID *string + CategoryID *gocql.UUID + Tag *string + Status *post.Status + Type *post.Type + IsPinned *bool + CreateStartTime *int64 + CreateEndTime *int64 + PublishedStartTime *int64 + PublishedEndTime *int64 + PageSize int64 + PageIndex int64 + OrderBy string // "created_at", "published_at", "like_count", "view_count" + OrderDirection string // "ASC", "DESC" +} diff --git a/pkg/post/domain/repository/tag.go b/pkg/post/domain/repository/tag.go new file mode 100644 index 0000000..8f6316d --- /dev/null +++ b/pkg/post/domain/repository/tag.go @@ -0,0 +1,28 @@ +package repository + +import ( + "context" + + "backend/pkg/post/domain/entity" + + "github.com/gocql/gocql" +) + +// TagRepository defines the interface for tag data access operations +type TagRepository interface { + BaseTagRepository + FindByName(ctx context.Context, name string) (*entity.Tag, error) + FindByNames(ctx context.Context, names []string) ([]*entity.Tag, error) + FindPopular(ctx context.Context, limit int64) ([]*entity.Tag, error) + IncrementPostCount(ctx context.Context, tagID gocql.UUID) error + DecrementPostCount(ctx context.Context, tagID gocql.UUID) error +} + +// BaseTagRepository defines basic CRUD operations for tags +type BaseTagRepository interface { + Insert(ctx context.Context, data *entity.Tag) error + FindOne(ctx context.Context, id gocql.UUID) (*entity.Tag, error) + Update(ctx context.Context, data *entity.Tag) error + Delete(ctx context.Context, id gocql.UUID) error +} + diff --git a/pkg/post/domain/usecase/comment.go b/pkg/post/domain/usecase/comment.go new file mode 100644 index 0000000..83132ed --- /dev/null +++ b/pkg/post/domain/usecase/comment.go @@ -0,0 +1,128 @@ +package usecase + +import ( + "context" + + "backend/pkg/post/domain/post" + + "github.com/gocql/gocql" +) + +// CommentUseCase defines the interface for comment business logic operations +type CommentUseCase interface { + CommentCRUDUseCase + CommentQueryUseCase + CommentInteractionUseCase +} + +// CommentCRUDUseCase defines CRUD operations for comments +type CommentCRUDUseCase interface { + // CreateComment creates a new comment + CreateComment(ctx context.Context, req CreateCommentRequest) (*CommentResponse, error) + // GetComment retrieves a comment by ID + GetComment(ctx context.Context, req GetCommentRequest) (*CommentResponse, error) + // UpdateComment updates an existing comment + UpdateComment(ctx context.Context, req UpdateCommentRequest) (*CommentResponse, error) + // DeleteComment deletes a comment (soft delete) + DeleteComment(ctx context.Context, req DeleteCommentRequest) error +} + +// CommentQueryUseCase defines query operations for comments +type CommentQueryUseCase interface { + // ListComments lists comments for a post + ListComments(ctx context.Context, req ListCommentsRequest) (*ListCommentsResponse, error) + // ListReplies lists replies to a comment + ListReplies(ctx context.Context, req ListRepliesRequest) (*ListCommentsResponse, error) + // ListCommentsByAuthor lists comments by author + ListCommentsByAuthor(ctx context.Context, req ListCommentsByAuthorRequest) (*ListCommentsResponse, error) +} + +// CommentInteractionUseCase defines interaction operations for comments +type CommentInteractionUseCase interface { + // LikeComment likes a comment + LikeComment(ctx context.Context, req LikeCommentRequest) error + // UnlikeComment unlikes a comment + UnlikeComment(ctx context.Context, req UnlikeCommentRequest) error +} + +// CreateCommentRequest represents a request to create a comment +type CreateCommentRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + AuthorUID string `json:"author_uid"` // Author user UID + ParentID *gocql.UUID `json:"parent_id,omitempty"` // Parent comment ID (optional, for replies) + Content string `json:"content"` // Comment content +} + +// UpdateCommentRequest represents a request to update a comment +type UpdateCommentRequest struct { + CommentID gocql.UUID `json:"comment_id"` // Comment ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) + Content string `json:"content"` // Comment content +} + +// GetCommentRequest represents a request to get a comment +type GetCommentRequest struct { + CommentID gocql.UUID `json:"comment_id"` // Comment ID +} + +// DeleteCommentRequest represents a request to delete a comment +type DeleteCommentRequest struct { + CommentID gocql.UUID `json:"comment_id"` // Comment ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) +} + +// ListCommentsRequest represents a request to list comments +type ListCommentsRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + ParentID *gocql.UUID `json:"parent_id,omitempty"` // Parent comment ID (optional, for replies only) + PageSize int64 `json:"page_size"` // Page size + PageIndex int64 `json:"page_index"` // Page index + OrderBy string `json:"order_by,omitempty"` // Order by field (default: "created_at") + OrderDirection string `json:"order_direction,omitempty"` // Order direction (ASC/DESC, default: ASC) +} + +// ListRepliesRequest represents a request to list replies to a comment +type ListRepliesRequest struct { + CommentID gocql.UUID `json:"comment_id"` // Comment ID + PageSize int64 `json:"page_size"` // Page size + PageIndex int64 `json:"page_index"` // Page index +} + +// ListCommentsByAuthorRequest represents a request to list comments by author +type ListCommentsByAuthorRequest struct { + AuthorUID string `json:"author_uid"` // Author UID + PageSize int64 `json:"page_size"` // Page size + PageIndex int64 `json:"page_index"` // Page index +} + +// LikeCommentRequest represents a request to like a comment +type LikeCommentRequest struct { + CommentID gocql.UUID `json:"comment_id"` // Comment ID + UserUID string `json:"user_uid"` // User UID +} + +// UnlikeCommentRequest represents a request to unlike a comment +type UnlikeCommentRequest struct { + CommentID gocql.UUID `json:"comment_id"` // Comment ID + UserUID string `json:"user_uid"` // User UID +} + +// CommentResponse represents a comment response +type CommentResponse struct { + ID gocql.UUID `json:"id"` + PostID gocql.UUID `json:"post_id"` + AuthorUID string `json:"author_uid"` + ParentID *gocql.UUID `json:"parent_id,omitempty"` + Content string `json:"content"` + Status post.CommentStatus `json:"status"` + LikeCount int64 `json:"like_count"` + ReplyCount int64 `json:"reply_count"` + CreatedAt int64 `json:"created_at"` + UpdatedAt int64 `json:"updated_at"` +} + +// ListCommentsResponse represents a list of comments response +type ListCommentsResponse struct { + Data []CommentResponse `json:"data"` + Page Pager `json:"page"` +} diff --git a/pkg/post/domain/usecase/post.go b/pkg/post/domain/usecase/post.go new file mode 100644 index 0000000..1a0bc2c --- /dev/null +++ b/pkg/post/domain/usecase/post.go @@ -0,0 +1,229 @@ +package usecase + +import ( + "context" + + "backend/pkg/post/domain/post" + + "github.com/gocql/gocql" +) + +// PostUseCase defines the interface for post business logic operations +type PostUseCase interface { + PostCRUDUseCase + PostQueryUseCase + PostInteractionUseCase + PostManagementUseCase +} + +// PostCRUDUseCase defines CRUD operations for posts +type PostCRUDUseCase interface { + // CreatePost creates a new post + CreatePost(ctx context.Context, req CreatePostRequest) (*PostResponse, error) + // GetPost retrieves a post by ID + GetPost(ctx context.Context, req GetPostRequest) (*PostResponse, error) + // UpdatePost updates an existing post + UpdatePost(ctx context.Context, req UpdatePostRequest) (*PostResponse, error) + // DeletePost deletes a post (soft delete) + DeletePost(ctx context.Context, req DeletePostRequest) error + // PublishPost publishes a draft post + PublishPost(ctx context.Context, req PublishPostRequest) (*PostResponse, error) + // ArchivePost archives a post + ArchivePost(ctx context.Context, req ArchivePostRequest) error +} + +// PostQueryUseCase defines query operations for posts +type PostQueryUseCase interface { + // ListPosts lists posts with filters and pagination + ListPosts(ctx context.Context, req ListPostsRequest) (*ListPostsResponse, error) + // ListPostsByAuthor lists posts by author UID + ListPostsByAuthor(ctx context.Context, req ListPostsByAuthorRequest) (*ListPostsResponse, error) + // ListPostsByCategory lists posts by category + ListPostsByCategory(ctx context.Context, req ListPostsByCategoryRequest) (*ListPostsResponse, error) + // ListPostsByTag lists posts by tag + ListPostsByTag(ctx context.Context, req ListPostsByTagRequest) (*ListPostsResponse, error) + // GetPinnedPosts gets pinned posts + GetPinnedPosts(ctx context.Context, req GetPinnedPostsRequest) (*ListPostsResponse, error) +} + +// PostInteractionUseCase defines interaction operations for posts +type PostInteractionUseCase interface { + // LikePost likes a post + LikePost(ctx context.Context, req LikePostRequest) error + // UnlikePost unlikes a post + UnlikePost(ctx context.Context, req UnlikePostRequest) error + // ViewPost increments view count + ViewPost(ctx context.Context, req ViewPostRequest) error +} + +// PostManagementUseCase defines management operations for posts +type PostManagementUseCase interface { + // PinPost pins a post + PinPost(ctx context.Context, req PinPostRequest) error + // UnpinPost unpins a post + UnpinPost(ctx context.Context, req UnpinPostRequest) error +} + +// CreatePostRequest represents a request to create a post +type CreatePostRequest struct { + AuthorUID string `json:"author_uid"` // Author user UID + Title string `json:"title"` // Post title + Content string `json:"content"` // Post content + Type post.Type `json:"type"` // Post type + CategoryID *gocql.UUID `json:"category_id,omitempty"` // Category ID (optional) + Tags []string `json:"tags,omitempty"` // Post tags (optional) + Images []string `json:"images,omitempty"` // Image URLs (optional) + VideoURL *string `json:"video_url,omitempty"` // Video URL (optional) + LinkURL *string `json:"link_url,omitempty"` // Link URL (optional) + Status post.Status `json:"status,omitempty"` // Post status (default: draft) +} + +// UpdatePostRequest represents a request to update a post +type UpdatePostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) + Title *string `json:"title,omitempty"` // Post title (optional) + Content *string `json:"content,omitempty"` // Post content (optional) + Type *post.Type `json:"type,omitempty"` // Post type (optional) + CategoryID *gocql.UUID `json:"category_id,omitempty"` // Category ID (optional) + Tags []string `json:"tags,omitempty"` // Post tags (optional) + Images []string `json:"images,omitempty"` // Image URLs (optional) + VideoURL *string `json:"video_url,omitempty"` // Video URL (optional) + LinkURL *string `json:"link_url,omitempty"` // Link URL (optional) +} + +// GetPostRequest represents a request to get a post +type GetPostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + UserUID *string `json:"user_uid,omitempty"` // User UID (for view count increment) +} + +// DeletePostRequest represents a request to delete a post +type DeletePostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) +} + +// PublishPostRequest represents a request to publish a post +type PublishPostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) +} + +// ArchivePostRequest represents a request to archive a post +type ArchivePostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) +} + +// ListPostsRequest represents a request to list posts +type ListPostsRequest struct { + CategoryID *gocql.UUID `json:"category_id,omitempty"` // Category ID (optional) + Tag *string `json:"tag,omitempty"` // Tag name (optional) + Status *post.Status `json:"status,omitempty"` // Post status (optional) + Type *post.Type `json:"type,omitempty"` // Post type (optional) + AuthorUID *string `json:"author_uid,omitempty"` // Author UID (optional) + CreateStartTime *int64 `json:"create_start_time,omitempty"` // Create start time (optional) + CreateEndTime *int64 `json:"create_end_time,omitempty"` // Create end time (optional) + PageSize int64 `json:"page_size"` // Page size + PageIndex int64 `json:"page_index"` // Page index + OrderBy string `json:"order_by,omitempty"` // Order by field + OrderDirection string `json:"order_direction,omitempty"` // Order direction (ASC/DESC) +} + +// ListPostsByAuthorRequest represents a request to list posts by author +type ListPostsByAuthorRequest struct { + AuthorUID string `json:"author_uid"` // Author UID + Status *post.Status `json:"status,omitempty"` // Post status (optional) + PageSize int64 `json:"page_size"` // Page size + PageIndex int64 `json:"page_index"` // Page index +} + +// ListPostsByCategoryRequest represents a request to list posts by category +type ListPostsByCategoryRequest struct { + CategoryID gocql.UUID `json:"category_id"` // Category ID + Status *post.Status `json:"status,omitempty"` // Post status (optional) + PageSize int64 `json:"page_size"` // Page size + PageIndex int64 `json:"page_index"` // Page index +} + +// ListPostsByTagRequest represents a request to list posts by tag +type ListPostsByTagRequest struct { + Tag string `json:"tag"` // Tag name + Status *post.Status `json:"status,omitempty"` // Post status (optional) + PageSize int64 `json:"page_size"` // Page size + PageIndex int64 `json:"page_index"` // Page index +} + +// GetPinnedPostsRequest represents a request to get pinned posts +type GetPinnedPostsRequest struct { + Limit int64 `json:"limit,omitempty"` // Limit (optional, default: 10) +} + +// LikePostRequest represents a request to like a post +type LikePostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + UserUID string `json:"user_uid"` // User UID +} + +// UnlikePostRequest represents a request to unlike a post +type UnlikePostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + UserUID string `json:"user_uid"` // User UID +} + +// ViewPostRequest represents a request to view a post +type ViewPostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + UserUID *string `json:"user_uid,omitempty"` // User UID (optional) +} + +// PinPostRequest represents a request to pin a post +type PinPostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) +} + +// UnpinPostRequest represents a request to unpin a post +type UnpinPostRequest struct { + PostID gocql.UUID `json:"post_id"` // Post ID + AuthorUID string `json:"author_uid"` // Author user UID (for authorization) +} + +// PostResponse represents a post response +type PostResponse struct { + ID gocql.UUID `json:"id"` + AuthorUID string `json:"author_uid"` + Title string `json:"title"` + Content string `json:"content"` + Type post.Type `json:"type"` + Status post.Status `json:"status"` + CategoryID *gocql.UUID `json:"category_id,omitempty"` + Tags []string `json:"tags,omitempty"` + Images []string `json:"images,omitempty"` + VideoURL *string `json:"video_url,omitempty"` + LinkURL *string `json:"link_url,omitempty"` + LikeCount int64 `json:"like_count"` + CommentCount int64 `json:"comment_count"` + ViewCount int64 `json:"view_count"` + IsPinned bool `json:"is_pinned"` + PinnedAt *int64 `json:"pinned_at,omitempty"` + PublishedAt *int64 `json:"published_at,omitempty"` + CreatedAt int64 `json:"created_at"` + UpdatedAt int64 `json:"updated_at"` +} + +// ListPostsResponse represents a list of posts response +type ListPostsResponse struct { + Data []PostResponse `json:"data"` + Page Pager `json:"page"` +} + +// Pager represents pagination information +type Pager struct { + PageIndex int64 `json:"page_index"` + PageSize int64 `json:"page_size"` + Total int64 `json:"total"` + TotalPage int64 `json:"total_page"` +} +