]> git.scottworley.com Git - reliable-chat/blob - server/server_test.go
b9a7c925ebc1822b5e1764bc3642a0c74b4ecea1
[reliable-chat] / server / server_test.go
1 /* reliable-chat - multipath chat
2 * Copyright (C) 2012 Scott Worley <sworley@chkno.net>
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Affero General Public License as
6 * published by the Free Software Foundation, version 3.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU Affero General Public License for more details.
12 *
13 * You should have received a copy of the GNU Affero General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
16
17 package main
18
19 import "testing"
20 import "runtime"
21 import "strconv"
22 import "time"
23
24 func expectMessage(t *testing.T, m *Message, at time.Time, id, say string) {
25 if m.Time != at {
26 t.Fail()
27 }
28 if m.ID != id {
29 t.Fail()
30 }
31 if m.Text != say {
32 t.Fail()
33 }
34 }
35
36 func TestMessageInsertAndRetreive(t *testing.T) {
37 id := "1"
38 say := "'Ello, Mister Polly Parrot!"
39 at := time.Now()
40 var zero_time time.Time
41 store := start_store()
42 defer func() {
43 close(store.Get)
44 close(store.Add)
45 }()
46
47 store.Add <- &Message{at, id, say}
48 messages_from_store := make(chan []Message, 1)
49 store.Get <- &StoreRequest{zero_time, messages_from_store}
50 messages := <-messages_from_store
51 if len(messages) != 1 {
52 t.FailNow()
53 }
54 expectMessage(t, &messages[0], at, id, say)
55 }
56
57 func TestFetchBlocksUntilSpeak(t *testing.T) {
58 start_fetch_wait_count := fetch_wait_count.String()
59 id := "2"
60 say := "I've got a lovely fresh cuttle fish for you"
61 at := time.Now()
62 var zero_time time.Time
63 store := start_store()
64 defer func() {
65 close(store.Get)
66 close(store.Add)
67 }()
68
69 messages_from_store := make(chan []Message, 1)
70 store.Get <- &StoreRequest{zero_time, messages_from_store}
71 for start_fetch_wait_count == fetch_wait_count.String() {
72 runtime.Gosched()
73 }
74 store.Add <- &Message{at, id, say}
75 messages := <-messages_from_store
76 if len(messages) != 1 {
77 t.FailNow()
78 }
79 expectMessage(t, &messages[0], at, id, say)
80 }
81
82 func TestMultipleListeners(t *testing.T) {
83 id := "3"
84 say := "This is your nine o'clock alarm call!"
85 at := time.Now()
86 var zero_time time.Time
87 store := start_store()
88 defer func() {
89 close(store.Get)
90 close(store.Add)
91 }()
92
93 const num_clients = 13
94 var messages_from_store [num_clients]chan []Message
95 for i := 0; i < num_clients; i++ {
96 messages_from_store[i] = make(chan []Message, 1)
97 store.Get <- &StoreRequest{zero_time, messages_from_store[i]}
98 }
99 store.Add <- &Message{at, id, say}
100 for i := 0; i < num_clients; i++ {
101 messages := <-messages_from_store[i]
102 if len(messages) != 1 {
103 t.FailNow()
104 }
105 expectMessage(t, &messages[0], at, id, say)
106 }
107 }
108
109 func parseDuration(s string) time.Duration {
110 d, err := time.ParseDuration(s)
111 if err != nil {
112 panic(err)
113 }
114 return d
115 }
116
117 func atoi(s string) int {
118 i, err := strconv.Atoi(s)
119 if err != nil {
120 panic(err)
121 }
122 return i
123 }
124
125 func TestPartialRetreive(t *testing.T) {
126 start_speak_count := atoi(speak_count.String())
127 id1 := "4"
128 id2 := "5"
129 id3 := "6"
130 say1 := "No, no.....No, 'e's stunned!"
131 say2 := "You stunned him, just as he was wakin' up!"
132 say3 := "Norwegian Blues stun easily, major."
133 base := time.Now()
134 at1 := base.Add(parseDuration("-4m"))
135 since := base.Add(parseDuration("-3m"))
136 at2 := base.Add(parseDuration("-2m"))
137 at3 := base.Add(parseDuration("-1m"))
138 store := start_store()
139 defer func() {
140 close(store.Get)
141 close(store.Add)
142 }()
143
144 store.Add <- &Message{at1, id1, say1}
145 store.Add <- &Message{at2, id2, say2}
146 store.Add <- &Message{at3, id3, say3}
147 for atoi(speak_count.String()) != start_speak_count+3 {
148 runtime.Gosched()
149 }
150 messages_from_store := make(chan []Message, 1)
151 store.Get <- &StoreRequest{since, messages_from_store}
152 messages := <-messages_from_store
153 if len(messages) != 2 {
154 t.FailNow()
155 }
156 expectMessage(t, &messages[0], at2, id2, say2)
157 expectMessage(t, &messages[1], at3, id3, say3)
158 }
159
160 func TestPrecisePartialRetreive(t *testing.T) {
161 start_speak_count := atoi(speak_count.String())
162 id1 := "7"
163 id2 := "8"
164 id3 := "9"
165 say1 := "Well, he's...he's, ah...probably pining for the fjords."
166 say2 := "PININ' for the FJORDS?!?!?!?"
167 say3 := "look, why did he fall flat on his back the moment I got 'im home?"
168 base := time.Now()
169 at1 := base.Add(parseDuration("-3m"))
170 at2 := base.Add(parseDuration("-2m"))
171 at3 := base.Add(parseDuration("-1m"))
172 since := at2
173 store := start_store()
174 defer func() {
175 close(store.Get)
176 close(store.Add)
177 }()
178
179 store.Add <- &Message{at1, id1, say1}
180 store.Add <- &Message{at2, id2, say2}
181 store.Add <- &Message{at3, id3, say3}
182 for atoi(speak_count.String()) != start_speak_count+3 {
183 runtime.Gosched()
184 }
185 messages_from_store := make(chan []Message, 1)
186 store.Get <- &StoreRequest{since, messages_from_store}
187 messages := <-messages_from_store
188 if len(messages) != 1 {
189 t.FailNow()
190 }
191 expectMessage(t, &messages[0], at3, id3, say3)
192 }
193
194 func TestTypicalFlow(t *testing.T) {
195 id1 := "10"
196 id2 := "11"
197 say1 := "The Norwegian Blue prefers kippin' on it's back!"
198 say2 := "Remarkable bird, innit, squire? Lovely plumage!"
199 store := start_store()
200 defer func() {
201 close(store.Get)
202 close(store.Add)
203 }()
204
205 // A waiting zero-time fetch.
206 var zero_time time.Time
207 prev_fetch_wait_count := fetch_wait_count.String()
208 fetch1 := make(chan []Message, 1)
209 store.Get <- &StoreRequest{zero_time, fetch1}
210 for prev_fetch_wait_count == fetch_wait_count.String() {
211 runtime.Gosched()
212 }
213
214 // Someone speaks. This triggers delivery.
215 at1 := time.Now()
216 store.Add <- &Message{at1, id1, say1}
217 messages1 := <-fetch1
218 if len(messages1) != 1 {
219 t.FailNow()
220 }
221 expectMessage(t, &messages1[0], at1, id1, say1)
222
223 // Upon recipt, client blocks on fetch with since=at1
224 prev_fetch_wait_count = fetch_wait_count.String()
225 fetch2 := make(chan []Message, 1)
226 store.Get <- &StoreRequest{at1, fetch2}
227 for prev_fetch_wait_count == fetch_wait_count.String() {
228 runtime.Gosched()
229 }
230
231 // Someone speaks again. This triggers another delivery.
232 at2 := time.Now()
233 if !at2.After(at1) {
234 t.Fail()
235 }
236 store.Add <- &Message{at2, id2, say2}
237 messages2 := <-fetch2
238 if len(messages2) != 1 {
239 t.FailNow()
240 }
241 expectMessage(t, &messages2[0], at2, id2, say2)
242 }
243
244 func TestExpiryDueToLimit(t *testing.T) {
245 previous_limit := *max_messages
246 defer func() { *max_messages = previous_limit }()
247 *max_messages = 2
248
249 start_speak_count := atoi(speak_count.String())
250 start_drop_count := atoi(drop_due_to_limit_count.String())
251 id1 := "12"
252 id2 := "13"
253 id3 := "14"
254 say1 := "'E's passed on!"
255 say2 := "This parrot is no more!"
256 say3 := "He has ceased to be!"
257 base := time.Now()
258 at1 := base.Add(parseDuration("-3m"))
259 at2 := base.Add(parseDuration("-2m"))
260 at3 := base.Add(parseDuration("-1m"))
261 store := start_store()
262 defer func() {
263 close(store.Get)
264 close(store.Add)
265 }()
266
267 store.Add <- &Message{at1, id1, say1}
268 store.Add <- &Message{at2, id2, say2}
269 store.Add <- &Message{at3, id3, say3}
270 for atoi(speak_count.String()) != start_speak_count+3 {
271 runtime.Gosched()
272 }
273 if atoi(drop_due_to_limit_count.String()) != start_drop_count+1 {
274 t.Fail()
275 }
276 messages_from_store := make(chan []Message, 1)
277 var zero_time time.Time
278 store.Get <- &StoreRequest{zero_time, messages_from_store}
279 messages := <-messages_from_store
280 if len(messages) != 2 {
281 t.FailNow()
282 }
283 expectMessage(t, &messages[0], at2, id2, say2)
284 expectMessage(t, &messages[1], at3, id3, say3)
285 }