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) TearDownSuite(c *C) {
  29         arvadostest.StopKeep(2)
  30         arvadostest.StopAPI()
  31 }
  32
  33 func (s *ServerRequiredSuite) SetUpTest(c *C) {
  34         arvadostest.ResetEnv()
  35 }
  36
  37 func (s *ServerRequiredSuite) TestMakeArvadosClientSecure(c *C) {
  38         os.Setenv("ARVADOS_API_HOST_INSECURE", "")
  39         kc, err := MakeArvadosClient()
  40         c.Assert(err, Equals, nil)
  41         c.Check(kc.ApiServer, Equals, os.Getenv("ARVADOS_API_HOST"))
  42         c.Check(kc.ApiToken, Equals, os.Getenv("ARVADOS_API_TOKEN"))
  43         c.Check(kc.ApiInsecure, Equals, false)
  44 }
  45
  46 func (s *ServerRequiredSuite) TestMakeArvadosClientInsecure(c *C) {
  47         os.Setenv("ARVADOS_API_HOST_INSECURE", "true")
  48         kc, err := MakeArvadosClient()
  49         c.Assert(err, Equals, nil)
  50         c.Check(kc.ApiInsecure, Equals, true)
  51         c.Check(kc.ApiServer, Equals, os.Getenv("ARVADOS_API_HOST"))
  52         c.Check(kc.ApiToken, Equals, os.Getenv("ARVADOS_API_TOKEN"))
  53         c.Check(kc.Client.Transport.(*http.Transport).TLSClientConfig.InsecureSkipVerify, Equals, true)
  54 }
  55
  56 func (s *ServerRequiredSuite) TestGetInvalidUUID(c *C) {
  57         arv, err := MakeArvadosClient()
  58
  59         getback := make(Dict)
  60         err = arv.Get("collections", "", nil, &getback)
  61         c.Assert(err, Equals, ErrInvalidArgument)
  62         c.Assert(len(getback), Equals, 0)
  63
  64         err = arv.Get("collections", "zebra-moose-unicorn", nil, &getback)
  65         c.Assert(err, Equals, ErrInvalidArgument)
  66         c.Assert(len(getback), Equals, 0)
  67
  68         err = arv.Get("collections", "acbd18db4cc2f85cedef654fccc4a4d8", nil, &getback)
  69         c.Assert(err, Equals, ErrInvalidArgument)
  70         c.Assert(len(getback), Equals, 0)
  71 }
  72
  73 func (s *ServerRequiredSuite) TestGetValidUUID(c *C) {
  74         arv, err := MakeArvadosClient()
  75
  76         getback := make(Dict)
  77         err = arv.Get("collections", "zzzzz-4zz18-abcdeabcdeabcde", 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         err = arv.Get("collections", "acbd18db4cc2f85cedef654fccc4a4d8+3", nil, &getback)
  83         c.Assert(err, FitsTypeOf, APIServerError{})
  84         c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
  85         c.Assert(len(getback), Equals, 0)
  86 }
  87
  88 func (s *ServerRequiredSuite) TestInvalidResourceType(c *C) {
  89         arv, err := MakeArvadosClient()
  90
  91         getback := make(Dict)
  92         err = arv.Get("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.Update("unicorns", "zzzzz-zebra-unicorn7unicorn", 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         err = arv.List("unicorns", nil, &getback)
 103         c.Assert(err, FitsTypeOf, APIServerError{})
 104         c.Assert(err.(APIServerError).HttpStatusCode, Equals, http.StatusNotFound)
 105         c.Assert(len(getback), Equals, 0)
 106 }
 107
 108 func (s *ServerRequiredSuite) TestCreatePipelineTemplate(c *C) {
 109         arv, err := MakeArvadosClient()
 110
 111         for _, idleConnections := range []bool{
 112                 false,
 113                 true,
 114         } {
 115                 if idleConnections {
 116                         arv.lastClosedIdlesAt = time.Now().Add(-time.Minute)
 117                 } else {
 118                         arv.lastClosedIdlesAt = time.Now()
 119                 }
 120
 121                 getback := make(Dict)
 122                 err = arv.Create("pipeline_templates",
 123                         Dict{"pipeline_template": Dict{
 124                                 "name": "tmp",
 125                                 "components": Dict{
 126                                         "c1": map[string]string{"script": "script1"},
 127                                         "c2": map[string]string{"script": "script2"}}}},
 128                         &getback)
 129                 c.Assert(err, Equals, nil)
 130                 c.Assert(getback["name"], Equals, "tmp")
 131                 c.Assert(getback["components"].(map[string]interface{})["c2"].(map[string]interface{})["script"], Equals, "script2")
 132
 133                 uuid := getback["uuid"].(string)
 134
 135                 getback = make(Dict)
 136                 err = arv.Get("pipeline_templates", uuid, nil, &getback)
 137                 c.Assert(err, Equals, nil)
 138                 c.Assert(getback["name"], Equals, "tmp")
 139                 c.Assert(getback["components"].(map[string]interface{})["c1"].(map[string]interface{})["script"], Equals, "script1")
 140
 141                 getback = make(Dict)
 142                 err = arv.Update("pipeline_templates", uuid,
 143                         Dict{
 144                                 "pipeline_template": Dict{"name": "tmp2"}},
 145                         &getback)
 146                 c.Assert(err, Equals, nil)
 147                 c.Assert(getback["name"], Equals, "tmp2")
 148
 149                 c.Assert(getback["uuid"].(string), Equals, uuid)
 150                 getback = make(Dict)
 151                 err = arv.Delete("pipeline_templates", uuid, nil, &getback)
 152                 c.Assert(err, Equals, nil)
 153                 c.Assert(getback["name"], Equals, "tmp2")
 154         }
 155 }
 156
 157 func (s *ServerRequiredSuite) TestErrorResponse(c *C) {
 158         arv, _ := MakeArvadosClient()
 159
 160         getback := make(Dict)
 161
 162         {
 163                 err := arv.Create("logs",
 164                         Dict{"log": Dict{"bogus_attr": "foo"}},
 165                         &getback)
 166                 c.Assert(err, ErrorMatches, "arvados API server error: .*")
 167                 c.Assert(err, ErrorMatches, ".*unknown attribute: bogus_attr.*")
 168                 c.Assert(err, FitsTypeOf, APIServerError{})
 169                 c.Assert(err.(APIServerError).HttpStatusCode, Equals, 422)
 170         }
 171
 172         {
 173                 err := arv.Create("bogus",
 174                         Dict{"bogus": Dict{}},
 175                         &getback)
 176                 c.Assert(err, ErrorMatches, "arvados API server error: .*")
 177                 c.Assert(err, ErrorMatches, ".*Path not found.*")
 178                 c.Assert(err, FitsTypeOf, APIServerError{})
 179                 c.Assert(err.(APIServerError).HttpStatusCode, Equals, 404)
 180         }
 181 }
 182
 183 func (s *ServerRequiredSuite) TestAPIDiscovery_Get_defaultCollectionReplication(c *C) {
 184         arv, err := MakeArvadosClient()
 185         value, err := arv.Discovery("defaultCollectionReplication")
 186         c.Assert(err, IsNil)
 187         c.Assert(value, NotNil)
 188 }
 189
 190 func (s *ServerRequiredSuite) TestAPIDiscovery_Get_noSuchParameter(c *C) {
 191         arv, err := MakeArvadosClient()
 192         value, err := arv.Discovery("noSuchParameter")
 193         c.Assert(err, NotNil)
 194         c.Assert(value, IsNil)
 195 }
 196
 197 type UnitSuite struct{}
 198
 199 func (s *UnitSuite) TestUUIDMatch(c *C) {
 200         c.Assert(UUIDMatch("zzzzz-tpzed-000000000000000"), Equals, true)
 201         c.Assert(UUIDMatch("zzzzz-zebra-000000000000000"), Equals, true)
 202         c.Assert(UUIDMatch("00000-00000-zzzzzzzzzzzzzzz"), Equals, true)
 203         c.Assert(UUIDMatch("ZEBRA-HORSE-AFRICANELEPHANT"), Equals, false)
 204         c.Assert(UUIDMatch(" zzzzz-tpzed-000000000000000"), Equals, false)
 205         c.Assert(UUIDMatch("d41d8cd98f00b204e9800998ecf8427e"), Equals, false)
 206         c.Assert(UUIDMatch("d41d8cd98f00b204e9800998ecf8427e+0"), Equals, false)
 207         c.Assert(UUIDMatch(""), Equals, false)
 208 }
 209
 210 func (s *UnitSuite) TestPDHMatch(c *C) {
 211         c.Assert(PDHMatch("zzzzz-tpzed-000000000000000"), Equals, false)
 212         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e"), Equals, false)
 213         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+0"), Equals, true)
 214         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345"), Equals, true)
 215         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e 12345"), Equals, false)
 216         c.Assert(PDHMatch("D41D8CD98F00B204E9800998ECF8427E+12345"), Equals, false)
 217         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345 "), Equals, false)
 218         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+abcdef"), Equals, false)
 219         c.Assert(PDHMatch("da39a3ee5e6b4b0d3255bfef95601890afd80709"), Equals, false)
 220         c.Assert(PDHMatch("da39a3ee5e6b4b0d3255bfef95601890afd80709+0"), Equals, false)
 221         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427+12345"), Equals, false)
 222         c.Assert(PDHMatch("d41d8cd98f00b204e9800998ecf8427e+12345\n"), Equals, false)
 223         c.Assert(PDHMatch("+12345"), Equals, false)
 224         c.Assert(PDHMatch(""), Equals, false)
 225 }