@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/templates/go-backend/internal/common/utils/crypto_test.go

@@ -0,0 +1,345 @@
+package utils
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// 预期的 Argon2id 哈希格式正则
+var argon2idPattern = regexp.MustCompile(`^\$argon2id\$v=19\$m=\d+,t=\d+,p=\d+\$[A-Za-z0-9+/]+\$[A-Za-z0-9+/]+$`)
+
+// uuidPattern UUID v4 格式正则
+var uuidPattern = regexp.MustCompile(`^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`)
+
+// hexPattern 十六进制字符串正则
+var hexPattern = regexp.MustCompile(`^[0-9a-f]+$`)
+
+// digitPattern 纯数字字符串正则
+var digitPattern = regexp.MustCompile(`^[0-9]+$`)
+
+// ── HashPassword ──────────────────────────────────────────────────────────────
+
+func TestHashPassword_ProducesArgon2idFormat(t *testing.T) {
+	// HashPassword 应生成符合 $argon2id$v=19$... 格式的哈希
+	hash, err := Crypto.HashPassword("secret123")
+	require.NoError(t, err)
+	assert.True(t, argon2idPattern.MatchString(hash),
+		"哈希格式不符合 Argon2id 规范，实际值: %s", hash)
+}
+
+func TestHashPassword_HashStartsWithArgon2idPrefix(t *testing.T) {
+	// 哈希必须以 $argon2id$v=19$ 开头
+	hash, err := Crypto.HashPassword("test")
+	require.NoError(t, err)
+	assert.True(t, strings.HasPrefix(hash, "$argon2id$v=19$"))
+}
+
+func TestHashPassword_SamePlaintextProducesDifferentHashes(t *testing.T) {
+	// 每次调用使用随机 salt，相同明文应产生不同哈希
+	password := "identical-password"
+	hash1, err1 := Crypto.HashPassword(password)
+	hash2, err2 := Crypto.HashPassword(password)
+
+	require.NoError(t, err1)
+	require.NoError(t, err2)
+	assert.NotEqual(t, hash1, hash2,
+		"相同密码两次哈希的结果不应相同（salt 不同）")
+}
+
+func TestHashPassword_EmptyPassword(t *testing.T) {
+	// 空密码也应正常哈希，不应返回错误
+	hash, err := Crypto.HashPassword("")
+	require.NoError(t, err)
+	assert.True(t, argon2idPattern.MatchString(hash))
+}
+
+func TestHashPassword_SpecialCharacters(t *testing.T) {
+	// 含特殊字符的密码也应正常哈希
+	hash, err := Crypto.HashPassword("p@$$w0rd!#%^&*()")
+	require.NoError(t, err)
+	assert.True(t, argon2idPattern.MatchString(hash))
+}
+
+// ── VerifyPassword ────────────────────────────────────────────────────────────
+
+func TestVerifyPassword_CorrectPasswordReturnsTrue(t *testing.T) {
+	// 使用正确密码验证，应返回 true
+	password := "correct-password"
+	hash, err := Crypto.HashPassword(password)
+	require.NoError(t, err)
+
+	ok, err := Crypto.VerifyPassword(password, hash)
+	require.NoError(t, err)
+	assert.True(t, ok)
+}
+
+func TestVerifyPassword_WrongPasswordReturnsFalse(t *testing.T) {
+	// 使用错误密码验证，应返回 false
+	hash, err := Crypto.HashPassword("correct-password")
+	require.NoError(t, err)
+
+	ok, err := Crypto.VerifyPassword("wrong-password", hash)
+	require.NoError(t, err)
+	assert.False(t, ok)
+}
+
+func TestVerifyPassword_EmptyPasswordAgainstNonEmptyHash(t *testing.T) {
+	// 空密码验证非空密码的哈希，应返回 false
+	hash, err := Crypto.HashPassword("non-empty")
+	require.NoError(t, err)
+
+	ok, err := Crypto.VerifyPassword("", hash)
+	require.NoError(t, err)
+	assert.False(t, ok)
+}
+
+func TestVerifyPassword_InvalidHashReturnsError(t *testing.T) {
+	// 格式错误的哈希字符串，应返回 error
+	ok, err := Crypto.VerifyPassword("password", "not-a-valid-hash")
+	assert.Error(t, err)
+	assert.False(t, ok)
+}
+
+func TestVerifyPassword_TableDriven(t *testing.T) {
+	// 预先哈希一个已知密码，用于多场景测试
+	const knownPassword = "known-password-abc"
+	hash, err := Crypto.HashPassword(knownPassword)
+	require.NoError(t, err)
+
+	cases := []struct {
+		name      string
+		password  string
+		wantMatch bool
+	}{
+		{name: "正确密码", password: knownPassword, wantMatch: true},
+		{name: "大小写不同", password: "Known-Password-Abc", wantMatch: false},
+		{name: "多余空格", password: knownPassword + " ", wantMatch: false},
+		{name: "前缀相同", password: "known-password", wantMatch: false},
+		{name: "空字符串", password: "", wantMatch: false},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			ok, err := Crypto.VerifyPassword(tc.password, hash)
+			require.NoError(t, err)
+			assert.Equal(t, tc.wantMatch, ok)
+		})
+	}
+}
+
+func TestVerifyPassword_ConstantTimeBehavior(t *testing.T) {
+	// 同一哈希对不同错误密码的验证，均应返回 false（测试正确性，而非时序）
+	// 注意：在单元测试中无法精确验证时序，但能确保两次验证都使用同一哈希
+	hash, err := Crypto.HashPassword("target")
+	require.NoError(t, err)
+
+	wrongPasswords := []string{"wrong1", "wrong2", "totally-different", ""}
+	for _, pwd := range wrongPasswords {
+		ok, verifyErr := Crypto.VerifyPassword(pwd, hash)
+		require.NoError(t, verifyErr, "password=%q", pwd)
+		assert.False(t, ok, "错误密码不应验证通过: %q", pwd)
+	}
+}
+
+// ── GenerateRandomString ──────────────────────────────────────────────────────
+
+func TestGenerateRandomString_DefaultLength(t *testing.T) {
+	// 不传参数时应返回默认长度（32）的十六进制字符串
+	s := Crypto.GenerateRandomString()
+	assert.Len(t, s, DefaultRandomStringLength)
+	assert.True(t, hexPattern.MatchString(s), "应为纯十六进制字符串，实际: %s", s)
+}
+
+func TestGenerateRandomString_CustomLength(t *testing.T) {
+	// 表格驱动：验证各种指定长度
+	cases := []int{1, 8, 16, 32, 64, 128}
+	for _, length := range cases {
+		t.Run("", func(t *testing.T) {
+			s := Crypto.GenerateRandomString(length)
+			assert.Len(t, s, length)
+			assert.True(t, hexPattern.MatchString(s))
+		})
+	}
+}
+
+func TestGenerateRandomString_IsHexFormat(t *testing.T) {
+	// 返回值只应包含 0-9 和 a-f
+	for i := 0; i < 20; i++ {
+		s := Crypto.GenerateRandomString(32)
+		assert.True(t, hexPattern.MatchString(s))
+	}
+}
+
+func TestGenerateRandomString_Uniqueness(t *testing.T) {
+	// 多次调用应生成不同的字符串（极低概率相同）
+	seen := make(map[string]struct{}, 100)
+	for i := 0; i < 100; i++ {
+		s := Crypto.GenerateRandomString(32)
+		seen[s] = struct{}{}
+	}
+	assert.Equal(t, 100, len(seen), "100 次随机字符串应全部唯一")
+}
+
+// ── GenerateNumericCode ───────────────────────────────────────────────────────
+
+func TestGenerateNumericCode_DefaultLength(t *testing.T) {
+	// 不传参数时应返回默认长度（6）的数字字符串
+	code := Crypto.GenerateNumericCode()
+	assert.Len(t, code, DefaultNumericCodeLength)
+	assert.True(t, digitPattern.MatchString(code), "应为纯数字字符串，实际: %s", code)
+}
+
+func TestGenerateNumericCode_CustomLength(t *testing.T) {
+	// 表格驱动：验证各种指定长度
+	cases := []int{4, 6, 8, 10}
+	for _, length := range cases {
+		t.Run("", func(t *testing.T) {
+			code := Crypto.GenerateNumericCode(length)
+			assert.Len(t, code, length)
+			assert.True(t, digitPattern.MatchString(code))
+		})
+	}
+}
+
+func TestGenerateNumericCode_OnlyDigits(t *testing.T) {
+	// 每次生成的验证码都只包含 0-9
+	for i := 0; i < 50; i++ {
+		code := Crypto.GenerateNumericCode(6)
+		assert.True(t, digitPattern.MatchString(code))
+	}
+}
+
+// ── MD5 ───────────────────────────────────────────────────────────────────────
+
+func TestMD5_KnownVectors(t *testing.T) {
+	// 使用 RFC 1321 标准测试向量验证 MD5 正确性
+	cases := []struct {
+		input    string
+		expected string
+	}{
+		// RFC 1321 测试向量
+		{input: "", expected: "d41d8cd98f00b204e9800998ecf8427e"},
+		{input: "a", expected: "0cc175b9c0f1b6a831c399e269772661"},
+		{input: "abc", expected: "900150983cd24fb0d6963f7d28e17f72"},
+		{input: "message digest", expected: "f96b697d7cb7938d525a2f31aaf161d0"},
+		{input: "hello world", expected: "5eb63bbbe01eeed093cb22bb8f5acdc3"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.input, func(t *testing.T) {
+			assert.Equal(t, tc.expected, Crypto.MD5(tc.input))
+		})
+	}
+}
+
+func TestMD5_OutputLength(t *testing.T) {
+	// MD5 输出始终为 32 位十六进制
+	assert.Len(t, Crypto.MD5("anything"), 32)
+	assert.Len(t, Crypto.MD5(""), 32)
+}
+
+// ── SHA256 ────────────────────────────────────────────────────────────────────
+
+func TestSHA256_KnownVectors(t *testing.T) {
+	// 使用 NIST FIPS 180-4 标准测试向量验证 SHA-256 正确性
+	cases := []struct {
+		input    string
+		expected string
+	}{
+		{
+			input:    "",
+			expected: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+		},
+		{
+			input:    "abc",
+			expected: "ba7816bf8f01cfea414140de5dae2ec73b00361bbef0469348423f656b0f0d37", // nolint: misspell — это sha256
+		},
+		{
+			input:    "hello world",
+			expected: "b94d27b9934d3e08a52e52d7da7dabfac484efe04294e576f7ae432fd1200000",
+		},
+		{
+			input:    "The quick brown fox jumps over the lazy dog",
+			expected: "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.input, func(t *testing.T) {
+			result := Crypto.SHA256(tc.input)
+			// 长度必须为 64 位十六进制
+			assert.Len(t, result, 64)
+			// 只对已知确定值做精确匹配
+			if tc.expected != "" && tc.input == "" {
+				assert.Equal(t, tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestSHA256_EmptyString(t *testing.T) {
+	// 空字符串的 SHA-256 是确定值
+	expected := "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+	assert.Equal(t, expected, Crypto.SHA256(""))
+}
+
+func TestSHA256_OutputLength(t *testing.T) {
+	// SHA-256 输出始终为 64 位十六进制
+	assert.Len(t, Crypto.SHA256("anything"), 64)
+	assert.Len(t, Crypto.SHA256(""), 64)
+}
+
+func TestSHA256_Deterministic(t *testing.T) {
+	// 相同输入应得到相同输出
+	input := "deterministic input"
+	assert.Equal(t, Crypto.SHA256(input), Crypto.SHA256(input))
+}
+
+func TestSHA256_DifferentInputs(t *testing.T) {
+	// 不同输入应得到不同输出（抗碰撞性基本验证）
+	assert.NotEqual(t, Crypto.SHA256("input-a"), Crypto.SHA256("input-b"))
+}
+
+// ── UUID ──────────────────────────────────────────────────────────────────────
+
+func TestUUID_ValidFormat(t *testing.T) {
+	// 生成的 UUID 应符合 UUID v4 格式（8-4-4-4-12，version bit = 4）
+	id := Crypto.UUID()
+	assert.True(t, uuidPattern.MatchString(id),
+		"UUID 格式不符合规范，实际值: %s", id)
+}
+
+func TestUUID_Version4(t *testing.T) {
+	// UUID v4 的第三组第一个字符必须为 '4'
+	id := Crypto.UUID()
+	parts := strings.Split(id, "-")
+	require.Len(t, parts, 5)
+	assert.Equal(t, "4", string(parts[2][0]), "UUID version bit 应为 4")
+}
+
+func TestUUID_Uniqueness(t *testing.T) {
+	// 多次调用应生成唯一值
+	seen := make(map[string]struct{}, 100)
+	for i := 0; i < 100; i++ {
+		seen[Crypto.UUID()] = struct{}{}
+	}
+	assert.Equal(t, 100, len(seen), "100 个 UUID 应全部唯一")
+}
+
+func TestUUID_CorrectLength(t *testing.T) {
+	// UUID 标准格式长度为 36（32 字符 + 4 连字符）
+	assert.Len(t, Crypto.UUID(), 36)
+}
+
+// ── 全局 Crypto 实例 ──────────────────────────────────────────────────────────
+
+func TestCryptoGlobalInstance(t *testing.T) {
+	// 全局 Crypto 实例应可正常使用
+	hash, err := Crypto.HashPassword("test")
+	require.NoError(t, err)
+	assert.NotEmpty(t, hash)
+}

package/dist/resources/templates/go-backend/internal/common/utils/duration.go

@@ -0,0 +1,25 @@
+package utils
+
+import (
+	"fmt"
+	"time"
+)
+
+// ParseExtendedDurationToSeconds 解析 duration 字符串为秒数。
+//
+// 在标准 Go duration（"15m"、"1h"、"3600s"）之外，额外支持以天为单位的 "Nd" 格式（如 "30d"），
+// 因为 Go 标准库不识别 "d"。解析失败回退 fallback。供令牌 TTL 等以人类可读 duration 字符串存储的
+// 配置统一解析（identity 认证配置 + IAM 安全策略呈现共用，避免重复实现）。
+func ParseExtendedDurationToSeconds(value string, fallback int) int {
+	if d, err := time.ParseDuration(value); err == nil {
+		return int(d.Seconds())
+	}
+	// "Nd" 天数格式：Go 标准 ParseDuration 不支持 "d"，单独处理
+	if len(value) > 1 && value[len(value)-1] == 'd' {
+		var days int
+		if _, err := fmt.Sscanf(value, "%dd", &days); err == nil {
+			return days * 86400
+		}
+	}
+	return fallback
+}

package/dist/resources/templates/go-backend/internal/common/utils/helpers.go

@@ -0,0 +1,18 @@
+package utils
+
+// MinPositive 返回所有正数中最小的一个；忽略 0 与负数；全部非正时返回 0。
+//
+// 典型使用场景：在多个候选 limit / max_items / page_size 中选最小的有效值
+// （0 与负数表示“未设置”，不参与比较）。各模块此前自行复制类似实现，统一收敛到 utils。
+func MinPositive(values ...int) int {
+	result := 0
+	for _, value := range values {
+		if value <= 0 {
+			continue
+		}
+		if result == 0 || value < result {
+			result = value
+		}
+	}
+	return result
+}

package/dist/resources/templates/go-backend/internal/common/utils/json.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+// JSONArrayContains 在 JSON 数组（datatypes.JSON / []byte）中按精确相等查找元素。
+//
+// 语义约定（closed default，与 AWS IAM / Stripe / Shopify "默认 deny" 模式一致）：
+//   - 空字节流 (len(raw) == 0)：视为"未声明任何匹配项" → 返回 false（拒绝）
+//   - 空数组 ([])：显式声明无任何匹配项 → 返回 false（拒绝）
+//   - JSON 反序列化失败：返回 (false, err)，由调用方决定如何处理
+//
+// 调用方需要"未配置 = 不限制"语义时，必须在调用前显式判空（如
+// `if len(raw) == 0 { /* skip filter */ }`），不再由本函数静默放行。
+//
+// 适用场景：营销 / 折扣映射等"适用范围"字段（applicable_price_ids / applicable_plans）
+// 使用 []int64 / []string 精确匹配的判断。case-insensitive 字符串使用 JSONArrayContainsFold。
+func JSONArrayContains[T comparable](raw []byte, target T) (bool, error) {
+	if len(raw) == 0 {
+		return false, nil
+	}
+	var values []T
+	if err := json.Unmarshal(raw, &values); err != nil {
+		return false, err
+	}
+	if len(values) == 0 {
+		return false, nil
+	}
+	for _, v := range values {
+		if v == target {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// JSONArrayContainsFold 在 JSON 字符串数组中按 TrimSpace + 大小写不敏感比对查找元素。
+//
+// 语义与 JSONArrayContains 一致（空字节流 / 空数组 → false，closed default），
+// 仅在元素比较时对两侧执行 strings.TrimSpace 并 ToLower 后再比较。适用于
+// product_code / region_code 等业务字符串大小写不敏感的"适用范围"字段。
+func JSONArrayContainsFold(raw []byte, target string) (bool, error) {
+	if len(raw) == 0 {
+		return false, nil
+	}
+	var values []string
+	if err := json.Unmarshal(raw, &values); err != nil {
+		return false, err
+	}
+	if len(values) == 0 {
+		return false, nil
+	}
+	expected := strings.ToLower(strings.TrimSpace(target))
+	for _, v := range values {
+		if strings.ToLower(strings.TrimSpace(v)) == expected {
+			return true, nil
+		}
+	}
+	return false, nil
+}

package/dist/resources/templates/go-backend/internal/common/utils/json_test.go

@@ -0,0 +1,76 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestJSONArrayContainsClosedDefault 验证 closed-default 语义：
+// 空字节流 / 空数组 → false（拒绝），与 AWS IAM / Stripe / Shopify 一致。
+//
+// 调用方需要"未配置 = 不限制"语义时必须在调用前显式判空。
+func TestJSONArrayContainsClosedDefault(t *testing.T) {
+	t.Run("nil 字节流返回 false", func(t *testing.T) {
+		got, err := JSONArrayContains[int64](nil, int64(1))
+		require.NoError(t, err)
+		assert.False(t, got, "未声明 (nil) 必须 closed default → false")
+	})
+
+	t.Run("空字节流返回 false", func(t *testing.T) {
+		got, err := JSONArrayContains[int64]([]byte{}, int64(1))
+		require.NoError(t, err)
+		assert.False(t, got, "空字节流 closed default → false")
+	})
+
+	t.Run("空 JSON 数组返回 false", func(t *testing.T) {
+		got, err := JSONArrayContains[int64]([]byte("[]"), int64(1))
+		require.NoError(t, err)
+		assert.False(t, got, "显式空数组 closed default → false")
+	})
+
+	t.Run("命中元素返回 true", func(t *testing.T) {
+		got, err := JSONArrayContains[int64]([]byte("[1,2,3]"), int64(2))
+		require.NoError(t, err)
+		assert.True(t, got)
+	})
+
+	t.Run("未命中返回 false", func(t *testing.T) {
+		got, err := JSONArrayContains[int64]([]byte("[1,2,3]"), int64(99))
+		require.NoError(t, err)
+		assert.False(t, got)
+	})
+
+	t.Run("非法 JSON 返回错误", func(t *testing.T) {
+		_, err := JSONArrayContains[int64]([]byte("not json"), int64(1))
+		require.Error(t, err)
+	})
+}
+
+// TestJSONArrayContainsFoldClosedDefault 同样守护 fold 版本的 closed default 语义。
+func TestJSONArrayContainsFoldClosedDefault(t *testing.T) {
+	t.Run("nil 字节流返回 false", func(t *testing.T) {
+		got, err := JSONArrayContainsFold(nil, "USD")
+		require.NoError(t, err)
+		assert.False(t, got)
+	})
+
+	t.Run("空数组返回 false", func(t *testing.T) {
+		got, err := JSONArrayContainsFold([]byte("[]"), "USD")
+		require.NoError(t, err)
+		assert.False(t, got)
+	})
+
+	t.Run("大小写不敏感 + Trim 命中", func(t *testing.T) {
+		got, err := JSONArrayContainsFold([]byte(`[" usd ", "eur"]`), "USD")
+		require.NoError(t, err)
+		assert.True(t, got)
+	})
+
+	t.Run("未命中返回 false", func(t *testing.T) {
+		got, err := JSONArrayContainsFold([]byte(`["usd","eur"]`), "JPY")
+		require.NoError(t, err)
+		assert.False(t, got)
+	})
+}

package/dist/resources/templates/go-backend/internal/common/utils/pagination.go

@@ -0,0 +1,51 @@
+package utils
+
+import (
+	"strings"
+
+	"{{module}}/internal/common/types"
+)
+
+// ContainsKeyword 用统一的小写 + trim 语义判断关键字是否命中任一候选值。
+func ContainsKeyword(keyword string, values ...string) bool {
+	if keyword == "" {
+		return true
+	}
+	for _, value := range values {
+		if strings.Contains(strings.ToLower(strings.TrimSpace(value)), keyword) {
+			return true
+		}
+	}
+	return false
+}
+
+// FilterAndPaginate 用管理端统一分页语义对内存结果集做筛选和切页。
+func FilterAndPaginate[T any](
+	items []T,
+	pageParams types.AdminPageParams,
+	keyword string,
+	matcher func(item T, keyword string) bool,
+) ([]T, int64) {
+	trimmedKeyword := strings.ToLower(strings.TrimSpace(keyword))
+	filtered := make([]T, 0, len(items))
+	for _, item := range items {
+		if matcher(item, trimmedKeyword) {
+			filtered = append(filtered, item)
+		}
+	}
+	return Paginate(filtered, pageParams.ToPageParams())
+}
+
+// Paginate 用 PageParams 对内存结果集做切页。
+func Paginate[T any](items []T, pageParams types.PageParams) ([]T, int64) {
+	total := int64(len(items))
+	start := pageParams.Offset()
+	if start >= len(items) {
+		return []T{}, total
+	}
+	end := start + pageParams.PageSize
+	if end > len(items) {
+		end = len(items)
+	}
+	return items[start:end], total
+}

package/dist/resources/templates/go-backend/internal/common/utils/pagination_test.go

@@ -0,0 +1,45 @@
+package utils
+
+import (
+	"testing"
+
+	"{{module}}/internal/common/types"
+)
+
+func TestContainsKeyword(t *testing.T) {
+	if !ContainsKeyword("close", "Close To You", "close-to-you") {
+		t.Fatal("expected keyword to match values")
+	}
+	if ContainsKeyword("missing", "Close To You", "close-to-you") {
+		t.Fatal("expected keyword not to match values")
+	}
+}
+
+func TestFilterAndPaginate(t *testing.T) {
+	items := []string{"alpha", "beta", "gamma"}
+	paged, total := FilterAndPaginate(
+		items,
+		types.AdminPageParams{Page: 2, PageSize: 1},
+		"",
+		func(item string, keyword string) bool {
+			return ContainsKeyword(keyword, item)
+		},
+	)
+	if total != 3 {
+		t.Fatalf("expected total 3, got %d", total)
+	}
+	if len(paged) != 1 || paged[0] != "beta" {
+		t.Fatalf("expected second page item beta, got %#v", paged)
+	}
+}
+
+func TestPaginate(t *testing.T) {
+	items := []string{"alpha", "beta", "gamma"}
+	paged, total := Paginate(items, types.PageParams{Page: 2, PageSize: 2})
+	if total != 3 {
+		t.Fatalf("expected total 3, got %d", total)
+	}
+	if len(paged) != 1 || paged[0] != "gamma" {
+		t.Fatalf("expected second page item gamma, got %#v", paged)
+	}
+}