《互联网产品的服务端架构·产品、流量与基础能力》3.1 注册登录与第三方身份

// file: internal/account/signup.go
// tier: L1
// verify: go test ./internal/account/

package account

import (
	"fmt"
	"strings"
)

// Identity 是外部身份源提供的事实：哪个平台、哪个不可变 ID。
// 手机号、邮箱这类可能变化的标识不应直接塞进 ExternalID。
type Identity struct {
	Provider   string
	ExternalID string
}

func (i Identity) key() string {
	return i.Provider + "\x00" + i.ExternalID
}

// Account 是站内主体，可以有多个身份。一个账号绑手机号、微信、Apple
// 是常态，账号 ID 必须独立于任何一种登录方式。
type Account struct {
	ID         string
	Identities []Identity
}

// Link 把外部身份绑定到指定账号。同一 provider+externalID 只能属于一个
// 账号；重复绑定同一账号是幂等的；空字段和未知账号直接报错。
func Link(accounts []Account, accountID string, identity Identity) ([]Account, error) {
	if strings.TrimSpace(accountID) == "" {
		return nil, fmt.Errorf("account: account id is required")
	}
	if strings.TrimSpace(identity.Provider) == "" || strings.TrimSpace(identity.ExternalID) == "" {
		return nil, fmt.Errorf("account: identity provider and external id are required")
	}

	target := -1
	for i := range accounts {
		if accounts[i].ID == accountID {
			target = i
			break
		}
	}
	if target < 0 {
		return nil, fmt.Errorf("account: account %q not found", accountID)
	}

	for _, a := range accounts {
		for _, id := range a.Identities {
			if id.key() != identity.key() {
				continue
			}
			if a.ID == accountID {
				return cloneAccounts(accounts), nil
			}
			return nil, fmt.Errorf("account: identity %s/%s already bound to %s",
				identity.Provider, identity.ExternalID, a.ID)
		}
	}

	out := cloneAccounts(accounts)
	out[target].Identities = append(out[target].Identities, identity)
	return out, nil
}

// cloneAccounts 复制切片和身份列表，避免调用方持有的旧切片被意外修改。
func cloneAccounts(accounts []Account) []Account {
	out := make([]Account, len(accounts))
	for i, a := range accounts {
		out[i] = Account{ID: a.ID, Identities: append([]Identity(nil), a.Identities...)}
	}
	return out
}

// file: internal/account/signup_test.go
// tier: L1
// verify: go test ./internal/account/

package account

import "testing"

func TestLinkAddsIdentity(t *testing.T) {
	base := []Account{{ID: "a1"}}
	got, err := Link(base, "a1", Identity{Provider: "wechat", ExternalID: "wx-1001"})
	if err != nil {
		t.Fatal(err)
	}
	if len(got[0].Identities) != 1 {
		t.Fatalf("identities = %d, want 1", len(got[0].Identities))
	}
	if len(base[0].Identities) != 0 {
		t.Fatal("Link mutated the input account")
	}
}

func TestLinkIsIdempotentForSameAccount(t *testing.T) {
	accounts := []Account{{ID: "a1", Identities: []Identity{{Provider: "apple", ExternalID: "ap-7"}}}}
	got, err := Link(accounts, "a1", Identity{Provider: "apple", ExternalID: "ap-7"})
	if err != nil {
		t.Fatal(err)
	}
	if len(got[0].Identities) != 1 {
		t.Fatalf("identities = %d, want 1", len(got[0].Identities))
	}
}

func TestLinkRejectsIdentityOwnedByAnotherAccount(t *testing.T) {
	accounts := []Account{
		{ID: "a1", Identities: []Identity{{Provider: "wechat", ExternalID: "wx-1001"}}},
		{ID: "a2"},
	}
	if _, err := Link(accounts, "a2", Identity{Provider: "wechat", ExternalID: "wx-1001"}); err == nil {
		t.Fatal("want conflict error for identity already bound to a1")
	}
}

func TestLinkValidatesInput(t *testing.T) {
	accounts := []Account{{ID: "a1"}}
	cases := []struct {
		name     string
		account  string
		identity Identity
	}{
		{"empty-provider", "a1", Identity{ExternalID: "x"}},
		{"empty-external-id", "a1", Identity{Provider: "wechat"}},
		{"unknown-account", "missing", Identity{Provider: "wechat", ExternalID: "x"}},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			if _, err := Link(accounts, c.account, c.identity); err == nil {
				t.Fatal("want error")
			}
		})
	}
}

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

ok  	webapp/internal/account	0.288s