lib/controller/localdb/group_test.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package localdb
   6
   7 import (
   8         "context"
   9
  10         "git.arvados.org/arvados.git/lib/config"
  11         "git.arvados.org/arvados.git/lib/controller/rpc"
  12         "git.arvados.org/arvados.git/sdk/go/arvados"
  13         "git.arvados.org/arvados.git/sdk/go/arvadostest"
  14         "git.arvados.org/arvados.git/sdk/go/auth"
  15         "git.arvados.org/arvados.git/sdk/go/ctxlog"
  16         check "gopkg.in/check.v1"
  17 )
  18
  19 var _ = check.Suite(&GroupSuite{})
  20
  21 type GroupSuite struct {
  22         cluster  *arvados.Cluster
  23         localdb  *Conn
  24         railsSpy *arvadostest.Proxy
  25 }
  26
  27 func (s *GroupSuite) TearDownSuite(c *check.C) {
  28         // Undo any changes/additions to the user database so they
  29         // don't affect subsequent tests.
  30         arvadostest.ResetEnv()
  31         c.Check(arvados.NewClientFromEnv().RequestAndDecode(nil, "POST", "database/reset", nil, nil), check.IsNil)
  32 }
  33
  34 func (s *GroupSuite) SetUpTest(c *check.C) {
  35         cfg, err := config.NewLoader(nil, ctxlog.TestLogger(c)).Load()
  36         c.Assert(err, check.IsNil)
  37         s.cluster, err = cfg.GetCluster("")
  38         c.Assert(err, check.IsNil)
  39         s.localdb = NewConn(s.cluster)
  40         s.railsSpy = arvadostest.NewProxy(c, s.cluster.Services.RailsAPI)
  41         *s.localdb.railsProxy = *rpc.NewConn(s.cluster.ClusterID, s.railsSpy.URL, true, rpc.PassthroughTokenProvider)
  42 }
  43
  44 func (s *GroupSuite) TearDownTest(c *check.C) {
  45         s.railsSpy.Close()
  46 }
  47
  48 func (s *GroupSuite) setUpVocabulary(c *check.C, testVocabulary string) {
  49         if testVocabulary == "" {
  50                 testVocabulary = `{
  51                         "strict_tags": false,
  52                         "tags": {
  53                                 "IDTAGIMPORTANCES": {
  54                                         "strict": true,
  55                                         "labels": [{"label": "Importance"}, {"label": "Priority"}],
  56                                         "values": {
  57                                                 "IDVALIMPORTANCES1": { "labels": [{"label": "Critical"}, {"label": "Urgent"}, {"label": "High"}] },
  58                                                 "IDVALIMPORTANCES2": { "labels": [{"label": "Normal"}, {"label": "Moderate"}] },
  59                                                 "IDVALIMPORTANCES3": { "labels": [{"label": "Low"}] }
  60                                         }
  61                                 }
  62                         }
  63                 }`
  64         }
  65         voc, err := arvados.NewVocabulary([]byte(testVocabulary), []string{})
  66         c.Assert(err, check.IsNil)
  67         s.localdb.vocabularyCache = voc
  68         s.cluster.API.VocabularyPath = "foo"
  69 }
  70
  71 func (s *GroupSuite) TestGroupCreateWithProperties(c *check.C) {
  72         s.setUpVocabulary(c, "")
  73         ctx := auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{arvadostest.ActiveTokenV2}})
  74
  75         tests := []struct {
  76                 name    string
  77                 props   map[string]interface{}
  78                 success bool
  79         }{
  80                 {"Invalid prop key", map[string]interface{}{"Priority": "IDVALIMPORTANCES1"}, false},
  81                 {"Invalid prop value", map[string]interface{}{"IDTAGIMPORTANCES": "high"}, false},
  82                 {"Valid prop key & value", map[string]interface{}{"IDTAGIMPORTANCES": "IDVALIMPORTANCES1"}, true},
  83                 {"Empty properties", map[string]interface{}{}, true},
  84         }
  85         for _, tt := range tests {
  86                 c.Log(c.TestName()+" ", tt.name)
  87
  88                 grp, err := s.localdb.GroupCreate(ctx, arvados.CreateOptions{
  89                         Select: []string{"uuid", "properties"},
  90                         Attrs: map[string]interface{}{
  91                                 "group_class": "project",
  92                                 "properties":  tt.props,
  93                         }})
  94                 if tt.success {
  95                         c.Assert(err, check.IsNil)
  96                         c.Assert(grp.Properties, check.DeepEquals, tt.props)
  97                 } else {
  98                         c.Assert(err, check.NotNil)
  99                 }
 100         }
 101 }
 102
 103 func (s *GroupSuite) TestGroupUpdateWithProperties(c *check.C) {
 104         s.setUpVocabulary(c, "")
 105         ctx := auth.NewContext(context.Background(), &auth.Credentials{Tokens: []string{arvadostest.ActiveTokenV2}})
 106
 107         tests := []struct {
 108                 name    string
 109                 props   map[string]interface{}
 110                 success bool
 111         }{
 112                 {"Invalid prop key", map[string]interface{}{"Priority": "IDVALIMPORTANCES1"}, false},
 113                 {"Invalid prop value", map[string]interface{}{"IDTAGIMPORTANCES": "high"}, false},
 114                 {"Valid prop key & value", map[string]interface{}{"IDTAGIMPORTANCES": "IDVALIMPORTANCES1"}, true},
 115                 {"Empty properties", map[string]interface{}{}, true},
 116         }
 117         for _, tt := range tests {
 118                 c.Log(c.TestName()+" ", tt.name)
 119                 grp, err := s.localdb.GroupCreate(ctx, arvados.CreateOptions{
 120                         Attrs: map[string]interface{}{
 121                                 "group_class": "project",
 122                         },
 123                 })
 124                 c.Assert(err, check.IsNil)
 125                 grp, err = s.localdb.GroupUpdate(ctx, arvados.UpdateOptions{
 126                         UUID:   grp.UUID,
 127                         Select: []string{"uuid", "properties"},
 128                         Attrs: map[string]interface{}{
 129                                 "properties": tt.props,
 130                         }})
 131                 if tt.success {
 132                         c.Assert(err, check.IsNil)
 133                         c.Assert(grp.Properties, check.DeepEquals, tt.props)
 134                 } else {
 135                         c.Assert(err, check.NotNil)
 136                 }
 137         }
 138 }