@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/templates/go-backend/internal/core/storage/path_test.go

@@ -0,0 +1,301 @@
+package storage
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// ===============================================================
+// GenerateObjectKey 测试
+//
+// 路径结构说明（time.Format("2006/01/02") 展开为三段）:
+//   shared    → {product}/{category}/{YYYY}/{MM}/{DD}/{hex}/{filename}  7 段
+//   dedicated → {category}/{YYYY}/{MM}/{DD}/{hex}/{filename}            6 段
+// ===============================================================
+
+func TestGenerateObjectKey_SharedBucketFormat(t *testing.T) {
+	strategy := &PathStrategy{
+		ProductCode:    "aichat",
+		BucketStrategy: "shared",
+	}
+
+	key, err := strategy.GenerateObjectKey(ObjectKeyInput{
+		Category: "avatars",
+		Filename: "photo.jpg",
+	})
+	require.NoError(t, err)
+	require.NotEmpty(t, key)
+
+	// shared 格式: product/category/YYYY/MM/DD/hex/filename — 7 段
+	parts := strings.Split(key, "/")
+	require.Len(t, parts, 7,
+		"shared bucket key must have 7 path segments: product/category/YYYY/MM/DD/hex/filename, got key: %q", key)
+
+	now := time.Now().UTC()
+
+	assert.Equal(t, "aichat", parts[0], "parts[0] must be product code")
+	assert.Equal(t, "avatars", parts[1], "parts[1] must be category")
+	assert.Equal(t, now.Format("2006"), parts[2], "parts[2] must be year (YYYY)")
+	assert.Equal(t, now.Format("01"), parts[3], "parts[3] must be month (MM)")
+	assert.Equal(t, now.Format("02"), parts[4], "parts[4] must be day (DD)")
+	assert.NotEmpty(t, parts[5], "parts[5] must be non-empty hex prefix")
+	assert.Equal(t, "photo.jpg", parts[6], "parts[6] must be sanitized filename")
+
+	// 整体前缀验证
+	datePath := now.Format("2006/01/02")
+	expectedPrefix := fmt.Sprintf("aichat/avatars/%s/", datePath)
+	assert.True(t, strings.HasPrefix(key, expectedPrefix),
+		"key %q should start with %q", key, expectedPrefix)
+}
+
+func TestGenerateObjectKey_DedicatedBucketFormat(t *testing.T) {
+	strategy := &PathStrategy{
+		ProductCode:    "aichat",
+		BucketStrategy: "dedicated",
+	}
+
+	key, err := strategy.GenerateObjectKey(ObjectKeyInput{
+		Category: "documents",
+		Filename: "report.pdf",
+	})
+	require.NoError(t, err)
+	require.NotEmpty(t, key)
+
+	// dedicated 格式: category/YYYY/MM/DD/hex/filename — 6 段
+	parts := strings.Split(key, "/")
+	require.Len(t, parts, 6,
+		"dedicated bucket key must have 6 path segments: category/YYYY/MM/DD/hex/filename, got key: %q", key)
+
+	now := time.Now().UTC()
+
+	assert.Equal(t, "documents", parts[0], "parts[0] must be category")
+	assert.Equal(t, now.Format("2006"), parts[1], "parts[1] must be year (YYYY)")
+	assert.Equal(t, now.Format("01"), parts[2], "parts[2] must be month (MM)")
+	assert.Equal(t, now.Format("02"), parts[3], "parts[3] must be day (DD)")
+	assert.NotEmpty(t, parts[4], "parts[4] must be non-empty hex prefix")
+	assert.Equal(t, "report.pdf", parts[5], "parts[5] must be sanitized filename")
+
+	// product code 不得出现在 dedicated key 头部
+	assert.False(t, strings.HasPrefix(key, "aichat/"),
+		"dedicated bucket key must NOT start with product code")
+
+	// 整体前缀验证
+	datePath := now.Format("2006/01/02")
+	expectedPrefix := fmt.Sprintf("documents/%s/", datePath)
+	assert.True(t, strings.HasPrefix(key, expectedPrefix),
+		"key %q should start with %q", key, expectedPrefix)
+}
+
+func TestGenerateObjectKey_HexPrefixFormat(t *testing.T) {
+	strategy := &PathStrategy{
+		ProductCode:    "product_beta",
+		BucketStrategy: "dedicated",
+	}
+
+	key, err := strategy.GenerateObjectKey(ObjectKeyInput{
+		Category: "videos",
+		Filename: "clip.mp4",
+	})
+	require.NoError(t, err)
+
+	// dedicated: category/YYYY/MM/DD/hex/filename — 6 段，hex 在 parts[4]
+	parts := strings.Split(key, "/")
+	require.Len(t, parts, 6,
+		"dedicated bucket key must have 6 segments, got key: %q", key)
+
+	hexPart := parts[4]
+	// generateRandomHex(8) 生成 8 字节 → 16 个 hex 字符
+	assert.Len(t, hexPart, 16,
+		"hex prefix should be 16 lowercase hex characters (8 random bytes), got %q", hexPart)
+
+	// 验证仅包含合法小写 hex 字符
+	for _, c := range hexPart {
+		assert.True(t,
+			(c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'),
+			"hex character %q must be in [0-9a-f]", c)
+	}
+}
+
+func TestGenerateObjectKey_Randomness(t *testing.T) {
+	strategy := &PathStrategy{
+		ProductCode:    "aichat",
+		BucketStrategy: "shared",
+	}
+
+	const iterations = 10
+	keys := make(map[string]struct{}, iterations)
+
+	for i := 0; i < iterations; i++ {
+		key, err := strategy.GenerateObjectKey(ObjectKeyInput{
+			Category: "images",
+			Filename: "photo.jpg",
+		})
+		require.NoError(t, err)
+		keys[key] = struct{}{}
+	}
+
+	// 10 次调用必须产生 10 个不同的 key（hex 前缀随机决定唯一性）
+	assert.Len(t, keys, iterations,
+		"all %d generated keys must be unique due to random hex prefix", iterations)
+}
+
+func TestGenerateObjectKey_FilenameWithSpecialCharacters(t *testing.T) {
+	tests := []struct {
+		name           string
+		filename       string
+		expectedSuffix string
+		bucketStrategy string
+	}{
+		{
+			name:           "path traversal in filename is sanitized (shared)",
+			filename:       "../../../etc/passwd",
+			expectedSuffix: "passwd",
+			bucketStrategy: "shared",
+		},
+		{
+			name:           "spaces in filename are replaced (dedicated)",
+			filename:       "my file name.jpg",
+			expectedSuffix: "my_file_name.jpg",
+			bucketStrategy: "dedicated",
+		},
+		{
+			name:           "special characters are replaced (shared)",
+			filename:       "file@2024!.png",
+			expectedSuffix: "file_2024_.png",
+			bucketStrategy: "shared",
+		},
+		{
+			name:           "empty filename becomes unnamed (dedicated)",
+			filename:       "",
+			expectedSuffix: "unnamed",
+			bucketStrategy: "dedicated",
+		},
+		{
+			name:           "valid filename preserved (shared)",
+			filename:       "report_2024-01.pdf",
+			expectedSuffix: "report_2024-01.pdf",
+			bucketStrategy: "shared",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			strategy := &PathStrategy{
+				ProductCode:    "aichat",
+				BucketStrategy: tc.bucketStrategy,
+			}
+
+			key, err := strategy.GenerateObjectKey(ObjectKeyInput{
+				Category: "uploads",
+				Filename: tc.filename,
+			})
+			require.NoError(t, err)
+
+			assert.True(t, strings.HasSuffix(key, "/"+tc.expectedSuffix),
+				"key %q should end with /%s", key, tc.expectedSuffix)
+		})
+	}
+}
+
+func TestGenerateObjectKey_DatePathIsUTC(t *testing.T) {
+	strategy := &PathStrategy{
+		ProductCode:    "aichat",
+		BucketStrategy: "dedicated",
+	}
+
+	before := time.Now().UTC()
+	key, err := strategy.GenerateObjectKey(ObjectKeyInput{
+		Category: "logs",
+		Filename: "event.log",
+	})
+	after := time.Now().UTC()
+	require.NoError(t, err)
+
+	// dedicated: category/YYYY/MM/DD/hex/filename — 6 段
+	// 日期段在 parts[1..3]
+	parts := strings.Split(key, "/")
+	require.Len(t, parts, 6,
+		"dedicated bucket key must have 6 segments, got key: %q", key)
+
+	datePart := fmt.Sprintf("%s/%s/%s", parts[1], parts[2], parts[3])
+
+	// 日期必须与调用时刻的 UTC 日期一致（极少情况下跨天，允许 before/after 各一）
+	beforeDate := before.Format("2006/01/02")
+	afterDate := after.Format("2006/01/02")
+
+	assert.True(t,
+		datePart == beforeDate || datePart == afterDate,
+		"date segment %q should be UTC date, expected %q or %q", datePart, beforeDate, afterDate)
+}
+
+func TestGenerateObjectKey_ProductCodeInSharedOnly(t *testing.T) {
+	productCode := "product_beta"
+
+	sharedStrategy := &PathStrategy{
+		ProductCode:    productCode,
+		BucketStrategy: "shared",
+	}
+	dedicatedStrategy := &PathStrategy{
+		ProductCode:    productCode,
+		BucketStrategy: "dedicated",
+	}
+
+	sharedKey, err := sharedStrategy.GenerateObjectKey(ObjectKeyInput{
+		Category: "assets",
+		Filename: "logo.png",
+	})
+	require.NoError(t, err)
+
+	dedicatedKey, err := dedicatedStrategy.GenerateObjectKey(ObjectKeyInput{
+		Category: "assets",
+		Filename: "logo.png",
+	})
+	require.NoError(t, err)
+
+	assert.True(t, strings.HasPrefix(sharedKey, productCode+"/"),
+		"shared key must start with product code, got: %q", sharedKey)
+	assert.False(t, strings.HasPrefix(dedicatedKey, productCode+"/"),
+		"dedicated key must NOT start with product code, got: %q", dedicatedKey)
+}
+
+func TestGenerateObjectKey_WithGovernancePrefix(t *testing.T) {
+	strategy := &PathStrategy{
+		ProductCode:    "product_beta",
+		BucketStrategy: "shared",
+	}
+
+	key, err := strategy.GenerateObjectKey(ObjectKeyInput{
+		Prefix:   "generation/output",
+		Category: "video",
+		Filename: "gen_123.mp4",
+	})
+	require.NoError(t, err)
+
+	parts := strings.Split(key, "/")
+	require.Len(t, parts, 9,
+		"shared key with prefix must have 9 segments, got key: %q", key)
+	assert.Equal(t, "product_beta", parts[0])
+	assert.Equal(t, "generation", parts[1])
+	assert.Equal(t, "output", parts[2])
+	assert.Equal(t, "video", parts[3])
+	assert.Equal(t, "gen_123.mp4", parts[8])
+}
+
+func TestGenerateObjectKey_RejectsUnsafePrefix(t *testing.T) {
+	strategy := &PathStrategy{
+		ProductCode:    "product_beta",
+		BucketStrategy: "shared",
+	}
+
+	_, err := strategy.GenerateObjectKey(ObjectKeyInput{
+		Prefix:   "../generation",
+		Category: "image",
+		Filename: "photo.jpg",
+	})
+	require.Error(t, err)
+}