💾 Archived View for source.community › ckaznocha › gemini › blob › main › server_test.go captured on 2024-02-05 at 09:53:18. Gemini links have been rewritten to link to archived content
⬅️ Previous capture (2023-01-29)
-=-=-=-=-=-=-
.
,-. ,-. . . ,-. ,-. ,-. ,-. ,-. ,-,-. ,-,-. . . ,-. . |- . .
`-. | | | | | | |-' | | | | | | | | | | | | | | | | |
`-' `-' `-^ ' `-' `-' :: `-' `-' ' ' ' ' ' ' `-^ ' ' ' `' `-|
/|
`-'
git clone https://source.community/ckaznocha/gemini.git
View raw contents of /server_test.go (main)
────╮
1│ package gemini_test
2│
3│ import (
4│ "bufio"
5│ "context"
6│ "crypto/tls"
7│ "errors"
8│ "fmt"
9│ "net"
10│ "strings"
11│ "sync"
12│ "testing"
13│ "time"
14│
15│ "source.community/ckaznocha/gemini"
16│ )
17│
18│ func failOnErrIfServerRunning(t *testing.T, done <-chan struct{}, err error, msg string) bool {
19│ t.Helper()
20│
21│ select {
22│ case <-done:
23│ return true
24│ default:
25│ if err != nil {
26│ t.Error(msg)
27│
28│ return true
29│ }
30│
31│ return false
32│ }
33│ }
34│
35│ func TestServer_ListenAndServeTLS(t *testing.T) {
36│ t.Parallel()
37│
38│ type fields struct {
39│ Handler gemini.Handler
40│ LogHandler func(message string, isError bool)
41│ BaseContext func(net.Listener) context.Context
42│ ConnContext func(ctx context.Context, c net.Conn) context.Context
43│ TLSConfig *tls.Config
44│ }
45│
46│ type args struct {
47│ addr string
48│ certFile string
49│ keyFile string
50│ }
51│
52│ tests := []struct {
53│ name string
54│ fields fields
55│ args args
56│ wantErr bool
57│ shutdownFirst bool
58│ }{
59│ {
60│ name: "Starts a server on the given address",
61│ fields: fields{
62│ Handler: gemini.NewServeMux(),
63│ },
64│ args: args{
65│ addr: "localhost:8049",
66│ certFile: "testdata/cert.pem",
67│ keyFile: "testdata/key.pem",
68│ },
69│ },
70│ {
71│ name: "Exits if the server has already been shutdown",
72│ shutdownFirst: true,
73│ },
74│ }
75│
76│ for _, tt := range tests {
77│ tt := tt
78│ t.Run(tt.name, func(t *testing.T) {
79│ t.Parallel()
80│ s := &gemini.Server{
81│ Handler: tt.fields.Handler,
82│ LogHandler: tt.fields.LogHandler,
83│ BaseContext: tt.fields.BaseContext,
84│ ConnContext: tt.fields.ConnContext,
85│ TLSConfig: tt.fields.TLSConfig,
86│ }
87│
88│ if tt.shutdownFirst {
89│ s.Shutdown(context.Background())
90│ }
91│
92│ clientDone := make(chan struct{}, 1)
93│ serverDone := make(chan struct{}, 1)
94│
95│ go func() {
96│ defer func() {
97│ if err := s.Shutdown(context.Background()); err != nil {
98│ t.Errorf("Server.ListenAndServeTLS(%v, %v) Unable to shutdown: error = %v", tt.args.certFile, tt.args.keyFile, err)
99│ }
100│
101│ clientDone <- struct{}{}
102│ }()
103│
104│ conn, err := tls.DialWithDialer(
105│ &net.Dialer{Timeout: 1 * time.Second},
106│ "tcp",
107│ tt.args.addr,
108│ &tls.Config{
109│ InsecureSkipVerify: true,
110│ },
111│ )
112│ if failOnErrIfServerRunning(
113│ t,
114│ serverDone,
115│ err,
116│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to dial: error = %v", tt.args.certFile, tt.args.keyFile, err),
117│ ) {
118│ return
119│ }
120│
121│ if _, err = fmt.Fprint(conn, "gemini://localhost.com/\r\n"); failOnErrIfServerRunning(
122│ t,
123│ serverDone,
124│ err,
125│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to write request: error = %v", tt.args.certFile, tt.args.keyFile, err),
126│ ) {
127│ return
128│ }
129│
130│ b := bufio.NewReader(conn)
131│ got, err := b.ReadBytes('\n')
132│ if failOnErrIfServerRunning(
133│ t,
134│ serverDone,
135│ err,
136│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to read response: error = %v", tt.args.certFile, tt.args.keyFile, err),
137│ ) {
138│ return
139│ }
140│
141│ if string(got) != "51 The requested resource could not be found but may be available in the future.\r\n" {
142│ t.Errorf("Server.ListenAndServeTLS(%v, %v) Incorrect response: got = %v", tt.args.certFile, tt.args.keyFile, string(got))
143│
144│ return
145│ }
146│
147│ if err = conn.Close(); failOnErrIfServerRunning(
148│ t,
149│ serverDone,
150│ err,
151│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to close connection: error = %v", tt.args.certFile, tt.args.keyFile, err),
152│ ) {
153│ return
154│ }
155│ }()
156│
157│ if err := s.ListenAndServeTLS(
158│ tt.args.addr,
159│ tt.args.certFile,
160│ tt.args.keyFile,
161│ ); !errors.Is(err, gemini.ErrServerShutdown) != tt.wantErr {
162│ t.Errorf("Server.ListenAndServeTLS(%v, %v) error = %v, wantErr %v", tt.args.certFile, tt.args.keyFile, err, tt.wantErr)
163│ }
164│
165│ serverDone <- struct{}{}
166│ <-clientDone
167│ })
168│ }
169│ }
170│
171│ func TestServer_ServeTLS(t *testing.T) {
172│ t.Parallel()
173│
174│ type fields struct {
175│ Handler gemini.Handler
176│ LogHandler func(message string, isError bool)
177│ BaseContext func(net.Listener) context.Context
178│ ConnContext func(ctx context.Context, c net.Conn) context.Context
179│ TLSConfig *tls.Config
180│ }
181│
182│ type args struct {
183│ certFile string
184│ keyFile string
185│ }
186│
187│ tests := []struct {
188│ name string
189│ fields fields
190│ args args
191│ wantErr bool
192│ shutdownFirst bool
193│ }{
194│ {
195│ name: "",
196│ fields: fields{
197│ Handler: gemini.NewServeMux(),
198│ },
199│ args: args{
200│ certFile: "",
201│ keyFile: "",
202│ },
203│ wantErr: true,
204│ },
205│ {
206│ name: "",
207│ args: args{
208│ certFile: "testdata/cert.pem",
209│ keyFile: "testdata/key.pem",
210│ },
211│ },
212│ {
213│ name: "",
214│ fields: fields{
215│ TLSConfig: &tls.Config{MinVersion: tls.VersionTLS11},
216│ },
217│ args: args{
218│ certFile: "testdata/cert.pem",
219│ keyFile: "testdata/key.pem",
220│ },
221│ wantErr: true,
222│ },
223│ {
224│ name: "",
225│ fields: fields{},
226│ args: args{
227│ certFile: "testdata/cert.pem",
228│ keyFile: "testdata/key.pem",
229│ },
230│ shutdownFirst: true,
231│ },
232│ }
233│
234│ for _, tt := range tests {
235│ tt := tt
236│ t.Run(tt.name, func(t *testing.T) {
237│ t.Parallel()
238│ s := &gemini.Server{
239│ Handler: tt.fields.Handler,
240│ LogHandler: tt.fields.LogHandler,
241│ BaseContext: tt.fields.BaseContext,
242│ ConnContext: tt.fields.ConnContext,
243│ TLSConfig: tt.fields.TLSConfig,
244│ }
245│
246│ l, err := net.Listen("tcp", "localhost:0")
247│ if err != nil {
248│ t.Fatalf("unable to open listener: %s", err)
249│ }
250│
251│ if tt.shutdownFirst {
252│ s.Shutdown(context.Background())
253│ }
254│
255│ clientDone := make(chan struct{}, 1)
256│ serverDone := make(chan struct{}, 1)
257│
258│ go func() {
259│ defer func() {
260│ if err := s.Shutdown(context.Background()); err != nil {
261│ t.Errorf("Server.ListenAndServeTLS(%v, %v) Unable to shutdown: error = %v", tt.args.certFile, tt.args.keyFile, err)
262│ }
263│
264│ clientDone <- struct{}{}
265│ }()
266│
267│ conn, err := tls.DialWithDialer(
268│ &net.Dialer{Timeout: 1 * time.Second},
269│ "tcp",
270│ l.Addr().String(),
271│ &tls.Config{
272│ InsecureSkipVerify: true,
273│ },
274│ )
275│ if failOnErrIfServerRunning(
276│ t,
277│ serverDone,
278│ err,
279│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to dial: error = %v", tt.args.certFile, tt.args.keyFile, err),
280│ ) {
281│ return
282│ }
283│
284│ if _, err = fmt.Fprint(conn, "gemini://localhost.com/\r\n"); failOnErrIfServerRunning(
285│ t,
286│ serverDone,
287│ err,
288│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to write request: error = %v", tt.args.certFile, tt.args.keyFile, err),
289│ ) {
290│ return
291│ }
292│
293│ b := bufio.NewReader(conn)
294│ got, err := b.ReadBytes('\n')
295│ if failOnErrIfServerRunning(
296│ t,
297│ serverDone,
298│ err,
299│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to read response: error = %v", tt.args.certFile, tt.args.keyFile, err),
300│ ) {
301│ return
302│ }
303│
304│ if string(got) != "51 The requested resource could not be found but may be available in the future.\r\n" {
305│ t.Errorf("Server.ListenAndServeTLS(%v, %v) Incorrect response: got = %v", tt.args.certFile, tt.args.keyFile, string(got))
306│
307│ return
308│ }
309│
310│ if err = conn.Close(); failOnErrIfServerRunning(
311│ t,
312│ serverDone,
313│ err,
314│ fmt.Sprintf("Server.ListenAndServeTLS(%v, %v) Unable to close connection: error = %v", tt.args.certFile, tt.args.keyFile, err),
315│ ) {
316│ return
317│ }
318│ }()
319│
320│ if err := s.ServeTLS(l, tt.args.certFile, tt.args.keyFile); !errors.Is(err, gemini.ErrServerShutdown) != tt.wantErr {
321│ t.Errorf("Server.ServeTLS(%v, %v, %v) error = %v, wantErr %v", l, tt.args.certFile, tt.args.keyFile, err, tt.wantErr)
322│ }
323│
324│ serverDone <- struct{}{}
325│ <-clientDone
326│ })
327│ }
328│ }
329│
330│ func TestServer_Serve(t *testing.T) {
331│ t.Parallel()
332│
333│ type fields struct {
334│ Handler gemini.Handler
335│ LogHandler func(message string, isError bool)
336│ BaseContext func(net.Listener) context.Context
337│ ConnContext func(ctx context.Context, c net.Conn) context.Context
338│ TLSConfig *tls.Config
339│ }
340│
341│ tests := []struct {
342│ fields fields
343│ name string
344│ reqBody string
345│ wantResponse string
346│ wantErr bool
347│ shutdownFirst bool
348│ wantNonTLS bool
349│ }{
350│ {
351│ name: "works",
352│ fields: fields{
353│ Handler: gemini.NewServeMux(),
354│ },
355│ wantResponse: "51 The requested resource could not be found but may be available in the future.\r\n",
356│ },
357│ {
358│ name: "errors when its not a TLS connection",
359│ fields: fields{
360│ Handler: gemini.NewServeMux(),
361│ },
362│ wantErr: true,
363│ wantNonTLS: true,
364│ },
365│ {
366│ name: "errors when the server has already been shutdown",
367│ fields: fields{
368│ Handler: gemini.NewServeMux(),
369│ },
370│ shutdownFirst: true,
371│ },
372│ {
373│ name: "errors base context is nil",
374│ fields: fields{
375│ Handler: gemini.NewServeMux(),
376│ BaseContext: func(l net.Listener) context.Context { return nil },
377│ },
378│ wantErr: true,
379│ },
380│ {
381│ name: "errors conn context is nil",
382│ fields: fields{
383│ Handler: gemini.NewServeMux(),
384│ ConnContext: func(ctx context.Context, c net.Conn) context.Context { return nil },
385│ },
386│ wantErr: true,
387│ },
388│ {
389│ name: "handles a too large request",
390│ fields: fields{
391│ Handler: gemini.NewServeMux(),
392│ },
393│ wantResponse: "59 the request length exceeded the max size of 1024 bytes\r\n",
394│ reqBody: "gemini://localhost/" + strings.Repeat("n", 1028-len("gemini://localhost/\r\n")) + "\r\n",
395│ },
396│ }
397│
398│ for _, tt := range tests {
399│ tt := tt
400│ t.Run(tt.name, func(t *testing.T) {
401│ t.Parallel()
402│ s := &gemini.Server{
403│ Handler: tt.fields.Handler,
404│ LogHandler: tt.fields.LogHandler,
405│ BaseContext: tt.fields.BaseContext,
406│ ConnContext: tt.fields.ConnContext,
407│ TLSConfig: tt.fields.TLSConfig,
408│ }
409│
410│ l, err := net.Listen("tcp", "localhost:0")
411│ if err != nil {
412│ t.Fatalf("unable to open listener: %s", err)
413│ }
414│
415│ if !tt.wantNonTLS {
416│ var cert tls.Certificate
417│ cert, err = tls.LoadX509KeyPair("testdata/cert.pem", "testdata/key.pem")
418│ if err != nil {
419│ t.Fatalf("unable to open listener: %s", err)
420│ }
421│
422│ config := &tls.Config{
423│ Certificates: []tls.Certificate{cert},
424│ }
425│ l = tls.NewListener(l, config)
426│ }
427│
428│ if tt.shutdownFirst {
429│ s.Shutdown(context.Background())
430│ }
431│
432│ clientDone := make(chan struct{}, 1)
433│ serverDone := make(chan struct{}, 1)
434│
435│ go func() {
436│ defer func() {
437│ if err = s.Shutdown(context.Background()); err != nil {
438│ t.Errorf("Server.Serve(%v) Unable to shutdown: error = %v", l, err)
439│ }
440│
441│ clientDone <- struct{}{}
442│ }()
443│
444│ var conn *tls.Conn
445│ conn, err = tls.DialWithDialer(
446│ &net.Dialer{Timeout: 1 * time.Second},
447│ "tcp",
448│ l.Addr().String(),
449│ &tls.Config{
450│ InsecureSkipVerify: true,
451│ },
452│ )
453│ if failOnErrIfServerRunning(
454│ t,
455│ serverDone,
456│ err,
457│ fmt.Sprintf("Server.Serve(%v) Unable to dial: error = %v", l, err),
458│ ) {
459│ return
460│ }
461│
462│ body := "gemini://localhost.com/\r\n"
463│ if tt.reqBody != "" {
464│ body = tt.reqBody
465│ }
466│
467│ if _, err = fmt.Fprint(conn, body); failOnErrIfServerRunning(
468│ t,
469│ serverDone,
470│ err,
471│ fmt.Sprintf("Server.Serve(%v) Unable to write request: error = %v", l, err),
472│ ) {
473│ return
474│ }
475│
476│ b := bufio.NewReader(conn)
477│ var got []byte
478│ got, err = b.ReadBytes('\n')
479│ if failOnErrIfServerRunning(
480│ t,
481│ serverDone,
482│ err,
483│ fmt.Sprintf("Server.Serve(%v) Unable to read response: error = %v", l, err),
484│ ) {
485│ return
486│ }
487│
488│ if string(got) != tt.wantResponse { //!= "51 The requested resource could not be found but may be available in the future.\r\n" {
489│ t.Errorf("Server.Serve(%v) Incorrect response: got = %v, want %s", l, string(got), tt.wantResponse)
490│
491│ return
492│ }
493│
494│ if err = conn.Close(); failOnErrIfServerRunning(
495│ t,
496│ serverDone,
497│ err,
498│ fmt.Sprintf("Server.Serve(%v) Unable to close connection: error = %v", l, err),
499│ ) {
500│ return
501│ }
502│ }()
503│
504│ err = s.Serve(l)
505│ if !errors.Is(err, gemini.ErrServerShutdown) != tt.wantErr {
506│ t.Errorf("Server.Serve(%v) error = %v, wantErr %v", l, err, tt.wantErr)
507│ }
508│
509│ serverDone <- struct{}{}
510│ <-clientDone
511│ })
512│ }
513│ }
514│
515│ func TestServer_RegisterOnShutdown(t *testing.T) {
516│ t.Parallel()
517│
518│ type args struct {
519│ i int
520│ }
521│
522│ tests := []struct {
523│ name string
524│ args args
525│ }{
526│ {
527│ name: "",
528│ args: args{i: 0},
529│ },
530│ {
531│ name: "",
532│ args: args{i: 1},
533│ },
534│ {
535│ name: "",
536│ args: args{i: 2},
537│ },
538│ }
539│
540│ for _, tt := range tests {
541│ tt := tt
542│ t.Run(tt.name, func(t *testing.T) {
543│ t.Parallel()
544│ s := &gemini.Server{}
545│ var wg sync.WaitGroup
546│ wg.Add(tt.args.i)
547│
548│ for i := 0; i < tt.args.i; i++ {
549│ s.RegisterOnShutdown(func() { wg.Done() })
550│ }
551│
552│ l, err := net.Listen("tcp", "localhost:0")
553│ if err != nil {
554│ t.Fatalf("unable to open listener: %s", err)
555│ }
556│
557│ cert, err := tls.LoadX509KeyPair("testdata/cert.pem", "testdata/key.pem")
558│ if err != nil {
559│ t.Fatalf("unable to open listener: %s", err)
560│ }
561│
562│ config := &tls.Config{
563│ Certificates: []tls.Certificate{cert},
564│ }
565│
566│ l = tls.NewListener(l, config)
567│
568│ go func() {
569│ defer s.Shutdown(context.Background())
570│ time.Sleep(5 * time.Millisecond)
571│ }()
572│
573│ if err := s.Serve(l); err != nil && !errors.Is(err, gemini.ErrServerShutdown) {
574│ t.Errorf("Server.Serve(%v) error = %v", l, err)
575│ }
576│
577│ wg.Wait()
578│ })
579│ }
580│ }
581│
582│ func TestServer_Shutdown(t *testing.T) {
583│ t.Parallel()
584│
585│ type fields struct {
586│ Handler gemini.Handler
587│ LogHandler func(message string, isError bool)
588│ BaseContext func(net.Listener) context.Context
589│ ConnContext func(ctx context.Context, c net.Conn) context.Context
590│ TLSConfig *tls.Config
591│ Addr string
592│ }
593│
594│ type args struct {
595│ ctx context.Context
596│ }
597│
598│ tests := []struct {
599│ args args
600│ fields fields
601│ name string
602│ wantErr bool
603│ }{
604│ // TODO: Add test cases.
605│ }
606│
607│ for _, tt := range tests {
608│ tt := tt
609│ t.Run(tt.name, func(t *testing.T) {
610│ t.Parallel()
611│ s := &gemini.Server{
612│ Handler: tt.fields.Handler,
613│ LogHandler: tt.fields.LogHandler,
614│ BaseContext: tt.fields.BaseContext,
615│ ConnContext: tt.fields.ConnContext,
616│ TLSConfig: tt.fields.TLSConfig,
617│ }
618│ if err := s.Shutdown(tt.args.ctx); (err != nil) != tt.wantErr {
619│ t.Errorf("Server.Shutdown(%v) error = %v, wantErr %v", tt.args.ctx, err, tt.wantErr)
620│ }
621│ })
622│ }
623│ }
────╯
· · ·
© 2024 source.community