5 "git.curoverse.com/arvados.git/sdk/go/arvadostest"
14 // Gocheck boilerplate
15 func Test(t *testing.T) {
19 var _ = Suite(&ServerRequiredSuite{})
20 var _ = Suite(&UnitSuite{})
21 var _ = Suite(&MockArvadosServerSuite{})
23 // Tests that require the Keep server running
24 type ServerRequiredSuite struct{}
26 func (s *ServerRequiredSuite) SetUpSuite(c *C) {
27 arvadostest.StartAPI()
28 arvadostest.StartKeep(2, false)
32 func (s *ServerRequiredSuite) SetUpTest(c *C) {
33 arvadostest.ResetEnv()
36 func (s *ServerRequiredSuite) TestMakeArvadosClientSecure(c *C) {
37 os.Setenv("ARVADOS_API_HOST_INSECURE", "")
38 kc, err := MakeArvadosClient()
39 c.Assert(err, Equals, nil)
40 c.Check(kc.ApiServer, Equals, os.Getenv("ARVADOS_API_HOST"))
41 c.Check(kc.ApiToken, Equals, os.Getenv("ARVADOS_API_TOKEN"))
42 c.Check(kc.ApiInsecure, Equals, false)
45 func (s *ServerRequiredSuite) TestMakeArvadosClientInsecure(c *C) {
46 os.Setenv("ARVADOS_API_HOST_INSECURE", "true")
47 kc, err := MakeArvadosClient()
48 c.Assert(err, Equals, nil)
49 c.Check(kc.ApiInsecure, Equals, true)
50 c.Check(kc.ApiServer, Equals, os.Getenv("ARVADOS_API_HOST"))
51 c.Check(kc.ApiToken, Equals, os.Getenv("ARVADOS_API_TOKEN"))
52 c.Check(kc.Client.Transport.(*http.Transport).TLSClientConfig.InsecureSkipVerify, Equals, true)
55 func (s *ServerRequiredSuite) TestGetInvalidUUID(c *C) {
56 arv, err := MakeArvadosClient()
59 err = arv.Get("collections", "", nil, &getback)
60 c.Assert(err, Equals, ErrInvalidArgument)
61 c.Assert(len(getback), Equals, 0)
63 err = arv.Get("collections", "zebra-moose-unicorn", nil, &getback)
64 c.Assert(err, Equals, ErrInvalidArgument)
65 c.Assert(len(getback), Equals, 0)
67 err = arv.Get("collections", "acbd18db4cc2f85cedef654fccc4a4d8", nil, &getback)
68 c.Assert(err, Equals, ErrInvalidArgument)
69 c.Assert(len(getback), Equals, 0)
72 func (s *ServerRequiredSuite) TestGetValidUUID(c *C) {
73 arv, err := MakeArvadosClient()
76 err = arv.Get("collections", "zzzzz-4zz18-abcdeabcdeabcde", nil, &getback)
77 c.Assert(err, FitsTypeOf, APIServerError{})
78 c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
79 c.Assert(len(getback), Equals, 0)
81 err = arv.Get("collections", "acbd18db4cc2f85cedef654fccc4a4d8+3", nil, &getback)
82 c.Assert(err, FitsTypeOf, APIServerError{})
83 c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
84 c.Assert(len(getback), Equals, 0)
87 func (s *ServerRequiredSuite) TestInvalidResourceType(c *C) {
88 arv, err := MakeArvadosClient()
91 err = arv.Get("unicorns", "zzzzz-zebra-unicorn7unicorn", nil, &getback)
92 c.Assert(err, FitsTypeOf, APIServerError{})
93 c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
94 c.Assert(len(getback), Equals, 0)
96 err = arv.Update("unicorns", "zzzzz-zebra-unicorn7unicorn", nil, &getback)
97 c.Assert(err, FitsTypeOf, APIServerError{})
98 c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
99 c.Assert(len(getback), Equals, 0)
101 err = arv.List("unicorns", nil, &getback)
102 c.Assert(err, FitsTypeOf, APIServerError{})
103 c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
104 c.Assert(len(getback), Equals, 0)
107 func (s *ServerRequiredSuite) TestCreatePipelineTemplate(c *C) {
108 arv, err := MakeArvadosClient()
110 for _, idleConnections := range []bool{
115 arv.lastClosedIdlesAt = time.Now().Add(-time.Minute)
117 arv.lastClosedIdlesAt = time.Now()
120 getback := make(Dict)
121 err = arv.Create("pipeline_templates",
122 Dict{"pipeline_template": Dict{
125 "c1": map[string]string{"script": "script1"},
126 "c2": map[string]string{"script": "script2"}}}},
128 c.Assert(err, Equals, nil)
129 c.Assert(getback["name"], Equals, "tmp")
130 c.Assert(getback["components"].(map[string]interface{})["c2"].(map[string]interface{})["script"], Equals, "script2")
132 uuid := getback["uuid"].(string)
135 err = arv.Get("pipeline_templates", uuid, nil, &getback)
136 c.Assert(err, Equals, nil)
137 c.Assert(getback["name"], Equals, "tmp")
138 c.Assert(getback["components"].(map[string]interface{})["c1"].(map[string]interface{})["script"], Equals, "script1")
141 err = arv.Update("pipeline_templates", uuid,
143 "pipeline_template": Dict{"name": "tmp2"}},
145 c.Assert(err, Equals, nil)
146 c.Assert(getback["name"], Equals, "tmp2")
148 c.Assert(getback["uuid"].(string), Equals, uuid)
150 err = arv.Delete("pipeline_templates", uuid, nil, &getback)
151 c.Assert(err, Equals, nil)
152 c.Assert(getback["name"], Equals, "tmp2")
156 func (s *ServerRequiredSuite) TestErrorResponse(c *C) {
157 arv, _ := MakeArvadosClient()
159 getback := make(Dict)
162 err := arv.Create("logs",
163 Dict{"log": Dict{"bogus_attr": "foo"}},
165 c.Assert(err, ErrorMatches, "arvados API server error: .*")
166 c.Assert(err, ErrorMatches, ".*unknown attribute: bogus_attr.*")
167 c.Assert(err, FitsTypeOf, APIServerError{})
168 c.Assert(err.(APIServerError).HttpStatusCode, Equals, 422)
172 err := arv.Create("bogus",
173 Dict{"bogus": Dict{}},
175 c.Assert(err, ErrorMatches, "arvados API server error: .*")
176 c.Assert(err, ErrorMatches, ".*Path not found.*")
177 c.Assert(err, FitsTypeOf, APIServerError{})
178 c.Assert(err.(APIServerError).HttpStatusCode, Equals, 404)
182 func (s *ServerRequiredSuite) TestAPIDiscovery_Get_defaultCollectionReplication(c *C) {
183 arv, err := MakeArvadosClient()
184 value, err := arv.Discovery("defaultCollectionReplication")
186 c.Assert(value, NotNil)
189 func (s *ServerRequiredSuite) TestAPIDiscovery_Get_noSuchParameter(c *C) {
190 arv, err := MakeArvadosClient()
191 value, err := arv.Discovery("noSuchParameter")
192 c.Assert(err, NotNil)
193 c.Assert(value, IsNil)
196 type UnitSuite struct{}
198 func (s *UnitSuite) TestUUIDMatch(c *C) {
199 c.Assert(UUIDMatch("zzzzz-tpzed-000000000000000"), Equals, true)
200 c.Assert(UUIDMatch("zzzzz-zebra-000000000000000"), Equals, true)
201 c.Assert(UUIDMatch("00000-00000-zzzzzzzzzzzzzzz"), Equals, true)
202 c.Assert(UUIDMatch("ZEBRA-HORSE-AFRICANELEPHANT"), Equals, false)
203 c.Assert(UUIDMatch(" zzzzz-tpzed-000000000000000"), Equals, false)
204 c.Assert(UUIDMatch("d41d8cd98f00b204e9800998ecf8427e"), Equals, false)
205 c.Assert(UUIDMatch("d41d8cd98f00b204e9800998ecf8427e+0"), Equals, false)
206 c.Assert(UUIDMatch(""), Equals, false)
209 func (s *UnitSuite) TestPDHMatch(c *C) {
210 c.Assert(PDHMatch("zzzzz-tpzed-000000000000000"), Equals, false)
211 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e"), Equals, false)
212 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+0"), Equals, true)
213 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345"), Equals, true)
214 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e 12345"), Equals, false)
215 c.Assert(PDHMatch("D41D8CD98F00B204E9800998ECF8427E+12345"), Equals, false)
216 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345 "), Equals, false)
217 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+abcdef"), Equals, false)
218 c.Assert(PDHMatch("da39a3ee5e6b4b0d3255bfef95601890afd80709"), Equals, false)
219 c.Assert(PDHMatch("da39a3ee5e6b4b0d3255bfef95601890afd80709+0"), Equals, false)
220 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427+12345"), Equals, false)
221 c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345\n"), Equals, false)
222 c.Assert(PDHMatch("+12345"), Equals, false)
223 c.Assert(PDHMatch(""), Equals, false)
226 // Tests that use mock arvados server
227 type MockArvadosServerSuite struct{}
229 func (s *MockArvadosServerSuite) SetUpSuite(c *C) {
233 func (s *MockArvadosServerSuite) SetUpTest(c *C) {
234 arvadostest.ResetEnv()
237 type APIServer struct {
238 listener net.Listener
242 func RunFakeArvadosServer(st http.Handler) (api APIServer, err error) {
243 api.listener, err = net.ListenTCP("tcp", &net.TCPAddr{Port: 0})
247 api.url = api.listener.Addr().String()
248 go http.Serve(api.listener, st)
252 type APIStub struct {
257 responseBody []string
260 func (h *APIStub) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
261 if req.URL.Path == "/redirect-loop" {
262 http.Redirect(resp, req, "/redirect-loop", http.StatusFound)
265 if h.respStatus[h.retryAttempts] < 0 {
266 // Fail the client's Do() by starting a redirect loop
267 http.Redirect(resp, req, "/redirect-loop", http.StatusFound)
269 resp.WriteHeader(h.respStatus[h.retryAttempts])
270 resp.Write([]byte(h.responseBody[h.retryAttempts]))
275 func (s *MockArvadosServerSuite) TestWithRetries(c *C) {
276 for _, stub := range []APIStub{
278 "get", 0, 200, []int{200, 500}, []string{`{"ok":"ok"}`, ``},
281 "create", 0, 200, []int{200, 500}, []string{`{"ok":"ok"}`, ``},
284 "get", 0, 500, []int{500, 500, 500, 200}, []string{``, ``, ``, `{"ok":"ok"}`},
287 "create", 0, 500, []int{500, 500, 500, 200}, []string{``, ``, ``, `{"ok":"ok"}`},
290 "update", 0, 500, []int{500, 500, 500, 200}, []string{``, ``, ``, `{"ok":"ok"}`},
293 "delete", 0, 500, []int{500, 500, 500, 200}, []string{``, ``, ``, `{"ok":"ok"}`},
296 "get", 0, 502, []int{500, 500, 502, 200}, []string{``, ``, ``, `{"ok":"ok"}`},
299 "create", 0, 502, []int{500, 500, 502, 200}, []string{``, ``, ``, `{"ok":"ok"}`},
302 "get", 0, 200, []int{500, 500, 200}, []string{``, ``, `{"ok":"ok"}`},
305 "create", 0, 200, []int{500, 500, 200}, []string{``, ``, `{"ok":"ok"}`},
308 "delete", 0, 200, []int{500, 500, 200}, []string{``, ``, `{"ok":"ok"}`},
311 "update", 0, 200, []int{500, 500, 200}, []string{``, ``, `{"ok":"ok"}`},
314 "get", 0, 401, []int{401, 200}, []string{``, `{"ok":"ok"}`},
317 "create", 0, 401, []int{401, 200}, []string{``, `{"ok":"ok"}`},
320 "get", 0, 404, []int{404, 200}, []string{``, `{"ok":"ok"}`},
323 "get", 0, 401, []int{500, 401, 200}, []string{``, ``, `{"ok":"ok"}`},
326 // Response code -1 simulates an HTTP/network error
327 // (i.e., Do() returns an error; there is no HTTP
328 // response status code).
330 // Succeed on second retry
332 "get", 0, 200, []int{-1, -1, 200}, []string{``, ``, `{"ok":"ok"}`},
334 // "POST" is not safe to retry: fail after one error
336 "create", 0, -1, []int{-1, 200}, []string{``, `{"ok":"ok"}`},
339 api, err := RunFakeArvadosServer(&stub)
342 defer api.listener.Close()
344 arv := ArvadosClient{
349 Client: &http.Client{Transport: &http.Transport{}},
352 getback := make(Dict)
355 err = arv.Get("collections", "zzzzz-4zz18-znfnqtbbv4spc3w", nil, &getback)
357 err = arv.Create("collections",
358 Dict{"collection": Dict{"name": "testing"}},
361 err = arv.Update("collections", "zzzzz-4zz18-znfnqtbbv4spc3w",
362 Dict{"collection": Dict{"name": "testing"}},
365 err = arv.Delete("pipeline_templates", "zzzzz-4zz18-znfnqtbbv4spc3w", nil, &getback)
368 switch stub.expected {
371 c.Check(getback["ok"], Equals, "ok")
374 c.Check(err, ErrorMatches, `.*stopped after \d+ redirects`)
377 c.Check(err, ErrorMatches, fmt.Sprintf("arvados API server error: %d.*", stub.expected))
378 c.Check(err.(APIServerError).HttpStatusCode, Equals, stub.expected)