platform/web/services/channel_test.go

package services

import (
	"context"
	"encoding/json"
	"fmt"
	"platform/pkg/remote"
	"platform/pkg/testutil"
	"platform/web/models"
	"slices"
	"strings"
	"testing"
	"time"

	"github.com/gofiber/fiber/v2/middleware/requestid"
)

func Test_genPassPair(t *testing.T) {
	tests := []struct {
		name string
	}{
		{
			name: "正常生成随机用户名和密码",
		},
		{
			name: "多次调用生成不同的值",
		},
	}

	// 第一个测试：检查生成的用户名和密码是否有效
	t.Run(tests[0].name, func(t *testing.T) {
		username, password := genPassPair()
		if username == "" {
			t.Errorf("genPassPair() username is empty")
		}
		if password == "" {
			t.Errorf("genPassPair() password is empty")
		}
	})

	// 第二个测试：确保多次调用生成不同的值
	t.Run(tests[1].name, func(t *testing.T) {
		username1, password1 := genPassPair()
		username2, password2 := genPassPair()

		if username1 == username2 {
			t.Errorf("genPassPair() generated the same username twice: %v", username1)
		}
		if password1 == password2 {
			t.Errorf("genPassPair() generated the same password twice: %v", password1)
		}
	})
}

func Test_chKey(t *testing.T) {
	type args struct {
		channel *models.Channel
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		{
			name: "ID为1的通道",
			args: args{
				channel: &models.Channel{
					ID: 1,
				},
			},
			want: "channel:1",
		},
		{
			name: "ID为100的通道",
			args: args{
				channel: &models.Channel{
					ID: 100,
				},
			},
			want: "channel:100",
		},
		{
			name: "ID为0的通道",
			args: args{
				channel: &models.Channel{
					ID: 0,
				},
			},
			want: "channel:0",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := chKey(tt.args.channel); got != tt.want {
				t.Errorf("chKey() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_cache(t *testing.T) {
	mr := testutil.SetupRedisTest(t)

	type args struct {
		ctx      context.Context
		channels []*models.Channel
	}

	// 准备测试数据
	now := time.Now()
	expiration := now.Add(24 * time.Hour)

	testChannels := []*models.Channel{
		{
			ID:         1,
			UserID:     100,
			ProxyID:    10,
			ProxyPort:  8080,
			Protocol:   "http",
			Expiration: expiration,
		},
		{
			ID:         2,
			UserID:     101,
			ProxyID:    11,
			ProxyPort:  8081,
			Protocol:   "socks5",
			Expiration: expiration,
		},
	}

	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "正常缓存多个通道",
			args: args{
				ctx:      context.Background(),
				channels: testChannels,
			},
			wantErr: false,
		},
		{
			name: "空通道列表",
			args: args{
				ctx:      context.Background(),
				channels: []*models.Channel{},
			},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mr.FlushAll() // 清空 Redis 数据

			if err := cache(tt.args.ctx, tt.args.channels); (err != nil) != tt.wantErr {
				t.Errorf("cache() error = %v, wantErr %v", err, tt.wantErr)
				return
			}

			// 验证缓存结果
			if len(tt.args.channels) > 0 {
				for _, channel := range tt.args.channels {
					key := fmt.Sprintf("channel:%d", channel.ID)
					if !mr.Exists(key) {
						t.Errorf("缓存未包含通道键 %s", key)
					} else {
						// 验证缓存的数据是否正确
						data, _ := mr.Get(key)
						var cachedChannel models.Channel
						err := json.Unmarshal([]byte(data), &cachedChannel)
						if err != nil {
							t.Errorf("无法解析缓存数据: %v", err)
						}
						if cachedChannel.ID != channel.ID {
							t.Errorf("缓存数据不匹配: 期望 ID %d, 得到 %d", channel.ID, cachedChannel.ID)
						}
					}
				}

				// 验证是否设置了过期时间
				for _, channel := range tt.args.channels {
					key := fmt.Sprintf("channel:%d", channel.ID)
					ttl := mr.TTL(key)
					if ttl <= 0 {
						t.Errorf("键 %s 没有设置过期时间", key)
					}
				}

				// 验证是否添加了有序集合
				if !mr.Exists("tasks:channel") {
					t.Errorf("ZAdd未创建有序集合 tasks:channel")
				}
			}
		})
	}
}

func Test_deleteCache(t *testing.T) {
	mr := testutil.SetupRedisTest(t)

	type args struct {
		ctx      context.Context
		channels []*models.Channel
	}

	// 准备测试数据
	testChannels := []*models.Channel{
		{ID: 1},
		{ID: 2},
		{ID: 3},
	}

	ctx := context.Background()

	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "正常删除多个通道缓存",
			args: args{
				ctx:      ctx,
				channels: testChannels,
			},
			wantErr: false,
		},
		{
			name: "空通道列表",
			args: args{
				ctx:      ctx,
				channels: []*models.Channel{},
			},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mr.FlushAll() // 清空 Redis 数据

			// 预先设置缓存数据
			for _, channel := range testChannels {
				key := fmt.Sprintf("channel:%d", channel.ID)
				data, _ := json.Marshal(channel)
				mr.Set(key, string(data))
				mr.SetTTL(key, 1*time.Hour) // 设置1小时的过期时间
			}

			if err := deleteCache(tt.args.ctx, tt.args.channels); (err != nil) != tt.wantErr {
				t.Errorf("deleteCache() error = %v, wantErr %v", err, tt.wantErr)
				return
			}

			// 验证删除结果
			for _, channel := range tt.args.channels {
				key := fmt.Sprintf("channel:%d", channel.ID)
				if mr.Exists(key) {
					t.Errorf("通道键 %s 未被删除", key)
				}
			}
		})
	}
}

