《互联网产品的服务端架构·交易、增长与平台化》1.1 商品模型与 SKU

// file: internal/catalog/sku.go
// tier: L1
// verify: go test ./internal/catalog/

// Package catalog holds the product, SKU, stock and reconciliation rules used
// by the transaction service in this book.
package catalog

import (
	"errors"
	"fmt"
	"net/url"
	"sort"
	"strings"
)

// SKU is the smallest sellable unit. Price lives here rather than on the
// product because two variants of the same product may sell at different
// prices, and a price change on one variant must not touch the other.
type SKU struct {
	ID         string
	ProductID  string
	Attrs      map[string]string
	PriceCents int64
	Status     string
}

const (
	StatusDraft   = "draft"
	StatusOnSale  = "on_sale"
	StatusOffSale = "off_sale"
)

var (
	ErrInvalidSKU    = errors.New("catalog: invalid sku")
	ErrInvalidPrice  = errors.New("catalog: invalid price")
	ErrInvalidStatus = errors.New("catalog: invalid status")
	ErrInvalidAttr   = errors.New("catalog: invalid attribute")
)

// Normalize validates a SKU and returns a copy that does not alias the
// caller's attribute map. Rejecting empty keys and values keeps the canonical
// key unambiguous: an attribute that exists but has no value is a data bug,
// not a variant.
func Normalize(s SKU) (SKU, error) {
	if strings.TrimSpace(s.ID) == "" || strings.TrimSpace(s.ProductID) == "" {
		return SKU{}, ErrInvalidSKU
	}
	if s.PriceCents < 0 {
		return SKU{}, ErrInvalidPrice
	}
	switch s.Status {
	case StatusDraft, StatusOnSale, StatusOffSale:
	default:
		return SKU{}, ErrInvalidStatus
	}
	attrs := make(map[string]string, len(s.Attrs))
	for k, v := range s.Attrs {
		if strings.TrimSpace(k) == "" || strings.TrimSpace(v) == "" {
			return SKU{}, fmt.Errorf("%w: empty key or value", ErrInvalidAttr)
		}
		attrs[k] = v
	}
	s.Attrs = attrs
	return s, nil
}

// Key returns the canonical identity of a product variant. Attribute order in
// the map never changes the result, and url escaping keeps a value containing
// "&" or "=" from colliding with the separator. Two rows that describe the
// same variant therefore produce the same key no matter how the editor saved
// them.
func Key(s SKU) (string, error) {
	n, err := Normalize(s)
	if err != nil {
		return "", err
	}
	keys := make([]string, 0, len(n.Attrs))
	for k := range n.Attrs {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	pairs := make([]string, 0, len(keys))
	for _, k := range keys {
		pairs = append(pairs, url.QueryEscape(k)+"="+url.QueryEscape(n.Attrs[k]))
	}
	return n.ProductID + "|" + strings.Join(pairs, "&"), nil
}

// file: internal/catalog/sku_test.go
// tier: L1
// verify: go test ./internal/catalog/

package catalog

import (
	"errors"
	"testing"
)

func validSKU() SKU {
	return SKU{
		ID:         "sku-1001",
		ProductID:  "prod-coffee-set",
		Attrs:      map[string]string{"color": "red", "size": "m"},
		PriceCents: 12900,
		Status:     StatusOnSale,
	}
}

func TestNormalizeReturnsIsolatedCopy(t *testing.T) {
	in := validSKU()
	got, err := Normalize(in)
	if err != nil {
		t.Fatal(err)
	}
	if got.ID != in.ID || got.ProductID != in.ProductID || got.PriceCents != in.PriceCents {
		t.Fatalf("normalize changed scalar fields: %+v", got)
	}
	got.Attrs["color"] = "blue"
	if in.Attrs["color"] != "red" {
		t.Fatal("Normalize aliased the caller's attribute map")
	}
}

func TestNormalizeRejectsBadFields(t *testing.T) {
	cases := []struct {
		name string
		in   SKU
		want error
	}{
		{"empty-id", func() SKU { s := validSKU(); s.ID = " "; return s }(), ErrInvalidSKU},
		{"empty-product", func() SKU { s := validSKU(); s.ProductID = ""; return s }(), ErrInvalidSKU},
		{"negative-price", func() SKU { s := validSKU(); s.PriceCents = -1; return s }(), ErrInvalidPrice},
		{"unknown-status", func() SKU { s := validSKU(); s.Status = "selling"; return s }(), ErrInvalidStatus},
		{"empty-attr-key", func() SKU { s := validSKU(); s.Attrs = map[string]string{"": "red"}; return s }(), ErrInvalidAttr},
		{"blank-attr-value", func() SKU { s := validSKU(); s.Attrs = map[string]string{"color": "  "}; return s }(), ErrInvalidAttr},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			if _, err := Normalize(c.in); !errors.Is(err, c.want) {
				t.Fatalf("err = %v, want %v", err, c.want)
			}
		})
	}
}

func TestKeyIsStableAcrossAttributeOrder(t *testing.T) {
	a := validSKU()
	a.Attrs = map[string]string{"color": "red", "size": "m"}
	b := validSKU()
	b.Attrs = map[string]string{"size": "m", "color": "red"}

	ka, err := Key(a)
	if err != nil {
		t.Fatal(err)
	}
	kb, err := Key(b)
	if err != nil {
		t.Fatal(err)
	}
	if ka != kb {
		t.Fatalf("keys differ by map order: %q vs %q", ka, kb)
	}
	const want = "prod-coffee-set|color=red&size=m"
	if ka != want {
		t.Fatalf("key = %q, want %q", ka, want)
	}
}

func TestKeyEscapesSeparators(t *testing.T) {
	merged := validSKU()
	merged.Attrs = map[string]string{"variant": "red&size=m"}
	split := validSKU()
	split.Attrs = map[string]string{"variant": "red", "size": "m"}

	km, err := Key(merged)
	if err != nil {
		t.Fatal(err)
	}
	ks, err := Key(split)
	if err != nil {
		t.Fatal(err)
	}
	if km == ks {
		t.Fatalf("ambiguous attribute values collapsed to %q", km)
	}
}

func TestKeyAllowsEmptyAttrs(t *testing.T) {
	s := validSKU()
	s.Attrs = nil
	got, err := Key(s)
	if err != nil {
		t.Fatal(err)
	}
	if got != "prod-coffee-set|" {
		t.Fatalf("key = %q, want product prefix with empty attrs", got)
	}
}

cd .local/checks/webapp-lab && go test ./internal/catalog/ -count=1

ok  	webapp/internal/catalog	0.228s