《互联网产品的服务端架构·内容、社交与实时互动》8.2 单聊、群聊与系统消息

// file: internal/im/conversation.go
// tier: L1
// verify: go test ./internal/im/

package im

import (
	"errors"
	"fmt"
)

// ConvType 是会话类型。单聊、群聊和系统会话的成员规则不同。
type ConvType string

const (
	ConvSingle ConvType = "single"
	ConvGroup  ConvType = "group"
	ConvSystem ConvType = "system"

	// SystemSender 是唯一允许向系统会话写入的发送方。
	SystemSender = "system"
)

// Conversation 描述一个会话及其成员。MaxMembers 只对群聊生效。
type Conversation struct {
	ID         string
	Type       ConvType
	Members    []string
	MaxMembers int
}

// Validate 检查会话类型、成员和人数上限。
func (c Conversation) Validate() error {
	if c.ID == "" {
		return errors.New("im: conversation id is empty")
	}
	if len(c.Members) == 0 {
		return errors.New("im: conversation has no members")
	}
	seen := make(map[string]struct{}, len(c.Members))
	for _, m := range c.Members {
		if m == "" {
			return errors.New("im: conversation has an empty member")
		}
		if _, ok := seen[m]; ok {
			return fmt.Errorf("im: duplicate member %q", m)
		}
		seen[m] = struct{}{}
	}
	switch c.Type {
	case ConvSingle:
		if len(c.Members) != 2 {
			return fmt.Errorf("im: single conversation needs 2 members, got %d", len(c.Members))
		}
	case ConvGroup:
		if c.MaxMembers <= 0 {
			return fmt.Errorf("im: group max members %d must be positive", c.MaxMembers)
		}
		if len(c.Members) > c.MaxMembers {
			return fmt.Errorf("im: group has %d members, limit %d", len(c.Members), c.MaxMembers)
		}
	case ConvSystem:
		// 系统会话的成员是接收者，发送方固定为 SystemSender。
	default:
		return fmt.Errorf("im: unknown conversation type %q", c.Type)
	}
	return nil
}

// CanSend 判断 sender 能否向会话写入消息。
func CanSend(c Conversation, sender string) error {
	if err := c.Validate(); err != nil {
		return err
	}
	if sender == "" {
		return errors.New("im: sender is empty")
	}
	if c.Type == ConvSystem {
		if sender != SystemSender {
			return fmt.Errorf("im: system conversation rejects sender %q", sender)
		}
		return nil
	}
	for _, m := range c.Members {
		if m == sender {
			return nil
		}
	}
	return fmt.Errorf("im: sender %q is not a member of %q", sender, c.ID)
}

// file: internal/im/conversation_test.go
// tier: L1
// verify: go test ./internal/im/

package im

import "testing"

func TestValidateSingleNeedsExactlyTwo(t *testing.T) {
	ok := Conversation{ID: "c1", Type: ConvSingle, Members: []string{"u1", "u2"}}
	if err := ok.Validate(); err != nil {
		t.Fatalf("Validate(two members) = %v, want nil", err)
	}
	for _, members := range [][]string{{"u1"}, {"u1", "u2", "u3"}} {
		c := Conversation{ID: "c1", Type: ConvSingle, Members: members}
		if err := c.Validate(); err == nil {
			t.Fatalf("Validate(single with %d members) = nil, want error", len(members))
		}
	}
}

func TestValidateGroupMemberLimit(t *testing.T) {
	cases := []struct {
		name    string
		members []string
		max     int
		wantErr bool
	}{
		{"one member", []string{"u1"}, 3, false},
		{"at limit", []string{"u1", "u2", "u3"}, 3, false},
		{"over limit", []string{"u1", "u2", "u3", "u4"}, 3, true},
		{"zero max", []string{"u1"}, 0, true},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			c := Conversation{ID: "g1", Type: ConvGroup, Members: tc.members, MaxMembers: tc.max}
			err := c.Validate()
			if tc.wantErr && err == nil {
				t.Fatal("Validate() = nil, want error")
			}
			if !tc.wantErr && err != nil {
				t.Fatalf("Validate() = %v, want nil", err)
			}
		})
	}
}

func TestValidateRejectsUnknownAndEmpty(t *testing.T) {
	cases := []Conversation{
		{ID: "c1", Type: ConvSingle},
		{ID: "c1", Type: ConvSingle, Members: []string{"u1", ""}},
		{ID: "c1", Type: ConvSingle, Members: []string{"u1", "u1"}},
		{ID: "c1", Type: "channel", Members: []string{"u1"}},
		{ID: "", Type: ConvGroup, Members: []string{"u1"}, MaxMembers: 5},
	}
	for i, c := range cases {
		if err := c.Validate(); err == nil {
			t.Fatalf("case %d: Validate(%+v) = nil, want error", i, c)
		}
	}
}

func TestCanSendChecksMembership(t *testing.T) {
	single := Conversation{ID: "c1", Type: ConvSingle, Members: []string{"u1", "u2"}}
	if err := CanSend(single, "u1"); err != nil {
		t.Fatalf("CanSend(member) = %v, want nil", err)
	}
	if err := CanSend(single, "u3"); err == nil {
		t.Fatal("CanSend(non-member) = nil, want error")
	}
	group := Conversation{ID: "g1", Type: ConvGroup, Members: []string{"u1", "u2"}, MaxMembers: 10}
	if err := CanSend(group, "u2"); err != nil {
		t.Fatalf("CanSend(group member) = %v, want nil", err)
	}
}

func TestCanSendSystemOnlyFromSystemSender(t *testing.T) {
	system := Conversation{ID: "s1", Type: ConvSystem, Members: []string{"u1"}}
	if err := CanSend(system, SystemSender); err != nil {
		t.Fatalf("CanSend(system) = %v, want nil", err)
	}
	if err := CanSend(system, "u1"); err == nil {
		t.Fatal("CanSend(user to system conversation) = nil, want error")
	}
}

cd .local/checks/webapp-lab && go test ./internal/im/ -run '^(TestValidateSingleNeedsExactlyTwo|TestValidateGroupMemberLimit|TestValidateRejectsUnknownAndEmpty|TestCanSendChecksMembership|TestCanSendSystemOnlyFromSystemSender)$' -count=1 -v

=== RUN   TestValidateSingleNeedsExactlyTwo
--- PASS: TestValidateSingleNeedsExactlyTwo (0.00s)
=== RUN   TestValidateGroupMemberLimit
=== RUN   TestValidateGroupMemberLimit/one_member
=== RUN   TestValidateGroupMemberLimit/at_limit
=== RUN   TestValidateGroupMemberLimit/over_limit
=== RUN   TestValidateGroupMemberLimit/zero_max
--- PASS: TestValidateGroupMemberLimit (0.00s)
    --- PASS: TestValidateGroupMemberLimit/one_member (0.00s)
    --- PASS: TestValidateGroupMemberLimit/at_limit (0.00s)
    --- PASS: TestValidateGroupMemberLimit/over_limit (0.00s)
    --- PASS: TestValidateGroupMemberLimit/zero_max (0.00s)
=== RUN   TestValidateRejectsUnknownAndEmpty
--- PASS: TestValidateRejectsUnknownAndEmpty (0.00s)
=== RUN   TestCanSendChecksMembership
--- PASS: TestCanSendChecksMembership (0.00s)
=== RUN   TestCanSendSystemOnlyFromSystemSender
--- PASS: TestCanSendSystemOnlyFromSystemSender (0.00s)
PASS
ok  	webapp/internal/im	0.333s