func Test_channelService_CreateChannel(t *testing.T) {
	mr := testutil.SetupRedisTest(t)
	db := testutil.SetupDBTest(t)
	mc := testutil.SetupCloudClientMock(t)

	type args struct {
		ctx        context.Context
		auth       *AuthContext
		resourceId int32
		protocol   ChannelProtocol
		authType   ChannelAuthType
		count      int
		nodeFilter []NodeFilterConfig
	}

	// 准备测试数据
	ctx := context.WithValue(context.Background(), requestid.ConfigDefault.ContextKey, "test-request-id")
	var adminAuth = &AuthContext{Payload: Payload{Id: 100, Type: PayloadAdmin}}
	var userAuth = &AuthContext{Payload: Payload{Id: 101, Type: PayloadUser}}
	var user = &models.User{
		ID:    101,
		Phone: "12312341234",
	}
	db.Create(user)
	var whitelists = []*models.Whitelist{
		{ID: 1, UserID: 101, Host: "123.123.123.123"},
		{ID: 2, UserID: 101, Host: "456.456.456.456"},
		{ID: 3, UserID: 101, Host: "789.789.789.789"},
	}
	db.Create(whitelists)
	var resource = &models.Resource{
		ID:     1,
		UserID: 101,
		Active: true,
	}
	db.Create(resource)
	var resourcePss = &models.ResourcePss{
		ID:         1,
		ResourceID: 1,
		Type:       1,
		Live:       180,
		Expire:     time.Now().AddDate(1, 0, 0),
		DailyLimit: 10000,
	}
	db.Create(resourcePss)
	var proxy = &models.Proxy{
		ID:      1,
		Version: 1,
		Name:    "test-proxy",
		Host:    "111.111.111.111",
		Type:    1,
		Secret:  "test:secret",
	}
	db.Create(proxy)
	mc.AutoQueryMock = func() (remote.CloudConnectResp, error) {
		return remote.CloudConnectResp{
			"test-proxy": []remote.AutoConfig{
				{Province: "河南", City: "郑州", Isp: "电信", Count: 10},
			},
		}, nil
	}
	var clearDb = func() {
		db.Exec("delete from channel where true")
		db.Exec("update resource_pss set daily_used = 0, daily_last = null, used = 0 where true")
	}
	tests := []struct {
		name            string
		args            args
		setup           func()
		wantErr         bool
		wantErrContains string
		want            func(t *testing.T, got []*PortInfo) error
	}{
		{
			name: "用户创建HTTP密码通道",
			args: args{
				ctx:        ctx,
				auth:       userAuth,
				resourceId: 1,
				protocol:   ProtocolHTTP,
				authType:   ChannelAuthTypePass,
				count:      3,
				nodeFilter: []NodeFilterConfig{{Prov: "河南", City: "郑州", Isp: "电信"}},
			},

			want: func(t *testing.T, got []*PortInfo) error {
				// 验证返回结果
				if len(got) == 0 {
					return fmt.Errorf("返回的 PortInfo 不应为空")
				}

				// 验证协议正确
				for _, port := range got {
					if port.Proto != "http" {
						return fmt.Errorf("期望协议为 http，得到 %s", port.Proto)
					}
					if port.Host != proxy.Host {
						return fmt.Errorf("期望主机为 %s，得到 %s", proxy.Host, port.Host)
					}
				}

				// 验证数据库字段
				var channels []*models.Channel
				db.Where("user_id = ? AND proxy_id = ?", userAuth.Payload.Id, proxy.ID).Find(&channels)
				for _, ch := range channels {
					if ch.Protocol != "http" {
						return fmt.Errorf("通道协议不正确，期望 http，得到 %s", ch.Protocol)
					}
					if ch.UserID != userAuth.Payload.Id {
						return fmt.Errorf("通道用户ID不正确，期望 %d，得到 %d", userAuth.Payload.Id, ch.UserID)
					}
					if ch.ProxyID != proxy.ID {
						return fmt.Errorf("通道代理ID不正确，期望 %d，得到 %d", proxy.ID, ch.ProxyID)
					}

					// 检查Redis缓存中的字段
					key := fmt.Sprintf("channel:%d", ch.ID)
					if !mr.Exists(key) {
						return fmt.Errorf("Redis缓存中应有键 %s", key)
					}

					data, _ := mr.Get(key)
					var cachedChannel models.Channel
					err := json.Unmarshal([]byte(data), &cachedChannel)
					if err != nil {
						return fmt.Errorf("无法解析缓存数据: %v", err)
					}

					if cachedChannel.ID != ch.ID {
						return fmt.Errorf("缓存ID不正确，期望 %d，得到 %d", ch.ID, cachedChannel.ID)
					}
					if cachedChannel.Protocol != ch.Protocol {
						return fmt.Errorf("缓存协议不正确，期望 %s，得到 %s", ch.Protocol, cachedChannel.Protocol)
					}
				}
				return nil
			},
		},
		{
			name: "用户创建HTTP白名单通道",
			args: args{
				ctx:        ctx,
				auth:       userAuth,
				resourceId: 1,
				protocol:   ProtocolHTTP,
				authType:   ChannelAuthTypeIp,
				count:      2,
			},
			want: func(t *testing.T, got []*PortInfo) error {
				return nil
			},
		},
		{
			name: "管理员创建SOCKS5密码通道",
			args: args{
				ctx:        ctx,
				auth:       adminAuth,
				resourceId: 1,
				protocol:   ProtocolSocks5,
				authType:   ChannelAuthTypePass,
				count:      2,
			},
			want: func(t *testing.T, got []*PortInfo) error {
				return nil
			},
		},
		{
			name: "套餐不存在",
			args: args{
				ctx:        ctx,
				auth:       userAuth,
				resourceId: 999,
				protocol:   ProtocolHTTP,
				authType:   ChannelAuthTypeIp,
				count:      1,
			},
			wantErr:         true,
			wantErrContains: "套餐不存在",
		},
		{
			name: "套餐没有权限",
			args: args{
				ctx:        ctx,
				auth:       userAuth,
				resourceId: 2,
				protocol:   ProtocolHTTP,
				authType:   ChannelAuthTypeIp,
				count:      1,
			},
			wantErr:         true,
			wantErrContains: "无权限访问",
		},
		{
			name: "套餐配额不足",
			args: args{
				ctx: ctx,
				auth: &AuthContext{
					Payload: Payload{
						Type: PayloadUser,
						Id:   100,
					},
				},
				resourceId: 2,
				protocol:   ProtocolHTTP,
				authType:   ChannelAuthTypeIp,
				count:      10,
			},
			setup: func() {
				// 创建一个配额几乎用完的资源包
				resource2 := models.Resource{
					ID:     2,
					UserID: 101,
					Active: true,
				}
				resourcePss2 := models.ResourcePss{
					ID:         1,
					ResourceID: 1,
					Type:       2,
					Quota:      100,
					Used:       91,
					Live:       180,
					DailyLimit: 10000,
				}
				db.Create(&resource2).Create(&resourcePss2)
			},
			wantErr:         true,
			wantErrContains: "套餐配额不足",
		},
		{
			name: "端口数量达到上限",
			args: args{
				ctx:        ctx,
				auth:       userAuth,
				resourceId: 1,
				protocol:   ProtocolHTTP,
				authType:   ChannelAuthTypeIp,
				count:      1,
			},
			setup: func() {
				// 创建大量占用端口的通道
				for i := 10000; i < 20000; i++ {
					channel := models.Channel{
						ProxyID:   1,
						ProxyPort: int32(i),
						UserID:    101,
					}
					db.Create(&channel)
				}
			},
			wantErr:         true,
			wantErrContains: "端口数量不足",
		},
		// todo 跨天用量更新
		// todo 多地区混杂条件提取
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mr.FlushAll()
			clearDb()
			if tt.setup != nil {
				tt.setup()
			}

			s := &channelService{}
			got, err := s.CreateChannel(tt.args.ctx, tt.args.auth, tt.args.resourceId, tt.args.protocol, tt.args.authType, tt.args.count, tt.args.nodeFilter...)

			// 检查错误或结果
			if tt.wantErr {
				if err == nil {
					t.Errorf("CreateChannel() 应当返回错误")
					return
				}
				if tt.wantErrContains != "" && !strings.Contains(err.Error(), tt.wantErrContains) {
					t.Errorf("CreateChannel() 错误 = %v, 应包含 %v", err, tt.wantErrContains)
				}
				return
			}

			if err != nil {
				t.Errorf("CreateChannel() 错误 = %v, wantErr %v", err, tt.wantErr)
				return
			}

			// 使用检查函数验证结果
			if tt.want != nil {
				if err := tt.want(t, got); err != nil {
					t.Errorf("结果验证失败: %v", err)
				}
			}
		})
	}
}

