gerrit.akraino Code Review - icn/sdwan.git/blob

   1 // SPDX-License-Identifier: Apache-2.0\r
   2 // Copyright (c) 2020 Intel Corporation\r
   3 \r
   4 package appcontext\r
   5 \r
   6 import (\r
   7         "fmt"\r
   8         "strings"\r
   9         "testing"\r
  10 \r
  11         pkgerrors "github.com/pkg/errors"\r
  12 )\r
  13 \r
  14 // Mock run time context\r
  15 type MockRunTimeContext struct {\r
  16         Items map[string]interface{}\r
  17         Err   error\r
  18 }\r
  19 \r
  20 type MockCompositeAppMeta struct {\r
  21         Project      string\r
  22         CompositeApp string\r
  23         Version      string\r
  24         Release      string\r
  25 }\r
  26 \r
  27 func (c *MockRunTimeContext) RtcCreate() (interface{}, error) {\r
  28         var key string = "/context/9345674458787728/"\r
  29 \r
  30         if c.Items == nil {\r
  31                 c.Items = make(map[string]interface{})\r
  32         }\r
  33         c.Items[key] = "9345674458787728"\r
  34         return interface{}(key), c.Err\r
  35 \r
  36 }\r
  37 \r
  38 func (c *MockRunTimeContext) RtcAddMeta(meta interface{}) error {\r
  39         var cid string = "/context/9345674458787728/"\r
  40         key := cid + "meta" + "/"\r
  41         if c.Items == nil {\r
  42                 c.Items = make(map[string]interface{})\r
  43         }\r
  44         c.Items[key] = meta\r
  45         return nil\r
  46 }\r
  47 \r
  48 func (c *MockRunTimeContext) RtcInit() (interface{}, error) {\r
  49         var id string = "9345674458787728"\r
  50         return id, c.Err\r
  51 }\r
  52 \r
  53 func (c *MockRunTimeContext) RtcLoad(id interface{}) (interface{}, error) {\r
  54         str := "/context/" + fmt.Sprintf("%v", id) + "/"\r
  55         return interface{}(str), c.Err\r
  56 }\r
  57 \r
  58 func (c *MockRunTimeContext) RtcGet() (interface{}, error) {\r
  59         var key string = "/context/9345674458787728/"\r
  60         return key, c.Err\r
  61 }\r
  62 \r
  63 func (c *MockRunTimeContext) RtcGetMeta() (interface{}, error) {\r
  64         meta := CompositeAppMeta{Project: "pn", CompositeApp: "ca", Version: "v", Release: "rName"}\r
  65         return meta, nil\r
  66 }\r
  67 \r
  68 func (c *MockRunTimeContext) RtcAddLevel(handle interface{}, level string, value string) (interface{}, error) {\r
  69         str := fmt.Sprintf("%v", handle) + level + "/" + value + "/"\r
  70         c.Items[str] = value\r
  71         return nil, c.Err\r
  72 \r
  73 }\r
  74 \r
  75 func (c *MockRunTimeContext) RtcAddOneLevel(handle interface{}, level string, value interface{}) (interface{}, error) {\r
  76         str := fmt.Sprintf("%v", handle) + level + "/"\r
  77         c.Items[str] = value\r
  78         return nil, c.Err\r
  79 \r
  80 }\r
  81 \r
  82 func (c *MockRunTimeContext) RtcAddResource(handle interface{}, resname string, value interface{}) (interface{}, error) {\r
  83         str := fmt.Sprintf("%v", handle) + "resource" + "/" + resname + "/"\r
  84         c.Items[str] = value\r
  85         return nil, c.Err\r
  86 \r
  87 }\r
  88 \r
  89 func (c *MockRunTimeContext) RtcAddInstruction(handle interface{}, level string, insttype string, value interface{}) (interface{}, error) {\r
  90         str := fmt.Sprintf("%v", handle) + level + "/" + insttype + "/"\r
  91         c.Items[str] = value\r
  92         return nil, c.Err\r
  93 }\r
  94 \r
  95 func (c *MockRunTimeContext) RtcDeletePair(handle interface{}) error {\r
  96         str := fmt.Sprintf("%v", handle)\r
  97         delete(c.Items, str)\r
  98         return c.Err\r
  99 }\r
 100 \r
 101 func (c *MockRunTimeContext) RtcDeletePrefix(handle interface{}) error {\r
 102         for k := range c.Items {\r
 103                 delete(c.Items, k)\r
 104         }\r
 105         return c.Err\r
 106 }\r
 107 \r
 108 func (c *MockRunTimeContext) RtcGetHandles(handle interface{}) ([]interface{}, error) {\r
 109         var keys []interface{}\r
 110 \r
 111         for k := range c.Items {\r
 112                 keys = append(keys, string(k))\r
 113         }\r
 114         return keys, c.Err\r
 115 }\r
 116 \r
 117 func (c *MockRunTimeContext) RtcGetValue(handle interface{}, value interface{}) error {\r
 118         key := fmt.Sprintf("%v", handle)\r
 119         var s *string\r
 120         s = value.(*string)\r
 121         for kvKey, kvValue := range c.Items {\r
 122                 if kvKey == key {\r
 123                         *s = kvValue.(string)\r
 124                         return c.Err\r
 125                 }\r
 126         }\r
 127         return c.Err\r
 128 }\r
 129 \r
 130 func (c *MockRunTimeContext) RtcUpdateValue(handle interface{}, value interface{}) error {\r
 131         key := fmt.Sprintf("%v", handle)\r
 132         c.Items[key] = value\r
 133         return c.Err\r
 134 }\r
 135 \r
 136 func TestCreateCompositeApp(t *testing.T) {\r
 137         var ac = AppContext{}\r
 138         testCases := []struct {\r
 139                 label         string\r
 140                 mockRtcontext *MockRunTimeContext\r
 141                 expectedError string\r
 142                 meta          interface{}\r
 143         }{\r
 144                 {\r
 145                         label:         "Success case",\r
 146                         mockRtcontext: &MockRunTimeContext{},\r
 147                         meta:          interface{}(MockCompositeAppMeta{Project: "Testproject", CompositeApp: "TestCompApp", Version: "CompAppVersion", Release: "TestRelease"}),\r
 148                 },\r
 149                 {\r
 150                         label:         "Create returns error case",\r
 151                         mockRtcontext: &MockRunTimeContext{Err: pkgerrors.Errorf("Error creating run time context:")},\r
 152                         expectedError: "Error creating run time context:",\r
 153                         meta:          interface{}(MockCompositeAppMeta{Project: "Testproject", CompositeApp: "TestCompApp", Version: "CompAppVersion", Release: "TestRelease"}),\r
 154                 },\r
 155         }\r
 156 \r
 157         for _, testCase := range testCases {\r
 158                 t.Run(testCase.label, func(t *testing.T) {\r
 159                         ac.rtc = testCase.mockRtcontext\r
 160                         _, err := ac.CreateCompositeApp()\r
 161                         if err != nil {\r
 162                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 163                                         t.Fatalf("Method returned an error (%s)", err)\r
 164                                 }\r
 165                         }\r
 166 \r
 167                 })\r
 168         }\r
 169 }\r
 170 \r
 171 func TestGetCompositeApp(t *testing.T) {\r
 172         var ac = AppContext{}\r
 173         testCases := []struct {\r
 174                 label         string\r
 175                 mockRtcontext *MockRunTimeContext\r
 176                 expectedError string\r
 177         }{\r
 178                 {\r
 179                         label:         "Success case",\r
 180                         mockRtcontext: &MockRunTimeContext{},\r
 181                 },\r
 182                 {\r
 183                         label:         "Get returns error case",\r
 184                         mockRtcontext: &MockRunTimeContext{Err: pkgerrors.Errorf("Error getting run time context:")},\r
 185                         expectedError: "Error getting run time context:",\r
 186                 },\r
 187         }\r
 188 \r
 189         for _, testCase := range testCases {\r
 190                 t.Run(testCase.label, func(t *testing.T) {\r
 191                         ac.rtc = testCase.mockRtcontext\r
 192                         _, err := ac.GetCompositeAppHandle()\r
 193                         if err != nil {\r
 194                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 195                                         t.Fatalf("Method returned an error (%s)", err)\r
 196                                 }\r
 197                         }\r
 198 \r
 199                 })\r
 200         }\r
 201 }\r
 202 \r
 203 func TestDeleteCompositeApp(t *testing.T) {\r
 204         var ac = AppContext{}\r
 205         testCases := []struct {\r
 206                 label         string\r
 207                 mockRtcontext *MockRunTimeContext\r
 208                 expectedError string\r
 209         }{\r
 210                 {\r
 211                         label:         "Success case",\r
 212                         mockRtcontext: &MockRunTimeContext{},\r
 213                 },\r
 214                 {\r
 215                         label:         "Delete returns error case",\r
 216                         mockRtcontext: &MockRunTimeContext{Err: pkgerrors.Errorf("Error deleting run time context:")},\r
 217                         expectedError: "Error deleting run time context:",\r
 218                 },\r
 219         }\r
 220 \r
 221         for _, testCase := range testCases {\r
 222                 t.Run(testCase.label, func(t *testing.T) {\r
 223                         ac.rtc = testCase.mockRtcontext\r
 224                         err := ac.DeleteCompositeApp()\r
 225                         if err != nil {\r
 226                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 227                                         t.Fatalf("Method returned an error (%s)", err)\r
 228                                 }\r
 229                         }\r
 230 \r
 231                 })\r
 232         }\r
 233 }\r
 234 \r
 235 func TestAddApp(t *testing.T) {\r
 236         var ac = AppContext{}\r
 237         testCases := []struct {\r
 238                 label         string\r
 239                 mockRtcontext *MockRunTimeContext\r
 240                 key           interface{}\r
 241                 expectedError string\r
 242                 meta          interface{}\r
 243         }{\r
 244                 {\r
 245                         label:         "Success case",\r
 246                         mockRtcontext: &MockRunTimeContext{},\r
 247                         key:           "/context/9345674458787728/",\r
 248                         meta:          interface{}(MockCompositeAppMeta{Project: "Testproject", CompositeApp: "TestCompApp", Version: "CompAppVersion", Release: "TestRelease"}),\r
 249                 },\r
 250                 {\r
 251                         label:         "Error case for adding app",\r
 252                         mockRtcontext: &MockRunTimeContext{Err: pkgerrors.Errorf("Error adding app to run time context:")},\r
 253                         key:           "/context/9345674458787728/",\r
 254                         expectedError: "Error adding app to run time context:",\r
 255                         meta:          interface{}(MockCompositeAppMeta{Project: "Testproject", CompositeApp: "TestCompApp", Version: "CompAppVersion", Release: "TestRelease"}),\r
 256                 },\r
 257         }\r
 258 \r
 259         for _, testCase := range testCases {\r
 260                 t.Run(testCase.label, func(t *testing.T) {\r
 261                         ac.rtc = testCase.mockRtcontext\r
 262                         _, err := ac.CreateCompositeApp()\r
 263                         _, err = ac.AddApp(testCase.key, "testapp1")\r
 264                         if err != nil {\r
 265                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 266                                         t.Fatalf("Method returned an error (%s)", err)\r
 267                                 }\r
 268                         }\r
 269 \r
 270                 })\r
 271         }\r
 272 }\r
 273 \r
 274 func TestGetAppHandle(t *testing.T) {\r
 275         var ac = AppContext{}\r
 276         testCases := []struct {\r
 277                 label         string\r
 278                 mockRtcontext *MockRunTimeContext\r
 279                 key           interface{}\r
 280                 appname       string\r
 281                 expectedError string\r
 282         }{\r
 283                 {\r
 284                         label:         "Success case",\r
 285                         mockRtcontext: &MockRunTimeContext{},\r
 286                         key:           "/context/9345674458787728/",\r
 287                         appname:       "testapp1",\r
 288                 },\r
 289                 {\r
 290                         label:         "Invalid app name case",\r
 291                         mockRtcontext: &MockRunTimeContext{},\r
 292                         key:           "/context/9345674458787728/",\r
 293                         appname:       "",\r
 294                 },\r
 295                 {\r
 296                         label:         "Delete returns error case",\r
 297                         mockRtcontext: &MockRunTimeContext{Err: pkgerrors.Errorf("Error getting app handle from run time context:")},\r
 298                         key:           "/context/9345674458787728/",\r
 299                         appname:       "testapp1",\r
 300                         expectedError: "Error getting app handle from run time context:",\r
 301                 },\r
 302         }\r
 303 \r
 304         for _, testCase := range testCases {\r
 305                 t.Run(testCase.label, func(t *testing.T) {\r
 306                         ac.rtc = testCase.mockRtcontext\r
 307                         _, err := ac.GetAppHandle(testCase.appname)\r
 308                         if err != nil {\r
 309                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 310                                         t.Fatalf("Method returned an error (%s)", err)\r
 311                                 }\r
 312                         }\r
 313 \r
 314                 })\r
 315         }\r
 316 }\r