client_test.go 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234
  1. package plugins
  2. import (
  3. "bytes"
  4. "encoding/json"
  5. "io"
  6. "net/http"
  7. "net/http/httptest"
  8. "net/url"
  9. "strings"
  10. "testing"
  11. "time"
  12. "github.com/docker/docker/pkg/plugins/transport"
  13. "github.com/docker/go-connections/tlsconfig"
  14. "github.com/stretchr/testify/assert"
  15. )
  16. var (
  17. mux *http.ServeMux
  18. server *httptest.Server
  19. )
  20. func setupRemotePluginServer() string {
  21. mux = http.NewServeMux()
  22. server = httptest.NewServer(mux)
  23. return server.URL
  24. }
  25. func teardownRemotePluginServer() {
  26. if server != nil {
  27. server.Close()
  28. }
  29. }
  30. func TestFailedConnection(t *testing.T) {
  31. c, _ := NewClient("tcp://127.0.0.1:1", &tlsconfig.Options{InsecureSkipVerify: true})
  32. _, err := c.callWithRetry("Service.Method", nil, false)
  33. if err == nil {
  34. t.Fatal("Unexpected successful connection")
  35. }
  36. }
  37. func TestFailOnce(t *testing.T) {
  38. addr := setupRemotePluginServer()
  39. defer teardownRemotePluginServer()
  40. failed := false
  41. mux.HandleFunc("/Test.FailOnce", func(w http.ResponseWriter, r *http.Request) {
  42. if !failed {
  43. failed = true
  44. panic("Plugin not ready")
  45. }
  46. })
  47. c, _ := NewClient(addr, &tlsconfig.Options{InsecureSkipVerify: true})
  48. b := strings.NewReader("body")
  49. _, err := c.callWithRetry("Test.FailOnce", b, true)
  50. if err != nil {
  51. t.Fatal(err)
  52. }
  53. }
  54. func TestEchoInputOutput(t *testing.T) {
  55. addr := setupRemotePluginServer()
  56. defer teardownRemotePluginServer()
  57. m := Manifest{[]string{"VolumeDriver", "NetworkDriver"}}
  58. mux.HandleFunc("/Test.Echo", func(w http.ResponseWriter, r *http.Request) {
  59. if r.Method != "POST" {
  60. t.Fatalf("Expected POST, got %s\n", r.Method)
  61. }
  62. header := w.Header()
  63. header.Set("Content-Type", transport.VersionMimetype)
  64. io.Copy(w, r.Body)
  65. })
  66. c, _ := NewClient(addr, &tlsconfig.Options{InsecureSkipVerify: true})
  67. var output Manifest
  68. err := c.Call("Test.Echo", m, &output)
  69. if err != nil {
  70. t.Fatal(err)
  71. }
  72. assert.Equal(t, m, output)
  73. err = c.Call("Test.Echo", nil, nil)
  74. if err != nil {
  75. t.Fatal(err)
  76. }
  77. }
  78. func TestBackoff(t *testing.T) {
  79. cases := []struct {
  80. retries int
  81. expTimeOff time.Duration
  82. }{
  83. {0, time.Duration(1)},
  84. {1, time.Duration(2)},
  85. {2, time.Duration(4)},
  86. {4, time.Duration(16)},
  87. {6, time.Duration(30)},
  88. {10, time.Duration(30)},
  89. }
  90. for _, c := range cases {
  91. s := c.expTimeOff * time.Second
  92. if d := backoff(c.retries); d != s {
  93. t.Fatalf("Retry %v, expected %v, was %v\n", c.retries, s, d)
  94. }
  95. }
  96. }
  97. func TestAbortRetry(t *testing.T) {
  98. cases := []struct {
  99. timeOff time.Duration
  100. expAbort bool
  101. }{
  102. {time.Duration(1), false},
  103. {time.Duration(2), false},
  104. {time.Duration(10), false},
  105. {time.Duration(30), true},
  106. {time.Duration(40), true},
  107. }
  108. for _, c := range cases {
  109. s := c.timeOff * time.Second
  110. if a := abort(time.Now(), s); a != c.expAbort {
  111. t.Fatalf("Duration %v, expected %v, was %v\n", c.timeOff, s, a)
  112. }
  113. }
  114. }
  115. func TestClientScheme(t *testing.T) {
  116. cases := map[string]string{
  117. "tcp://127.0.0.1:8080": "http",
  118. "unix:///usr/local/plugins/foo": "http",
  119. "http://127.0.0.1:8080": "http",
  120. "https://127.0.0.1:8080": "https",
  121. }
  122. for addr, scheme := range cases {
  123. u, err := url.Parse(addr)
  124. if err != nil {
  125. t.Fatal(err)
  126. }
  127. s := httpScheme(u)
  128. if s != scheme {
  129. t.Fatalf("URL scheme mismatch, expected %s, got %s", scheme, s)
  130. }
  131. }
  132. }
  133. func TestNewClientWithTimeout(t *testing.T) {
  134. addr := setupRemotePluginServer()
  135. defer teardownRemotePluginServer()
  136. m := Manifest{[]string{"VolumeDriver", "NetworkDriver"}}
  137. mux.HandleFunc("/Test.Echo", func(w http.ResponseWriter, r *http.Request) {
  138. time.Sleep(time.Duration(600) * time.Millisecond)
  139. io.Copy(w, r.Body)
  140. })
  141. // setting timeout of 500ms
  142. timeout := time.Duration(500) * time.Millisecond
  143. c, _ := NewClientWithTimeout(addr, &tlsconfig.Options{InsecureSkipVerify: true}, timeout)
  144. var output Manifest
  145. err := c.Call("Test.Echo", m, &output)
  146. if err == nil {
  147. t.Fatal("Expected timeout error")
  148. }
  149. }
  150. func TestClientStream(t *testing.T) {
  151. addr := setupRemotePluginServer()
  152. defer teardownRemotePluginServer()
  153. m := Manifest{[]string{"VolumeDriver", "NetworkDriver"}}
  154. var output Manifest
  155. mux.HandleFunc("/Test.Echo", func(w http.ResponseWriter, r *http.Request) {
  156. if r.Method != "POST" {
  157. t.Fatalf("Expected POST, got %s", r.Method)
  158. }
  159. header := w.Header()
  160. header.Set("Content-Type", transport.VersionMimetype)
  161. io.Copy(w, r.Body)
  162. })
  163. c, _ := NewClient(addr, &tlsconfig.Options{InsecureSkipVerify: true})
  164. body, err := c.Stream("Test.Echo", m)
  165. if err != nil {
  166. t.Fatal(err)
  167. }
  168. defer body.Close()
  169. if err := json.NewDecoder(body).Decode(&output); err != nil {
  170. t.Fatalf("Test.Echo: error reading plugin resp: %v", err)
  171. }
  172. assert.Equal(t, m, output)
  173. }
  174. func TestClientSendFile(t *testing.T) {
  175. addr := setupRemotePluginServer()
  176. defer teardownRemotePluginServer()
  177. m := Manifest{[]string{"VolumeDriver", "NetworkDriver"}}
  178. var output Manifest
  179. var buf bytes.Buffer
  180. if err := json.NewEncoder(&buf).Encode(m); err != nil {
  181. t.Fatal(err)
  182. }
  183. mux.HandleFunc("/Test.Echo", func(w http.ResponseWriter, r *http.Request) {
  184. if r.Method != "POST" {
  185. t.Fatalf("Expected POST, got %s\n", r.Method)
  186. }
  187. header := w.Header()
  188. header.Set("Content-Type", transport.VersionMimetype)
  189. io.Copy(w, r.Body)
  190. })
  191. c, _ := NewClient(addr, &tlsconfig.Options{InsecureSkipVerify: true})
  192. if err := c.SendFile("Test.Echo", &buf, &output); err != nil {
  193. t.Fatal(err)
  194. }
  195. assert.Equal(t, m, output)
  196. }