sdk/go/arvadosclient/arvadosclient_test.go

   1 package arvadosclient
   2
   3 import (
   4         "git.curoverse.com/arvados.git/sdk/go/arvadostest"
   5         . "gopkg.in/check.v1"
   6         "net/http"
   7         "os"
   8         "testing"
   9         "time"
  10 )
  11
  12 // Gocheck boilerplate
  13 func Test(t *testing.T) {
  14         TestingT(t)
  15 }
  16
  17 var _ = Suite(&ServerRequiredSuite{})
  18 var _ = Suite(&UnitSuite{})
  19
  20 // Tests that require the Keep server running
  21 type ServerRequiredSuite struct{}
  22
  23 func (s *ServerRequiredSuite) SetUpSuite(c *C) {
  24         arvadostest.StartAPI()
  25         arvadostest.StartKeep(2, false)
  26 }
  27
  28 func (s *ServerRequiredSuite) SetUpTest(c *C) {
  29         arvadostest.ResetEnv()
  30 }
  31
  32 func (s *ServerRequiredSuite) TestMakeArvadosClientSecure(c *C) {
  33         os.Setenv("ARVADOS_API_HOST_INSECURE", "")
  34         kc, err := MakeArvadosClient()
  35         c.Assert(err, Equals, nil)
  36         c.Check(kc.ApiServer, Equals, os.Getenv("ARVADOS_API_HOST"))
  37         c.Check(kc.ApiToken, Equals, os.Getenv("ARVADOS_API_TOKEN"))
  38         c.Check(kc.ApiInsecure, Equals, false)
  39 }
  40
  41 func (s *ServerRequiredSuite) TestMakeArvadosClientInsecure(c *C) {
  42         os.Setenv("ARVADOS_API_HOST_INSECURE", "true")
  43         kc, err := MakeArvadosClient()
  44         c.Assert(err, Equals, nil)
  45         c.Check(kc.ApiInsecure, Equals, true)
  46         c.Check(kc.ApiServer, Equals, os.Getenv("ARVADOS_API_HOST"))
  47         c.Check(kc.ApiToken, Equals, os.Getenv("ARVADOS_API_TOKEN"))
  48         c.Check(kc.Client.Transport.(*http.Transport).TLSClientConfig.InsecureSkipVerify, Equals, true)
  49 }
  50
  51 func (s *ServerRequiredSuite) TestGetInvalidUUID(c *C) {
  52         arv, err := MakeArvadosClient()
  53
  54         getback := make(Dict)
  55         err = arv.Get("collections", "", nil, &getback)
  56         c.Assert(err, Equals, ErrInvalidArgument)
  57         c.Assert(len(getback), Equals, 0)
  58
  59         err = arv.Get("collections", "zebra-moose-unicorn", nil, &getback)
  60         c.Assert(err, Equals, ErrInvalidArgument)
  61         c.Assert(len(getback), Equals, 0)
  62
  63         err = arv.Get("collections", "acbd18db4cc2f85cedef654fccc4a4d8", nil, &getback)
  64         c.Assert(err, Equals, ErrInvalidArgument)
  65         c.Assert(len(getback), Equals, 0)
  66 }
  67
  68 func (s *ServerRequiredSuite) TestGetValidUUID(c *C) {
  69         arv, err := MakeArvadosClient()
  70
  71         getback := make(Dict)
  72         err = arv.Get("collections", "zzzzz-4zz18-abcdeabcdeabcde", nil, &getback)
  73         c.Assert(err, FitsTypeOf, APIServerError{})
  74         c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
  75         c.Assert(len(getback), Equals, 0)
  76
  77         err = arv.Get("collections", "acbd18db4cc2f85cedef654fccc4a4d8+3", nil, &getback)
  78         c.Assert(err, FitsTypeOf, APIServerError{})
  79         c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
  80         c.Assert(len(getback), Equals, 0)
  81 }
  82
  83 func (s *ServerRequiredSuite) TestInvalidResourceType(c *C) {
  84         arv, err := MakeArvadosClient()
  85
  86         getback := make(Dict)
  87         err = arv.Get("unicorns", "zzzzz-zebra-unicorn7unicorn", nil, &getback)
  88         c.Assert(err, FitsTypeOf, APIServerError{})
  89         c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
  90         c.Assert(len(getback), Equals, 0)
  91
  92         err = arv.Update("unicorns", "zzzzz-zebra-unicorn7unicorn", nil, &getback)
  93         c.Assert(err, FitsTypeOf, APIServerError{})
  94         c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
  95         c.Assert(len(getback), Equals, 0)
  96
  97         err = arv.List("unicorns", nil, &getback)
  98         c.Assert(err, FitsTypeOf, APIServerError{})
  99         c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
 100         c.Assert(len(getback), Equals, 0)
 101 }
 102
 103 func (s *ServerRequiredSuite) TestCreatePipelineTemplate(c *C) {
 104         arv, err := MakeArvadosClient()
 105
 106         for _, idleConnections := range []bool{
 107                 false,
 108                 true,
 109         } {
 110                 if idleConnections {
 111                         arv.lastClosedIdlesAt = time.Now().Add(-time.Minute)
 112                 } else {
 113                         arv.lastClosedIdlesAt = time.Now()
 114                 }
 115
 116                 getback := make(Dict)
 117                 err = arv.Create("pipeline_templates",
 118                         Dict{"pipeline_template": Dict{
 119                                 "name": "tmp",
 120                                 "components": Dict{
 121                                         "c1": map[string]string{"script": "script1"},
 122                                         "c2": map[string]string{"script": "script2"}}}},
 123                         &getback)
 124                 c.Assert(err, Equals, nil)
 125                 c.Assert(getback["name"], Equals, "tmp")
 126                 c.Assert(getback["components"].(map[string]interface{})["c2"].(map[string]interface{})["script"], Equals, "script2")
 127
 128                 uuid := getback["uuid"].(string)
 129
 130                 getback = make(Dict)
 131                 err = arv.Get("pipeline_templates", uuid, nil, &getback)
 132                 c.Assert(err, Equals, nil)
 133                 c.Assert(getback["name"], Equals, "tmp")
 134                 c.Assert(getback["components"].(map[string]interface{})["c1"].(map[string]interface{})["script"], Equals, "script1")
 135
 136                 getback = make(Dict)
 137                 err = arv.Update("pipeline_templates", uuid,
 138                         Dict{
 139                                 "pipeline_template": Dict{"name": "tmp2"}},
 140                         &getback)
 141                 c.Assert(err, Equals, nil)
 142                 c.Assert(getback["name"], Equals, "tmp2")
 143
 144                 c.Assert(getback["uuid"].(string), Equals, uuid)
 145                 getback = make(Dict)
 146                 err = arv.Delete("pipeline_templates", uuid, nil, &getback)
 147                 c.Assert(err, Equals, nil)
 148                 c.Assert(getback["name"], Equals, "tmp2")
 149         }
 150 }
 151
 152 func (s *ServerRequiredSuite) TestErrorResponse(c *C) {
 153         arv, _ := MakeArvadosClient()
 154
 155         getback := make(Dict)
 156
 157         {
 158                 err := arv.Create("logs",
 159                         Dict{"log": Dict{"bogus_attr": "foo"}},
 160                         &getback)
 161                 c.Assert(err, ErrorMatches, "arvados API server error: .*")
 162                 c.Assert(err, ErrorMatches, ".*unknown attribute: bogus_attr.*")
 163                 c.Assert(err, FitsTypeOf, APIServerError{})
 164                 c.Assert(err.(APIServerError).HttpStatusCode, Equals, 422)
 165         }
 166
 167         {
 168                 err := arv.Create("bogus",
 169                         Dict{"bogus": Dict{}},
 170                         &getback)
 171                 c.Assert(err, ErrorMatches, "arvados API server error: .*")
 172                 c.Assert(err, ErrorMatches, ".*Path not found.*")
 173                 c.Assert(err, FitsTypeOf, APIServerError{})
 174                 c.Assert(err.(APIServerError).HttpStatusCode, Equals, 404)
 175         }
 176 }
 177
 178 func (s *ServerRequiredSuite) TestAPIDiscovery_Get_defaultCollectionReplication(c *C) {
 179         arv, err := MakeArvadosClient()
 180         value, err := arv.Discovery("defaultCollectionReplication")
 181         c.Assert(err, IsNil)
 182         c.Assert(value, NotNil)
 183 }
 184
 185 func (s *ServerRequiredSuite) TestAPIDiscovery_Get_noSuchParameter(c *C) {
 186         arv, err := MakeArvadosClient()
 187         value, err := arv.Discovery("noSuchParameter")
 188         c.Assert(err, NotNil)
 189         c.Assert(value, IsNil)
 190 }
 191
 192 type UnitSuite struct{}
 193
 194 func (s *UnitSuite) TestUUIDMatch(c *C) {
 195         c.Assert(UUIDMatch("zzzzz-tpzed-000000000000000"), Equals, true)
 196         c.Assert(UUIDMatch("zzzzz-zebra-000000000000000"), Equals, true)
 197         c.Assert(UUIDMatch("00000-00000-zzzzzzzzzzzzzzz"), Equals, true)
 198         c.Assert(UUIDMatch("ZEBRA-HORSE-AFRICANELEPHANT"), Equals, false)
 199         c.Assert(UUIDMatch(" zzzzz-tpzed-000000000000000"), Equals, false)
 200         c.Assert(UUIDMatch("d41d8cd98f00b204e9800998ecf8427e"), Equals, false)
 201         c.Assert(UUIDMatch("d41d8cd98f00b204e9800998ecf8427e+0"), Equals, false)
 202         c.Assert(UUIDMatch(""), Equals, false)
 203 }
 204
 205 func (s *UnitSuite) TestPDHMatch(c *C) {
 206         c.Assert(PDHMatch("zzzzz-tpzed-000000000000000"), Equals, false)
 207         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e"), Equals, false)
 208         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+0"), Equals, true)
 209         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345"), Equals, true)
 210         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e 12345"), Equals, false)
 211         c.Assert(PDHMatch("D41D8CD98F00B204E9800998ECF8427E+12345"), Equals, false)
 212         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345 "), Equals, false)
 213         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+abcdef"), Equals, false)
 214         c.Assert(PDHMatch("da39a3ee5e6b4b0d3255bfef95601890afd80709"), Equals, false)
 215         c.Assert(PDHMatch("da39a3ee5e6b4b0d3255bfef95601890afd80709+0"), Equals, false)
 216         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427+12345"), Equals, false)
 217         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345\n"), Equals, false)
 218         c.Assert(PDHMatch("+12345"), Equals, false)
 219         c.Assert(PDHMatch(""), Equals, false)
 220 }