kami_shop/internal/proxy/pool_test.go

package proxy

import (
	"context"
	"testing"
	"time"
)

func TestSocks5Proxy(t *testing.T) {
	socksProxy := NewSocks5Proxy("127.0.0.1", "1080", "testuser", "testpass")

	if socksProxy.Host != "127.0.0.1" {
		t.Errorf("Host 应该是 '127.0.0.1'，但是得到 '%s'", socksProxy.Host)
	}

	if socksProxy.Port != "1080" {
		t.Errorf("Port 应该是 '1080'，但是得到 '%s'", socksProxy.Port)
	}

	expectedAddr := "testuser:testpass@127.0.0.1:1080"
	if socksProxy.Address() != expectedAddr {
		t.Errorf("Address 应该是 '%s'，但是得到 '%s'", expectedAddr, socksProxy.Address())
	}

	// 测试过期逻辑
	if socksProxy.IsExpired() {
		t.Error("新创建的代理不应该过期")
	}

	// 模拟时间过去
	socksProxy.CreatedAt = time.Now().Add(-2 * time.Minute)
	if !socksProxy.IsExpired() {
		t.Error("超过1分钟的代理应该过期")
	}
}

func TestSocks5ProxyWithoutAuth(t *testing.T) {
	socksProxy := NewSocks5Proxy("127.0.0.1", "1080", "", "")

	expectedAddr := "127.0.0.1:1080"
	if socksProxy.Address() != expectedAddr {
		t.Errorf("Address 应该是 '%s'，但是得到 '%s'", expectedAddr, socksProxy.Address())
	}
}

func TestGetRandomProxy(t *testing.T) {
	// 注意：这个测试需要有效的代理API才能通过
	// 在实际环境中，你可能需要模拟这个API响应
	socksProxy, err := GetRandomProxy(context.Background())
	if err != nil {
		t.Logf("获取随机代理失败（这在测试环境中是正常的）: %v", err)
		return
	}

	if socksProxy == nil {
		t.Error("获取到的代理为空")
		return
	}

	t.Logf("获取到的代理: %s", socksProxy.Address())
}

func TestGetValidProxy(t *testing.T) {

	for i := 0; i < 30; i++ {
		// 注意：这个测试需要有效的代理API才能通过
		socksProxy, err := GetValidProxy(context.Background())
		if err != nil {
			t.Logf("获取有效代理失败（这在测试环境中是正常的）: %v", err)
			return
		}

		if socksProxy == nil {
			t.Error("获取到的代理为空")
			return
		}

		// 检查代理是否过期
		if socksProxy.IsExpired() {
			t.Error("GetValidProxy 应该返回未过期的代理")
		}

		t.Logf("获取到的有效代理: %s", socksProxy.Address())
		time.Sleep(time.Second * 5)
	}
}

func TestProxyExpiration(t *testing.T) {
	socksProxy := NewSocks5Proxy("127.0.0.1", "1080", "test", "test")

	// 新创建的代理不应该过期
	if socksProxy.IsExpired() {
		t.Error("新创建的代理不应该过期")
	}

	// 设置创建时间为2分钟前
	socksProxy.CreatedAt = time.Now().Add(-2 * time.Minute)

	// 现在应该过期了
	if !socksProxy.IsExpired() {
		t.Error("超过1分钟的代理应该过期")
	}
}

func TestProxyDialer(t *testing.T) {
	socksProxy := NewSocks5Proxy("127.0.0.1", "1080", "testuser", "testpass")

	// 测试获取拨号器
	dialer, err := socksProxy.GetDialer()
	if err != nil {
		t.Errorf("获取拨号器失败: %v", err)
		return
	}

	if dialer == nil {
		t.Error("拨号器为空")
		return
	}

	t.Log("成功获取代理拨号器")
}

func TestProxyCache(t *testing.T) {
	// 测试缓存信息
	total, valid, tested := GetCacheInfo()
	t.Logf("初始缓存状态 - 总数: %d, 有效: %d, 已测试: %d", total, valid, tested)

	// 手动清理缓存
	CleanCache()
	t.Log("手动清理缓存完成")

	// 再次检查缓存状态
	total, valid, tested = GetCacheInfo()
	t.Logf("清理后缓存状态 - 总数: %d, 有效: %d, 已测试: %d", total, valid, tested)
}

func TestProxyCacheReuse(t *testing.T) {
	// 这个测试验证代理缓存的重用功能
	// 第一次获取代理
	proxy1, err := GetValidProxy(context.Background())
	if err != nil {
		t.Skip("跳过缓存重用测试：无法获取有效代理")
		return
	}

	if proxy1 == nil {
		t.Error("第一次获取代理失败")
		return
	}

	// 检查缓存状态
	total1, valid1, tested1 := GetCacheInfo()
	t.Logf("第一次获取后缓存状态 - 总数: %d, 有效: %d, 已测试: %d", total1, valid1, tested1)

	// 短时间内再次获取代理，应该从缓存获取
	proxy2, err := GetValidProxy(context.Background())
	if err != nil {
		t.Error("第二次从缓存获取代理失败")
		return
	}

	if proxy2 == nil {
		t.Error("第二次获取代理为空")
		return
	}

	// 检查缓存状态
	total2, valid2, tested2 := GetCacheInfo()
	t.Logf("第二次获取后缓存状态 - 总数: %d, 有效: %d, 已测试: %d", total2, valid2, tested2)

	// 缓存中的代理数量应该有所增加（除非重复使用了相同的代理）
	if total2 < total1 {
		t.Error("缓存数量不应该减少")
	}

	t.Log("代理缓存重用测试完成")
}

// 基准测试
func BenchmarkGetRandomProxy(b *testing.B) {
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			_, err := GetRandomProxy(context.Background())
			if err != nil {
				// 在基准测试中，忽略获取失败的情况
				continue
			}
		}
	})
}

// 缓存性能基准测试
func BenchmarkGetValidProxy(b *testing.B) {
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			_, err := GetValidProxy(context.Background())
			if err != nil {
				// 在基准测试中，忽略获取失败的情况
				continue
			}
		}
	})
}