《互联网产品的服务端架构·内容、社交与实时互动》5.1 关注、好友与双向关系

DELETE FROM relation WHERE from_id = 'B' AND to_id = 'A' AND kind = 'friend';

// file: internal/social/relation.go
// tier: L1
// verify: go test ./internal/social/

package social

import "fmt"

// Kind 是关系边的类型。follow 是单向关注，friend 是双向好友，
// block 是单向拉黑。三者的读写语义不同，不能压缩成用户表上的一个字段。
type Kind string

const (
	Follow Kind = "follow"
	Friend Kind = "friend"
	Block  Kind = "block"
)

// Edge 是一条有方向的关系记录。From 发起关系，To 承接关系。
// 一条 friend 边只代表半条好友关系，完整好友需要两个方向各有一条。
type Edge struct {
	From string
	To   string
	Kind Kind
}

// Validate 检查一条关系边能否写入。自环、空 ID 和未知 Kind
// 必须在入口拒绝，不能留给查询层去猜。
func Validate(e Edge) error {
	if e.From == "" || e.To == "" {
		return fmt.Errorf("social: edge has empty id: %q -> %q", e.From, e.To)
	}
	if e.From == e.To {
		return fmt.Errorf("social: self edge on %q", e.From)
	}
	switch e.Kind {
	case Follow, Friend, Block:
		return nil
	default:
		return fmt.Errorf("social: unknown kind %q", e.Kind)
	}
}

// Mutual 判断 a 与 b 之间是否存在可确认的关系。
// friend 必须双向都有 friend 边；follow 单向即可；block 不构成关系，
// 它是否否决访问由 CanView 负责，不在这里混入。
func Mutual(edges []Edge, a, b string) bool {
	if a == "" || b == "" || a == b {
		return false
	}
	var abFriend, baFriend, abFollow, baFollow bool
	for _, e := range edges {
		switch {
		case e.From == a && e.To == b:
			switch e.Kind {
			case Friend:
				abFriend = true
			case Follow:
				abFollow = true
			}
		case e.From == b && e.To == a:
			switch e.Kind {
			case Friend:
				baFriend = true
			case Follow:
				baFollow = true
			}
		}
	}
	if abFriend && baFriend {
		return true
	}
	return abFollow || baFollow
}

// file: internal/social/relation_test.go
// tier: L1
// verify: go test ./internal/social/

package social

import "testing"

func TestValidateAcceptsKnownKinds(t *testing.T) {
	cases := []Edge{
		{From: "u1", To: "u2", Kind: Follow},
		{From: "u1", To: "u2", Kind: Friend},
		{From: "u1", To: "u2", Kind: Block},
	}
	for _, e := range cases {
		if err := Validate(e); err != nil {
			t.Fatalf("Validate(%+v) = %v, want nil", e, err)
		}
	}
}

func TestValidateRejectsBadEdges(t *testing.T) {
	cases := []struct {
		name string
		edge Edge
	}{
		{"empty-from", Edge{To: "u2", Kind: Follow}},
		{"empty-to", Edge{From: "u1", Kind: Follow}},
		{"self-loop", Edge{From: "u1", To: "u1", Kind: Friend}},
		{"unknown-kind", Edge{From: "u1", To: "u2", Kind: Kind("mute")}},
		{"empty-kind", Edge{From: "u1", To: "u2"}},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			if err := Validate(c.edge); err == nil {
				t.Fatalf("Validate(%+v) = nil, want error", c.edge)
			}
		})
	}
}

func TestMutualFriendNeedsBothDirections(t *testing.T) {
	oneWay := []Edge{{From: "u1", To: "u2", Kind: Friend}}
	if Mutual(oneWay, "u1", "u2") {
		t.Fatal("one-sided friend edge must not be mutual")
	}

	both := []Edge{
		{From: "u1", To: "u2", Kind: Friend},
		{From: "u2", To: "u1", Kind: Friend},
	}
	if !Mutual(both, "u1", "u2") {
		t.Fatal("two-sided friend edges must be mutual")
	}
	if !Mutual(both, "u2", "u1") {
		t.Fatal("Mutual must be symmetric for friends")
	}
}

func TestMutualFollowIsOneWay(t *testing.T) {
	edges := []Edge{{From: "u1", To: "u2", Kind: Follow}}
	if !Mutual(edges, "u1", "u2") {
		t.Fatal("single follow edge must be enough")
	}
	if !Mutual(edges, "u2", "u1") {
		t.Fatal("relation existence is symmetric for the query")
	}
}

func TestMutualIgnoresBlockAndDuplicates(t *testing.T) {
	edges := []Edge{
		{From: "u1", To: "u2", Kind: Block},
		{From: "u2", To: "u1", Kind: Block},
	}
	if Mutual(edges, "u1", "u2") {
		t.Fatal("block edges must not create a mutual relation")
	}

	dupes := []Edge{
		{From: "u1", To: "u2", Kind: Follow},
		{From: "u1", To: "u2", Kind: Follow},
		{From: "u1", To: "u2", Kind: Follow},
	}
	if !Mutual(dupes, "u1", "u2") {
		t.Fatal("duplicate follow edges must remain a valid relation")
	}
}

func TestMutualRejectsEmptyAndSelf(t *testing.T) {
	edges := []Edge{{From: "u1", To: "u1", Kind: Follow}}
	if Mutual(edges, "u1", "u1") {
		t.Fatal("self relation must not be mutual")
	}
	if Mutual(edges, "", "u1") {
		t.Fatal("empty id must not be mutual")
	}
	if Mutual(nil, "u1", "u2") {
		t.Fatal("nil edges must not be mutual")
	}
}

cd .local/checks/webapp-lab && go test ./internal/social/ -run 'TestValidate|TestMutual' -count=1 -v

=== RUN   TestValidateAcceptsKnownKinds
--- PASS: TestValidateAcceptsKnownKinds (0.00s)
=== RUN   TestValidateRejectsBadEdges
=== RUN   TestValidateRejectsBadEdges/empty-from
=== RUN   TestValidateRejectsBadEdges/empty-to
=== RUN   TestValidateRejectsBadEdges/self-loop
=== RUN   TestValidateRejectsBadEdges/unknown-kind
=== RUN   TestValidateRejectsBadEdges/empty-kind
--- PASS: TestValidateRejectsBadEdges (0.00s)
    --- PASS: TestValidateRejectsBadEdges/empty-from (0.00s)
    --- PASS: TestValidateRejectsBadEdges/empty-to (0.00s)
    --- PASS: TestValidateRejectsBadEdges/self-loop (0.00s)
    --- PASS: TestValidateRejectsBadEdges/unknown-kind (0.00s)
    --- PASS: TestValidateRejectsBadEdges/empty-kind (0.00s)
=== RUN   TestMutualFriendNeedsBothDirections
--- PASS: TestMutualFriendNeedsBothDirections (0.00s)
=== RUN   TestMutualFollowIsOneWay
--- PASS: TestMutualFollowIsOneWay (0.00s)
=== RUN   TestMutualIgnoresBlockAndDuplicates
--- PASS: TestMutualIgnoresBlockAndDuplicates (0.00s)
=== RUN   TestMutualRejectsEmptyAndSelf
--- PASS: TestMutualRejectsEmptyAndSelf (0.00s)
PASS
ok  	webapp/internal/social	0.352s