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 rtcontext\r
   5 \r
   6 import (\r
   7         "github.com/open-ness/EMCO/src/orchestrator/pkg/infra/contextdb"\r
   8         pkgerrors "github.com/pkg/errors"\r
   9         "strings"\r
  10         "testing"\r
  11 )\r
  12 \r
  13 // MockContextDb for mocking contextdb\r
  14 type MockContextDb struct {\r
  15         Items map[string]interface{}\r
  16         Err   error\r
  17 }\r
  18 \r
  19 // Put function\r
  20 func (c *MockContextDb) Put(key string, val interface{}) error {\r
  21         if c.Items == nil {\r
  22                 c.Items = make(map[string]interface{})\r
  23         }\r
  24         c.Items[key] = val\r
  25         return c.Err\r
  26 }\r
  27 \r
  28 // Get function\r
  29 func (c *MockContextDb) Get(key string, val interface{}) error {\r
  30         var s *string\r
  31         s = val.(*string)\r
  32         for kvKey, kvValue := range c.Items {\r
  33                 if kvKey == key {\r
  34                         *s = kvValue.(string)\r
  35                         return c.Err\r
  36                 }\r
  37         }\r
  38         return c.Err\r
  39 }\r
  40 \r
  41 // Delete function\r
  42 func (c *MockContextDb) Delete(key string) error {\r
  43         delete(c.Items, key)\r
  44         return c.Err\r
  45 }\r
  46 \r
  47 // Delete all function\r
  48 func (c *MockContextDb) DeleteAll(key string) error {\r
  49         for kvKey := range c.Items {\r
  50                 delete(c.Items, kvKey)\r
  51         }\r
  52         return c.Err\r
  53 }\r
  54 \r
  55 // GetAllKeys function\r
  56 func (c *MockContextDb) GetAllKeys(path string) ([]string, error) {\r
  57         var keys []string\r
  58 \r
  59         for k := range c.Items {\r
  60                 keys = append(keys, string(k))\r
  61         }\r
  62         return keys, c.Err\r
  63 }\r
  64 \r
  65 func (c *MockContextDb) HealthCheck() error {\r
  66         return nil\r
  67 }\r
  68 \r
  69 func TestRtcInit(t *testing.T) {\r
  70         var rtc = RunTimeContext{}\r
  71         testCases := []struct {\r
  72                 label         string\r
  73                 mockContextDb *MockContextDb\r
  74                 expectedError string\r
  75         }{\r
  76                 {\r
  77                         label:         "Success case",\r
  78                         mockContextDb: &MockContextDb{},\r
  79                 },\r
  80                 {\r
  81                         label:         "Init returns error case",\r
  82                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")},\r
  83                         expectedError: "Error, context already initialized",\r
  84                 },\r
  85         }\r
  86 \r
  87         for _, testCase := range testCases {\r
  88                 t.Run(testCase.label, func(t *testing.T) {\r
  89                         contextdb.Db = testCase.mockContextDb\r
  90                         _, err := rtc.RtcInit()\r
  91                         if err != nil {\r
  92                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
  93                                         t.Fatalf("Method returned an error (%s)", err)\r
  94                                 }\r
  95                         }\r
  96 \r
  97                 })\r
  98         }\r
  99 }\r
 100 \r
 101 func TestRtcLoad(t *testing.T) {\r
 102         var rtc = RunTimeContext{"", ""}\r
 103         testCases := []struct {\r
 104                 label         string\r
 105                 mockContextDb *MockContextDb\r
 106                 id            string\r
 107                 expectedError string\r
 108         }{\r
 109                 {\r
 110                         label:         "Success case",\r
 111                         id:            "5345674458787728",\r
 112                         mockContextDb: &MockContextDb{},\r
 113                 },\r
 114                 {\r
 115                         label:         "reinit returns error case",\r
 116                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")},\r
 117                         id:            "8885674458787728",\r
 118                         expectedError: "Error finding the context id:",\r
 119                 },\r
 120         }\r
 121 \r
 122         for _, testCase := range testCases {\r
 123                 t.Run(testCase.label, func(t *testing.T) {\r
 124                         contextdb.Db = testCase.mockContextDb\r
 125                         _, err := rtc.RtcLoad("5345674458787728")\r
 126                         if err != nil {\r
 127                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 128                                         t.Fatalf("Method returned an error (%s)", err)\r
 129                                 }\r
 130                         }\r
 131 \r
 132                 })\r
 133         }\r
 134 }\r
 135 \r
 136 func TestRtcCreate(t *testing.T) {\r
 137         var rtc = RunTimeContext{"/context/5345674458787728/", ""}\r
 138         testCases := []struct {\r
 139                 label         string\r
 140                 mockContextDb *MockContextDb\r
 141                 expectedError string\r
 142         }{\r
 143                 {\r
 144                         label:         "Success case",\r
 145                         mockContextDb: &MockContextDb{},\r
 146                 },\r
 147                 {\r
 148                         label:         "Create returns error case",\r
 149                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")},\r
 150                         expectedError: "Error creating run time context:",\r
 151                 },\r
 152         }\r
 153 \r
 154         for _, testCase := range testCases {\r
 155                 t.Run(testCase.label, func(t *testing.T) {\r
 156                         contextdb.Db = testCase.mockContextDb\r
 157                         _, err := rtc.RtcCreate()\r
 158                         if err != nil {\r
 159                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 160                                         t.Fatalf("Method returned an error (%s)", err)\r
 161                                 }\r
 162                         }\r
 163 \r
 164                 })\r
 165         }\r
 166 }\r
 167 \r
 168 func TestRtcGet(t *testing.T) {\r
 169         var rtc = RunTimeContext{"/context/5345674458787728/", ""}\r
 170         testCases := []struct {\r
 171                 label         string\r
 172                 mockContextDb *MockContextDb\r
 173                 expectedError string\r
 174         }{\r
 175                 {\r
 176                         label:         "Success case",\r
 177                         mockContextDb: &MockContextDb{},\r
 178                 },\r
 179                 {\r
 180                         label:         "Get returns error case",\r
 181                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")},\r
 182                         expectedError: "Error getting run time context metadata:",\r
 183                 },\r
 184                 {\r
 185                         label:         "Context handle does not match",\r
 186                         mockContextDb: &MockContextDb{Err: nil},\r
 187                         expectedError: "Error matching run time context metadata",\r
 188                 },\r
 189         }\r
 190 \r
 191         for _, testCase := range testCases {\r
 192                 t.Run(testCase.label, func(t *testing.T) {\r
 193                         switch testCase.label {\r
 194                         case "Success case":\r
 195                                 contextdb.Db = testCase.mockContextDb\r
 196                                 chandle, err := rtc.RtcCreate()\r
 197                                 if err != nil {\r
 198                                         t.Fatalf("Create returned an error (%s)", err)\r
 199                                 }\r
 200                                 ghandle, err := rtc.RtcGet()\r
 201                                 if err != nil {\r
 202                                         t.Fatalf("Get returned an error (%s)", err)\r
 203                                 }\r
 204                                 if chandle != ghandle {\r
 205                                         t.Fatalf("Create and Get does not match")\r
 206                                 }\r
 207                         case "Get returns error case":\r
 208                                 contextdb.Db = testCase.mockContextDb\r
 209                                 _, err := rtc.RtcGet()\r
 210                                 if err != nil {\r
 211                                         if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 212                                                 t.Fatalf("Method returned an error (%s)", err)\r
 213                                         }\r
 214                                 }\r
 215                         case "Context handle does not match":\r
 216                                 contextdb.Db = testCase.mockContextDb\r
 217                                 contextdb.Db.Put("/context/5345674458787728/", "6345674458787728")\r
 218                                 _, err := rtc.RtcGet()\r
 219                                 if err != nil {\r
 220                                         if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 221                                                 t.Fatalf("Method returned an error (%s)", err)\r
 222                                         }\r
 223                                 }\r
 224                         }\r
 225                 })\r
 226         }\r
 227 }\r
 228 \r
 229 func TestRtcAddLevel(t *testing.T) {\r
 230         var rtc = RunTimeContext{"/context/3528435435454354/", ""}\r
 231         testCases := []struct {\r
 232                 label         string\r
 233                 mockContextDb *MockContextDb\r
 234                 handle        interface{}\r
 235                 level         string\r
 236                 value         string\r
 237                 expectedError string\r
 238         }{\r
 239                 {\r
 240                         label:         "Success case",\r
 241                         mockContextDb: &MockContextDb{},\r
 242                         handle:        "/context/3528435435454354/",\r
 243                         level:         "app",\r
 244                         value:         "testapp1",\r
 245                 },\r
 246                 {\r
 247                         label:         "Not a valid rtc handle",\r
 248                         mockContextDb: &MockContextDb{},\r
 249                         handle:        "/context/9528435435454354/",\r
 250                         level:         "app",\r
 251                         value:         "testapp1",\r
 252                         expectedError: "Not a valid run time context handle",\r
 253                 },\r
 254                 {\r
 255                         label:         "Not a valid rtc level",\r
 256                         mockContextDb: &MockContextDb{},\r
 257                         handle:        "/context/3528435435454354/",\r
 258                         level:         "",\r
 259                         value:         "testapp1",\r
 260                         expectedError: "Not a valid run time context level",\r
 261                 },\r
 262                 {\r
 263                         label:         "Not a valid rtc value",\r
 264                         mockContextDb: &MockContextDb{},\r
 265                         handle:        "/context/3528435435454354/",\r
 266                         level:         "app",\r
 267                         value:         "",\r
 268                         expectedError: "Not a valid run time context level value",\r
 269                 },\r
 270                 {\r
 271                         label:         "Put returns error",\r
 272                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")},\r
 273                         handle:        "/context/3528435435454354/",\r
 274                         level:         "app",\r
 275                         value:         "testapp1",\r
 276                         expectedError: "Error adding run time context level:",\r
 277                 },\r
 278         }\r
 279 \r
 280         for _, testCase := range testCases {\r
 281                 t.Run(testCase.label, func(t *testing.T) {\r
 282                         contextdb.Db = testCase.mockContextDb\r
 283                         _, err := rtc.RtcAddLevel(testCase.handle, testCase.level, testCase.value)\r
 284                         if err != nil {\r
 285                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 286                                         t.Fatalf("Method returned an error (%s)", err)\r
 287                                 }\r
 288                         }\r
 289                 })\r
 290         }\r
 291 }\r
 292 \r
 293 func TestRtcAddResource(t *testing.T) {\r
 294         var rtc = RunTimeContext{"/context/3528435435454354/", ""}\r
 295         testCases := []struct {\r
 296                 label         string\r
 297                 mockContextDb *MockContextDb\r
 298                 handle        interface{}\r
 299                 resname       string\r
 300                 value         interface{}\r
 301                 expectedError string\r
 302         }{\r
 303                 {\r
 304                         label:         "Success case",\r
 305                         mockContextDb: &MockContextDb{},\r
 306                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 307                         resname:       "R1",\r
 308                         value:         "res1",\r
 309                 },\r
 310                 {\r
 311                         label:         "Not a valid rtc handle",\r
 312                         mockContextDb: &MockContextDb{},\r
 313                         handle:        "/context/9528435435454354/app/apptest1/cluster/cluster1/",\r
 314                         resname:       "R1",\r
 315                         value:         "res1",\r
 316                         expectedError: "Not a valid run time context handle",\r
 317                 },\r
 318                 {\r
 319                         label:         "Not a valid rtc resource name",\r
 320                         mockContextDb: &MockContextDb{},\r
 321                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 322                         resname:       "",\r
 323                         value:         "res1",\r
 324                         expectedError: "Not a valid run time context resource name",\r
 325                 },\r
 326                 {\r
 327                         label:         "Not a valid rtc value",\r
 328                         mockContextDb: &MockContextDb{},\r
 329                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 330                         resname:       "R1",\r
 331                         value:         nil,\r
 332                         expectedError: "Not a valid run time context resource value",\r
 333                 },\r
 334                 {\r
 335                         label:         "Put returns error",\r
 336                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")},\r
 337                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 338                         resname:       "R1",\r
 339                         value:         "res1",\r
 340                         expectedError: "Error adding run time context resource:",\r
 341                 },\r
 342         }\r
 343 \r
 344         for _, testCase := range testCases {\r
 345                 t.Run(testCase.label, func(t *testing.T) {\r
 346                         contextdb.Db = testCase.mockContextDb\r
 347                         _, err := rtc.RtcAddResource(testCase.handle, testCase.resname, testCase.value)\r
 348                         if err != nil {\r
 349                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 350                                         t.Fatalf("Method returned an error (%s)", err)\r
 351                                 }\r
 352                         }\r
 353                 })\r
 354         }\r
 355 }\r
 356 \r
 357 func TestRtcAddInstruction(t *testing.T) {\r
 358         var rtc = RunTimeContext{"/context/3528435435454354/", ""}\r
 359         testCases := []struct {\r
 360                 label         string\r
 361                 mockContextDb *MockContextDb\r
 362                 handle        interface{}\r
 363                 level         string\r
 364                 insttype      string\r
 365                 value         interface{}\r
 366                 expectedError string\r
 367         }{\r
 368                 {\r
 369                         label:         "Success case",\r
 370                         mockContextDb: &MockContextDb{},\r
 371                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 372                         level:         "resource",\r
 373                         insttype:      "order",\r
 374                         value:         "{resorder: [R3, R1, R2]}",\r
 375                 },\r
 376                 {\r
 377                         label:         "Not a valid rtc handle",\r
 378                         mockContextDb: &MockContextDb{},\r
 379                         handle:        "/context/9528435435454354/app/apptest1/cluster/cluster1/",\r
 380                         level:         "resource",\r
 381                         insttype:      "order",\r
 382                         value:         "{resorder: [R3, R1, R2]}",\r
 383                         expectedError: "Not a valid run time context handle",\r
 384                 },\r
 385                 {\r
 386                         label:         "Not a valid rtc level name",\r
 387                         mockContextDb: &MockContextDb{},\r
 388                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 389                         level:         "",\r
 390                         insttype:      "order",\r
 391                         value:         "{resorder: [R3, R1, R2]}",\r
 392                         expectedError: "Not a valid run time context level",\r
 393                 },\r
 394                 {\r
 395                         label:         "Not a valid rtc instruction type",\r
 396                         mockContextDb: &MockContextDb{},\r
 397                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 398                         level:         "resource",\r
 399                         insttype:      "",\r
 400                         value:         "{resorder: [R3, R1, R2]}",\r
 401                         expectedError: "Not a valid run time context instruction type",\r
 402                 },\r
 403                 {\r
 404                         label:         "Not a valid rtc value",\r
 405                         mockContextDb: &MockContextDb{},\r
 406                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 407                         level:         "resource",\r
 408                         insttype:      "order",\r
 409                         value:         nil,\r
 410                         expectedError: "Not a valid run time context instruction value",\r
 411                 },\r
 412                 {\r
 413                         label:         "Put returns error",\r
 414                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")},\r
 415                         handle:        "/context/3528435435454354/app/apptest1/cluster/cluster1/",\r
 416                         level:         "resource",\r
 417                         insttype:      "order",\r
 418                         value:         "{resorder: [R3, R1, R2]}",\r
 419                         expectedError: "Error adding run time context instruction:",\r
 420                 },\r
 421         }\r
 422 \r
 423         for _, testCase := range testCases {\r
 424                 t.Run(testCase.label, func(t *testing.T) {\r
 425                         contextdb.Db = testCase.mockContextDb\r
 426                         _, err := rtc.RtcAddInstruction(testCase.handle, testCase.level, testCase.insttype, testCase.value)\r
 427                         if err != nil {\r
 428                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 429                                         t.Fatalf("Method returned an error (%s)", err)\r
 430                                 }\r
 431                         }\r
 432                 })\r
 433         }\r
 434 }\r
 435 \r
 436 func TestRtcGetHandles(t *testing.T) {\r
 437         var rtc = RunTimeContext{"/context/5345674458787728/", ""}\r
 438         testCases := []struct {\r
 439                 label         string\r
 440                 mockContextDb *MockContextDb\r
 441                 key           interface{}\r
 442                 expectedError string\r
 443         }{\r
 444                 {\r
 445                         label:         "Not valid input handle case",\r
 446                         mockContextDb: &MockContextDb{},\r
 447                         key:           "/context/3528435435454354/",\r
 448                         expectedError: "Not a valid run time context handle",\r
 449                 },\r
 450                 {\r
 451                         label:         "Contextdb call returns error case",\r
 452                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")},\r
 453                         key:           "/context/5345674458787728/",\r
 454                         expectedError: "Error getting run time context handles:",\r
 455                 },\r
 456                 {\r
 457                         label:         "Success case",\r
 458                         mockContextDb: &MockContextDb{},\r
 459                         key:           "/context/5345674458787728/",\r
 460                 },\r
 461         }\r
 462 \r
 463         for _, testCase := range testCases {\r
 464                 t.Run(testCase.label, func(t *testing.T) {\r
 465                         contextdb.Db = testCase.mockContextDb\r
 466                         if testCase.label == "Success case" {\r
 467                                 contextdb.Db.Put("/context/5345674458787728/", 5345674458787728)\r
 468                         }\r
 469                         _, err := rtc.RtcGetHandles(testCase.key)\r
 470                         if err != nil {\r
 471                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 472                                         t.Fatalf("Method returned an error (%s)", err)\r
 473                                 }\r
 474                         }\r
 475                 })\r
 476         }\r
 477 }\r
 478 \r
 479 func TestRtcGetValue(t *testing.T) {\r
 480         var rtc = RunTimeContext{"/context/5345674458787728/", ""}\r
 481         testCases := []struct {\r
 482                 label         string\r
 483                 mockContextDb *MockContextDb\r
 484                 key           interface{}\r
 485                 expectedError string\r
 486         }{\r
 487                 {\r
 488                         label:         "Not valid input handle case",\r
 489                         mockContextDb: &MockContextDb{},\r
 490                         key:           "/context/3528435435454354/",\r
 491                         expectedError: "Not a valid run time context handle",\r
 492                 },\r
 493                 {\r
 494                         label:         "Contextdb call returns error case",\r
 495                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")},\r
 496                         key:           "/context/5345674458787728/",\r
 497                         expectedError: "Error getting run time context value:",\r
 498                 },\r
 499                 {\r
 500                         label:         "Success case",\r
 501                         mockContextDb: &MockContextDb{},\r
 502                         key:           "/context/5345674458787728/",\r
 503                 },\r
 504         }\r
 505 \r
 506         for _, testCase := range testCases {\r
 507                 t.Run(testCase.label, func(t *testing.T) {\r
 508                         contextdb.Db = testCase.mockContextDb\r
 509                         if testCase.label == "Success case" {\r
 510                                 contextdb.Db.Put("/context/5345674458787728/", "5345674458787728")\r
 511                         }\r
 512                         var val string\r
 513                         err := rtc.RtcGetValue(testCase.key, &val)\r
 514                         if err != nil {\r
 515                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 516                                         t.Fatalf("Method returned an error (%s)", err)\r
 517                                 }\r
 518                         }\r
 519                 })\r
 520         }\r
 521 }\r
 522 \r
 523 func TestRtcUpdateValue(t *testing.T) {\r
 524         var rtc = RunTimeContext{"/context/5345674458787728/", ""}\r
 525         testCases := []struct {\r
 526                 label         string\r
 527                 mockContextDb *MockContextDb\r
 528                 key           interface{}\r
 529                 value         interface{}\r
 530                 expectedError string\r
 531         }{\r
 532                 {\r
 533                         label:         "Not valid input handle case",\r
 534                         mockContextDb: &MockContextDb{},\r
 535                         key:           "/context/3528435435454354/",\r
 536                         value:         "{apporder: [app1, app2, app3]}",\r
 537                         expectedError: "Not a valid run time context handle",\r
 538                 },\r
 539                 {\r
 540                         label:         "Contextdb call returns error case",\r
 541                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")},\r
 542                         key:           "/context/5345674458787728/",\r
 543                         value:         "{apporder: [app1, app2, app3]}",\r
 544                         expectedError: "Error updating run time context value:",\r
 545                 },\r
 546                 {\r
 547                         label:         "Success case",\r
 548                         mockContextDb: &MockContextDb{},\r
 549                         key:           "/context/5345674458787728/",\r
 550                         value:         "{apporder: [app2, app3, app1]}",\r
 551                 },\r
 552         }\r
 553 \r
 554         for _, testCase := range testCases {\r
 555                 t.Run(testCase.label, func(t *testing.T) {\r
 556                         contextdb.Db = testCase.mockContextDb\r
 557                         if testCase.label == "Success case" {\r
 558                                 contextdb.Db.Put("/context/5345674458787728/", "5345674458787728")\r
 559                         }\r
 560                         err := rtc.RtcUpdateValue(testCase.key, testCase.value)\r
 561                         if err != nil {\r
 562                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 563                                         t.Fatalf("Method returned an error (%s)", err)\r
 564                                 }\r
 565                         }\r
 566                 })\r
 567         }\r
 568 }\r
 569 \r
 570 func TestRtcDeletePair(t *testing.T) {\r
 571         var rtc = RunTimeContext{"/context/5345674458787728/", ""}\r
 572         testCases := []struct {\r
 573                 label         string\r
 574                 mockContextDb *MockContextDb\r
 575                 key           interface{}\r
 576                 expectedError string\r
 577         }{\r
 578                 {\r
 579                         label:         "Not valid input handle case",\r
 580                         mockContextDb: &MockContextDb{},\r
 581                         key:           "/context/3528435435454354/",\r
 582                         expectedError: "Not a valid run time context handle",\r
 583                 },\r
 584                 {\r
 585                         label:         "Contextdb call returns error case",\r
 586                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")},\r
 587                         key:           "/context/5345674458787728/",\r
 588                         expectedError: "Error deleting run time context pair:",\r
 589                 },\r
 590                 {\r
 591                         label:         "Success case",\r
 592                         mockContextDb: &MockContextDb{},\r
 593                         key:           "/context/5345674458787728/",\r
 594                 },\r
 595         }\r
 596 \r
 597         for _, testCase := range testCases {\r
 598                 t.Run(testCase.label, func(t *testing.T) {\r
 599                         contextdb.Db = testCase.mockContextDb\r
 600                         err := rtc.RtcDeletePair(testCase.key)\r
 601                         if err != nil {\r
 602                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 603                                         t.Fatalf("Method returned an error (%s)", err)\r
 604                                 }\r
 605                         }\r
 606                 })\r
 607         }\r
 608 }\r
 609 \r
 610 func TestRtcDeletePrefix(t *testing.T) {\r
 611         var rtc = RunTimeContext{"/context/5345674458787728/", ""}\r
 612         testCases := []struct {\r
 613                 label         string\r
 614                 mockContextDb *MockContextDb\r
 615                 key           interface{}\r
 616                 expectedError string\r
 617         }{\r
 618                 {\r
 619                         label:         "Not valid input handle case",\r
 620                         mockContextDb: &MockContextDb{},\r
 621                         key:           "/context/3528435435454354/",\r
 622                         expectedError: "Not a valid run time context handle",\r
 623                 },\r
 624                 {\r
 625                         label:         "Contextdb call returns error case",\r
 626                         mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")},\r
 627                         key:           "/context/5345674458787728/",\r
 628                         expectedError: "Error deleting run time context with prefix:",\r
 629                 },\r
 630                 {\r
 631                         label:         "Success case",\r
 632                         mockContextDb: &MockContextDb{},\r
 633                         key:           "/context/5345674458787728/",\r
 634                 },\r
 635         }\r
 636 \r
 637         for _, testCase := range testCases {\r
 638                 t.Run(testCase.label, func(t *testing.T) {\r
 639                         contextdb.Db = testCase.mockContextDb\r
 640                         err := rtc.RtcDeletePrefix(testCase.key)\r
 641                         if err != nil {\r
 642                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {\r
 643                                         t.Fatalf("Method returned an error (%s)", err)\r
 644                                 }\r
 645                         }\r
 646                 })\r
 647         }\r
 648 }\r