protocol_test.go 3.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144
  1. package protocol
  2. import (
  3. "bytes"
  4. "context"
  5. "encoding/binary"
  6. "encoding/json"
  7. "errors"
  8. "io"
  9. "net"
  10. "strings"
  11. "sync"
  12. "testing"
  13. "time"
  14. )
  15. type shortWriter struct{ b bytes.Buffer }
  16. func (w *shortWriter) Write(b []byte) (int, error) {
  17. if len(b) > 2 {
  18. b = b[:2]
  19. }
  20. return w.b.Write(b)
  21. }
  22. type zeroWriter struct{}
  23. func (zeroWriter) Write([]byte) (int, error) { return 0, nil }
  24. type badWriter struct{}
  25. func (badWriter) Write([]byte) (int, error) { return 0, io.ErrClosedPipe }
  26. func TestFraming(t *testing.T) {
  27. w := &shortWriter{}
  28. req := Request{Version: Version, ID: 5, Method: "hello", Params: json.RawMessage(`{"text":"科学"}`)}
  29. if e := Write(w, req); e != nil {
  30. t.Fatal(e)
  31. }
  32. var out Request
  33. if e := Read(&w.b, &out); e != nil || out.Method != "hello" {
  34. t.Fatalf("roundtrip: %+v %v", out, e)
  35. }
  36. if Write(zeroWriter{}, req) != io.ErrShortWrite {
  37. t.Fatal("zero writer did not fail")
  38. }
  39. if Write(badWriter{}, req) != io.ErrClosedPipe {
  40. t.Fatal("write error lost")
  41. }
  42. if Write(io.Discard, map[string]string{"large": strings.Repeat("x", MaxMessage)}) == nil {
  43. t.Fatal("oversized frame accepted")
  44. }
  45. for _, n := range []uint32{0, MaxMessage + 1} {
  46. var b bytes.Buffer
  47. _ = binary.Write(&b, binary.BigEndian, n)
  48. if Read(&b, &out) == nil {
  49. t.Fatal("invalid length accepted")
  50. }
  51. }
  52. for _, b := range [][]byte{{1}, {0, 0, 0, 2, '{'}, {0, 0, 0, 1, 'x'}} {
  53. if Read(bytes.NewReader(b), &out) == nil {
  54. t.Fatal("malformed frame accepted")
  55. }
  56. }
  57. if Write(io.Discard, make(chan int)) == nil {
  58. t.Fatal("unmarshalable value accepted")
  59. }
  60. }
  61. func TestConcurrentCallsCancellationAndEOF(t *testing.T) {
  62. a, b := net.Pipe()
  63. serverDone := make(chan error, 1)
  64. canceled := make(chan struct{}, 1)
  65. go func() {
  66. serverDone <- Serve(context.Background(), a, a, func(ctx context.Context, method string, raw json.RawMessage) (any, error) {
  67. if method == "wait" {
  68. <-ctx.Done()
  69. canceled <- struct{}{}
  70. return nil, ctx.Err()
  71. }
  72. if method == "fail" {
  73. return nil, errors.New("failure")
  74. }
  75. return json.RawMessage(raw), nil
  76. })
  77. }()
  78. c := NewClient(b, b)
  79. var wg sync.WaitGroup
  80. for i := 0; i < 12; i++ {
  81. wg.Add(1)
  82. go func(n int) {
  83. defer wg.Done()
  84. var got int
  85. if e := c.Call(context.Background(), "echo", n, &got); e != nil || got != n {
  86. t.Errorf("echo %d: %d %v", n, got, e)
  87. }
  88. }(i)
  89. }
  90. wg.Wait()
  91. ctx, stop := context.WithTimeout(context.Background(), 30*time.Millisecond)
  92. defer stop()
  93. if e := c.Call(ctx, "wait", nil, nil); !errors.Is(e, context.DeadlineExceeded) {
  94. t.Fatalf("cancellation: %v", e)
  95. }
  96. select {
  97. case <-canceled:
  98. case <-time.After(time.Second):
  99. t.Fatal("worker did not receive cancellation")
  100. }
  101. if c.Call(context.Background(), "fail", nil, nil) == nil {
  102. t.Fatal("remote failure lost")
  103. }
  104. c.Close()
  105. if c.Call(context.Background(), "echo", nil, nil) == nil {
  106. t.Fatal("closed client accepted call")
  107. }
  108. b.Close()
  109. a.Close()
  110. select {
  111. case <-serverDone:
  112. case <-time.After(time.Second):
  113. t.Fatal("server did not exit")
  114. }
  115. }
  116. func TestVersionAndUnknownCancellation(t *testing.T) {
  117. var input bytes.Buffer
  118. _ = Write(&input, Request{Version: 99, ID: 1})
  119. _ = Write(&input, Request{Version: Version, ID: 2, Method: "request.cancel", Params: json.RawMessage(`{"id":99}`)})
  120. var output bytes.Buffer
  121. if err := Serve(context.Background(), &input, &output, func(context.Context, string, json.RawMessage) (any, error) {
  122. t.Fatal("invalid envelope dispatched")
  123. return nil, nil
  124. }); err != nil {
  125. t.Fatal(err)
  126. }
  127. var first, second Response
  128. if Read(&output, &first) != nil || first.Error == nil {
  129. t.Fatal("version failure missing")
  130. }
  131. if Read(&output, &second) != nil || second.Error != nil {
  132. t.Fatal("cancel response missing")
  133. }
  134. }