func Test_channelService_RemoveChannels(t *testing.T) {
	mr := testutil.SetupRedisTest(t)
	md := testutil.SetupDBTest(t)
	mg := testutil.SetupGatewayClientMock(t)
	mc := testutil.SetupCloudClientMock(t)

	type args struct {
		ctx  context.Context
		auth *AuthContext
		id   []int32
	}

	// 准备测试数据
	ctx := context.WithValue(context.Background(), requestid.ConfigDefault.ContextKey, "test-request-id")

	// 创建用户
	var user = &models.User{
		ID:    101,
		Phone: "12312341234",
	}
	md.Create(user)

	// 创建管理员
	var adminUser = &models.User{
		ID:    100,
		Phone: "99999999999",
	}
	md.Create(adminUser)

	// 认证上下文
	var adminAuth = &AuthContext{Payload: Payload{Id: 100, Type: PayloadAdmin}}
	var userAuth = &AuthContext{Payload: Payload{Id: 101, Type: PayloadUser}}

	// 创建代理
	var proxy = &models.Proxy{
		ID:      1,
		Version: 1,
		Name:    "test-proxy",
		Host:    "111.111.111.111",
		Type:    1,
		Secret:  "test:secret",
	}
	md.Create(proxy)

	var proxy2 = &models.Proxy{
		ID:      2,
		Version: 1,
		Name:    "test-proxy-2",
		Host:    "222.222.222.222",
		Type:    1,
		Secret:  "test:secret2",
	}
	md.Create(proxy2)

	// 清空数据库函数
	var clearDb = func() {
		md.Exec("delete from channel where true")
		mr.FlushAll()
	}

	tests := []struct {
		name            string
		args            args
		setup           func()
		wantErr         bool
		wantErrContains string
		want            func(t *testing.T) error
	}{
		{
			name: "管理员删除多个通道",
			args: args{
				ctx:  ctx,
				auth: adminAuth,
				id:   []int32{1, 2, 3},
			},
			setup: func() {
				mr.FlushAll()
				clearDb()

				// 创建通道
				channels := []models.Channel{
					{ID: 1, UserID: 101, ProxyID: 1, ProxyPort: 10001, Protocol: "http", Expiration: time.Now().Add(24 * time.Hour)},
					{ID: 2, UserID: 101, ProxyID: 1, ProxyPort: 10002, Protocol: "http", Expiration: time.Now().Add(24 * time.Hour)},
					{ID: 3, UserID: 101, ProxyID: 2, ProxyPort: 10001, Protocol: "socks5", Expiration: time.Now().Add(24 * time.Hour)},
				}

				// 保存预设数据
				md.Create(channels)
				for _, channel := range channels {
					key := fmt.Sprintf("channel:%d", channel.ID)
					data, _ := json.Marshal(channel)
					_ = mr.Set(key, string(data))
				}

				// 模拟网关客户端的响应
				mg.PortActiveMock = func(m *testutil.MockGatewayClient, param ...remote.PortActiveReq) (map[string]remote.PortData, error) {
					switch {
					case m.Host == proxy.Host:
						return map[string]remote.PortData{
							"10001": {Edge: []string{"edge1", "edge4"}},
							"10002": {Edge: []string{"edge2"}},
						}, nil
					case m.Host == proxy2.Host:
						return map[string]remote.PortData{
							"10001": {Edge: []string{"edge3"}},
						}, nil
					}
					return nil, fmt.Errorf("代理主机不符合预期: %s", m.Host)
				}
				mg.PortConfigsMock = func(m *testutil.MockGatewayClient, params []remote.PortConfigsReq) error {
					switch {
					case m.Host == proxy.Host:
						for _, param := range params {
							if param.Port != 10001 && param.Port != 10002 {
								return fmt.Errorf("端口配置不符合预期: %d", param.Port)
							}
							if param.Status != false {
								return fmt.Errorf("端口状态不符合预期: %v", param.Status)
							}
							if param.Edge == nil || len(*param.Edge) != 0 {
								return fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
							}
						}
					case m.Host == proxy2.Host:
						for _, param := range params {
							if param.Port != 10001 {
								return fmt.Errorf("端口配置不符合预期: %d", param.Port)
							}
							if param.Status != false {
								return fmt.Errorf("端口状态不符合预期: %v", param.Status)
							}
							if param.Edge == nil || len(*param.Edge) != 0 {
								return fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
							}
						}
					}
					return fmt.Errorf("代理主机不符合预期: %s", m.Host)
				}
				mc.DisconnectMock = func(param remote.CloudDisconnectReq) (int, error) {
					switch {
					case param.Uuid == proxy.Name:
						var edges = []string{"edge1", "edge2", "edge4"}
						if !slices.Equal(edges, param.Edge) {
							return 0, fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
						}
						if len(param.Config) != 0 {
							return 0, fmt.Errorf("配置不符合预期: %v", param.Config)
						}
						return len(param.Edge), nil
					case param.Uuid == proxy2.Name:
						var edges = []string{"edge3"}
						if !slices.Equal(edges, param.Edge) {
							return 0, fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
						}
						if len(param.Config) != 0 {
							return 0, fmt.Errorf("配置不符合预期: %v", param.Config)
						}
						return len(param.Edge), nil
					}
					return 0, fmt.Errorf("代理名称不符合预期: %s", param.Uuid)
				}
			},
			want: func(t *testing.T) error {
				// 检查通道是否被软删除
				var count int64
				md.Model(&models.Channel{}).Where("id IN ? AND deleted_at IS NULL", []int32{1, 2, 3}).Count(&count)
				if count > 0 {
					return fmt.Errorf("应该软删除了所有通道，但仍有 %d 个未删除", count)
				}

				// 检查Redis缓存是否被删除
				for _, id := range []int32{1, 2, 3} {
					key := fmt.Sprintf("channel:%d", id)
					if mr.Exists(key) {
						return fmt.Errorf("通道缓存 %s 应被删除但仍存在", key)
					}
				}
				return nil
			},
		},
		{
			name: "用户删除自己的通道",
			args: args{
				ctx:  ctx,
				auth: userAuth,
				id:   []int32{1, 2, 3},
			},
			setup: func() {
				mr.FlushAll()
				clearDb()

				// 创建通道
				channels := []models.Channel{
					{ID: 1, UserID: 101, ProxyID: 1, ProxyPort: 10001, Protocol: "http", Expiration: time.Now().Add(24 * time.Hour)},
					{ID: 2, UserID: 101, ProxyID: 1, ProxyPort: 10002, Protocol: "http", Expiration: time.Now().Add(24 * time.Hour)},
					{ID: 3, UserID: 101, ProxyID: 2, ProxyPort: 10001, Protocol: "socks5", Expiration: time.Now().Add(24 * time.Hour)},
				}

				// 保存预设数据
				md.Create(channels)
				for _, channel := range channels {
					key := fmt.Sprintf("channel:%d", channel.ID)
					data, _ := json.Marshal(channel)
					_ = mr.Set(key, string(data))
				}

				// 模拟网关客户端的响应
				mg.PortActiveMock = func(m *testutil.MockGatewayClient, param ...remote.PortActiveReq) (map[string]remote.PortData, error) {
					switch {
					case m.Host == proxy.Host:
						return map[string]remote.PortData{
							"10001": {Edge: []string{"edge1", "edge4"}},
							"10002": {Edge: []string{"edge2"}},
						}, nil
					case m.Host == proxy2.Host:
						return map[string]remote.PortData{
							"10001": {Edge: []string{"edge3"}},
						}, nil
					}
					return nil, fmt.Errorf("代理主机不符合预期: %s", m.Host)
				}
				mg.PortConfigsMock = func(m *testutil.MockGatewayClient, params []remote.PortConfigsReq) error {
					switch {
					case m.Host == proxy.Host:
						for _, param := range params {
							if param.Port != 10001 && param.Port != 10002 {
								return fmt.Errorf("端口配置不符合预期: %d", param.Port)
							}
							if param.Status != false {
								return fmt.Errorf("端口状态不符合预期: %v", param.Status)
							}
							if param.Edge == nil || len(*param.Edge) != 0 {
								return fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
							}
						}
					case m.Host == proxy2.Host:
						for _, param := range params {
							if param.Port != 10001 {
								return fmt.Errorf("端口配置不符合预期: %d", param.Port)
							}
							if param.Status != false {
								return fmt.Errorf("端口状态不符合预期: %v", param.Status)
							}
							if param.Edge == nil || len(*param.Edge) != 0 {
								return fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
							}
						}
					}
					return fmt.Errorf("代理主机不符合预期: %s", m.Host)
				}
				mc.DisconnectMock = func(param remote.CloudDisconnectReq) (int, error) {
					switch {
					case param.Uuid == proxy.Name:
						var edges = []string{"edge1", "edge2", "edge4"}
						if !slices.Equal(edges, param.Edge) {
							return 0, fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
						}
						if len(param.Config) != 0 {
							return 0, fmt.Errorf("配置不符合预期: %v", param.Config)
						}
						return len(param.Edge), nil
					case param.Uuid == proxy2.Name:
						var edges = []string{"edge3"}
						if !slices.Equal(edges, param.Edge) {
							return 0, fmt.Errorf("边缘节点不符合预期: %v", param.Edge)
						}
						if len(param.Config) != 0 {
							return 0, fmt.Errorf("配置不符合预期: %v", param.Config)
						}
						return len(param.Edge), nil
					}
					return 0, fmt.Errorf("代理名称不符合预期: %s", param.Uuid)
				}
			},
			want: func(t *testing.T) error {
				// 检查通道是否被软删除
				var count int64
				md.Model(&models.Channel{}).Where("id IN ? AND deleted_at IS NULL", []int32{1, 2, 3}).Count(&count)
				if count > 0 {
					return fmt.Errorf("应该软删除了所有通道，但仍有 %d 个未删除", count)
				}

				// 检查Redis缓存是否被删除
				for _, id := range []int32{1, 2, 3} {
					key := fmt.Sprintf("channel:%d", id)
					if mr.Exists(key) {
						return fmt.Errorf("通道缓存 %s 应被删除但仍存在", key)
					}
				}
				return nil
			},
		},
		{
			name: "用户删除不属于自己的通道",
			args: args{
				ctx:  ctx,
				auth: userAuth,
				id:   []int32{1, 2, 3},
			},
			setup: func() {
				mr.FlushAll()
				clearDb()

				// 创建通道
				channels := []models.Channel{
					{ID: 1, UserID: 101, ProxyID: 1, ProxyPort: 10001, Protocol: "http", Expiration: time.Now().Add(24 * time.Hour)},
					{ID: 2, UserID: 101, ProxyID: 1, ProxyPort: 10002, Protocol: "http", Expiration: time.Now().Add(24 * time.Hour)},
					{ID: 3, UserID: 102, ProxyID: 2, ProxyPort: 10001, Protocol: "socks5", Expiration: time.Now().Add(24 * time.Hour)},
				}

				// 保存预设数据
				md.Create(channels)
				for _, channel := range channels {
					key := fmt.Sprintf("channel:%d", channel.ID)
					data, _ := json.Marshal(channel)
					_ = mr.Set(key, string(data))
				}
			},
			wantErr:         true,
			wantErrContains: "无权限访问",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.setup != nil {
				tt.setup()
			}

			s := &channelService{}
			err := s.RemoveChannels(tt.args.ctx, tt.args.auth, tt.args.id...)

			// 检查错误
			if tt.wantErr {
				if err == nil {
					t.Errorf("RemoveChannels() 应当返回错误")
					return
				}
				if tt.wantErrContains != "" && !strings.Contains(err.Error(), tt.wantErrContains) {
					t.Errorf("RemoveChannels() 错误 = %v, 应包含 %v", err, tt.wantErrContains)
				}
				return
			}

			if err != nil {
				t.Errorf("RemoveChannels() 错误 = %v, wantErr %v", err, tt.wantErr)
				return
			}

			// 检查数据库和缓存是否正确设置
			want := tt.want(t)
			if tt.want(t) != nil {
				t.Errorf("RemoveChannels() 结果验证失败: %v", want)
			}
		})
	}
}