forked from p4gefau1t/trojan-go
-
Notifications
You must be signed in to change notification settings - Fork 0
/
server_test.go
124 lines (120 loc) · 2.58 KB
/
server_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package api
import (
context "context"
"fmt"
"testing"
"time"
"github.com/p4gefau1t/trojan-go/common"
"github.com/p4gefau1t/trojan-go/conf"
"github.com/p4gefau1t/trojan-go/stat/memory"
grpc "google.golang.org/grpc"
)
func TestServerAPI(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
auth, err := memory.NewMemoryAuth(ctx, &conf.GlobalConfig{})
common.Must(err)
go RunServerAPI(ctx, &conf.GlobalConfig{
API: conf.APIConfig{
APIAddress: common.NewAddress("127.0.0.1", 10000, "tcp"),
},
}, auth)
common.Must(auth.AddUser("hash1234"))
_, meter := auth.AuthUser("hash1234")
conn, err := grpc.Dial("127.0.0.1:10000", grpc.WithInsecure())
server := NewTrojanServerServiceClient(conn)
stream1, err := server.ListUsers(ctx, &ListUserRequest{})
common.Must(err)
for {
resp, err := stream1.Recv()
if err != nil {
break
}
fmt.Println(resp.User.Hash)
if resp.User.Hash != "hash1234" {
t.Fail()
}
fmt.Println(resp.SpeedCurrent)
fmt.Println(resp.SpeedLimit)
}
stream1.CloseSend()
meter.Count(1234, 5678)
time.Sleep(time.Millisecond * 1000)
stream2, err := server.GetTraffic(ctx)
common.Must(err)
stream2.Send(&GetTrafficRequest{
User: &User{
Hash: "hash1234",
},
})
resp2, err := stream2.Recv()
common.Must(err)
if resp2.TrafficTotal.DownloadTraffic != 1234 || resp2.TrafficTotal.UploadTraffic != 5678 {
t.Fail()
}
if resp2.SpeedCurrent.DownloadSpeed != 1234 || resp2.TrafficTotal.UploadTraffic != 5678 {
t.Fail()
}
stream3, err := server.SetUsers(ctx)
stream3.Send(&SetUserRequest{
User: &User{
Hash: "hash1234",
},
Operation: SetUserRequest_Delete,
})
resp3, err := stream3.Recv()
if err != nil || !resp3.Success {
t.Fail()
}
valid, _ := auth.AuthUser("hash1234")
if valid {
t.Fail()
}
stream3.Send(&SetUserRequest{
User: &User{
Hash: "newhash",
},
Operation: SetUserRequest_Add,
})
resp3, err = stream3.Recv()
if err != nil || !resp3.Success {
t.Fail()
}
valid, meter = auth.AuthUser("newhash")
if !valid {
t.Fail()
}
stream3.Send(&SetUserRequest{
User: &User{
Hash: "newhash",
},
Operation: SetUserRequest_Modify,
SpeedLimit: &Speed{
DownloadSpeed: 5000,
UploadSpeed: 3000,
},
})
go func() {
for {
meter.Count(200, 0)
}
}()
go func() {
for {
meter.Count(0, 300)
}
}()
time.Sleep(time.Second * 3)
for i := 0; i < 3; i++ {
stream2.Send(&GetTrafficRequest{
User: &User{
Hash: "newhash",
},
})
resp2, err = stream2.Recv()
fmt.Println(resp2.SpeedCurrent)
fmt.Println(resp2.SpeedLimit)
time.Sleep(time.Second)
}
stream2.CloseSend()
cancel()
}