From 8e1269b1f3958d2caa57464b1aac0d086e10c509 Mon Sep 17 00:00:00 2001 From: Manjunath Ranganathaiah Date: Mon, 30 Mar 2020 18:37:18 +0000 Subject: Add init and reinit interfaces to context libs Issue-ID: MULTICLOUD-1005 Signed-off-by: Manjunath Ranganathaiah Change-Id: I9839d265840c25b2fbfbe0265a65c65388eaebcb --- src/orchestrator/pkg/rtcontext/rtcontext.go | 66 +++- src/orchestrator/pkg/rtcontext/rtcontext_test.go | 415 +++++++++++++---------- 2 files changed, 289 insertions(+), 192 deletions(-) (limited to 'src/orchestrator/pkg/rtcontext') diff --git a/src/orchestrator/pkg/rtcontext/rtcontext.go b/src/orchestrator/pkg/rtcontext/rtcontext.go index e1f1c03b..1835251a 100644 --- a/src/orchestrator/pkg/rtcontext/rtcontext.go +++ b/src/orchestrator/pkg/rtcontext/rtcontext.go @@ -18,11 +18,11 @@ package rtcontext import ( "fmt" - "math/rand" - "time" - "strings" "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/contextdb" pkgerrors "github.com/pkg/errors" + "math/rand" + "strings" + "time" ) const maxrand = 0x7fffffffffffffff @@ -33,27 +33,59 @@ type RunTimeContext struct { } type Rtcontext interface { + RtcInit() (interface{}, error) + RtcLoad(interface{}) (interface{}, error) RtcCreate() (interface{}, error) RtcGet() (interface{}, error) RtcAddLevel(handle interface{}, level string, value string) (interface{}, error) RtcAddResource(handle interface{}, resname string, value interface{}) (interface{}, error) RtcAddInstruction(handle interface{}, level string, insttype string, value interface{}) (interface{}, error) - RtcDeletePair(handle interface{}) (error) - RtcDeletePrefix(handle interface{}) (error) + RtcDeletePair(handle interface{}) error + RtcDeletePrefix(handle interface{}) error RtcGetHandles(handle interface{}) ([]interface{}, error) - RtcGetValue(handle interface{}, value interface{}) (error) - RtcUpdateValue(handle interface{}, value interface{}) (error) + RtcGetValue(handle interface{}, value interface{}) error + RtcUpdateValue(handle interface{}, value interface{}) error } -//Create context by assiging a new id -func (rtc *RunTimeContext) RtcCreate() (interface{}, error) { - +//Intialize context by assiging a new id +func (rtc *RunTimeContext) RtcInit() (interface{}, error) { + if rtc.cid != nil { + return nil, pkgerrors.Errorf("Error, context already initialized") + } ra := rand.New(rand.NewSource(time.Now().UnixNano())) rn := ra.Int63n(maxrand) id := fmt.Sprintf("%v", rn) cid := (prefix + id + "/") rtc.cid = interface{}(cid) + return interface{}(id), nil + +} +//Load context using the given id +func (rtc *RunTimeContext) RtcLoad(id interface{}) (interface{}, error) { + str := fmt.Sprintf("%v", id) + if str == "" { + return nil, pkgerrors.Errorf("Not a valid context id") + } + cid := (prefix + str + "/") + rtc.cid = interface{}(cid) + handle, err := rtc.RtcGet() + if err != nil { + return nil, pkgerrors.Errorf("Error finding the context id: %s", err.Error()) + } + return handle, nil +} + +//Create context using the id and prefix +func (rtc *RunTimeContext) RtcCreate() (interface{}, error) { + cid := fmt.Sprintf("%v", rtc.cid) + if cid == "" { + return nil, pkgerrors.Errorf("Error, context not intialized") + } + if !strings.HasPrefix(cid, prefix) { + return nil, pkgerrors.Errorf("Not a valid run time context prefix") + } + id := strings.SplitN(cid, "/", 4)[2] err := contextdb.Db.Put(cid, id) if err != nil { return nil, pkgerrors.Errorf("Error creating run time context: %s", err.Error()) @@ -139,16 +171,16 @@ func (rtc *RunTimeContext) RtcAddInstruction(handle interface{}, level string, i if level == "" { return nil, pkgerrors.Errorf("Not a valid run time context level") } - if insttype == "" { + if insttype == "" { return nil, pkgerrors.Errorf("Not a valid run time context instruction type") } if value == nil { return nil, pkgerrors.Errorf("Not a valid run time context instruction value") } - k := str + level + "/" + "instruction" + "/" + insttype +"/" + k := str + level + "/" + "instruction" + "/" + insttype + "/" err := contextdb.Db.Put(k, fmt.Sprintf("%v", value)) - if err != nil { + if err != nil { return nil, pkgerrors.Errorf("Error adding run time context instruction: %s", err.Error()) } @@ -156,7 +188,7 @@ func (rtc *RunTimeContext) RtcAddInstruction(handle interface{}, level string, i } //Delete the key value pair using given handle -func (rtc *RunTimeContext) RtcDeletePair(handle interface{}) (error) { +func (rtc *RunTimeContext) RtcDeletePair(handle interface{}) error { str := fmt.Sprintf("%v", handle) sid := fmt.Sprintf("%v", rtc.cid) if !strings.HasPrefix(str, sid) { @@ -172,7 +204,7 @@ func (rtc *RunTimeContext) RtcDeletePair(handle interface{}) (error) { } // Delete all handles underneath the given handle -func (rtc *RunTimeContext) RtcDeletePrefix(handle interface{}) (error) { +func (rtc *RunTimeContext) RtcDeletePrefix(handle interface{}) error { str := fmt.Sprintf("%v", handle) sid := fmt.Sprintf("%v", rtc.cid) if !strings.HasPrefix(str, sid) { @@ -207,7 +239,7 @@ func (rtc *RunTimeContext) RtcGetHandles(handle interface{}) ([]interface{}, err } // Get the value for a given handle -func (rtc *RunTimeContext) RtcGetValue(handle interface{}, value interface{}) (error) { +func (rtc *RunTimeContext) RtcGetValue(handle interface{}, value interface{}) error { str := fmt.Sprintf("%v", handle) sid := fmt.Sprintf("%v", rtc.cid) if !strings.HasPrefix(str, sid) { @@ -223,7 +255,7 @@ func (rtc *RunTimeContext) RtcGetValue(handle interface{}, value interface{}) (e } // Update the value of a given handle -func (rtc *RunTimeContext) RtcUpdateValue(handle interface{}, value interface{}) (error) { +func (rtc *RunTimeContext) RtcUpdateValue(handle interface{}, value interface{}) error { str := fmt.Sprintf("%v", handle) sid := fmt.Sprintf("%v", rtc.cid) if !strings.HasPrefix(str, sid) { diff --git a/src/orchestrator/pkg/rtcontext/rtcontext_test.go b/src/orchestrator/pkg/rtcontext/rtcontext_test.go index 29df9a25..e9610ef0 100644 --- a/src/orchestrator/pkg/rtcontext/rtcontext_test.go +++ b/src/orchestrator/pkg/rtcontext/rtcontext_test.go @@ -17,21 +17,20 @@ package rtcontext import ( - "testing" - "strings" "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/contextdb" pkgerrors "github.com/pkg/errors" + "strings" + "testing" ) // MockContextDb for mocking contextdb type MockContextDb struct { - Items map[string]interface{} Err error } // Put function -func (c *MockContextDb) Put(key string, val interface{}) (error) { +func (c *MockContextDb) Put(key string, val interface{}) error { if c.Items == nil { c.Items = make(map[string]interface{}) } @@ -40,7 +39,7 @@ func (c *MockContextDb) Put(key string, val interface{}) (error) { } // Get function -func (c *MockContextDb) Get(key string, val interface{}) (error) { +func (c *MockContextDb) Get(key string, val interface{}) error { var s *string s = val.(*string) for kvKey, kvValue := range c.Items { @@ -53,13 +52,13 @@ func (c *MockContextDb) Get(key string, val interface{}) (error) { } // Delete function -func (c *MockContextDb) Delete(key string) (error) { +func (c *MockContextDb) Delete(key string) error { delete(c.Items, key) return c.Err } // Delete all function -func (c *MockContextDb) DeleteAll(key string) (error) { +func (c *MockContextDb) DeleteAll(key string) error { for kvKey, _ := range c.Items { delete(c.Items, kvKey) } @@ -80,19 +79,86 @@ func (c *MockContextDb) HealthCheck() error { return nil } -func TestRtcCreate(t *testing.T) { +func TestRtcInit(t *testing.T) { var rtc = RunTimeContext{} testCases := []struct { - label string + label string + mockContextDb *MockContextDb + expectedError string + }{ + { + label: "Success case", + mockContextDb: &MockContextDb{}, + }, + { + label: "Init returns error case", + mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")}, + expectedError: "Error, context already initialized", + }, + } + + for _, testCase := range testCases { + t.Run(testCase.label, func(t *testing.T) { + contextdb.Db = testCase.mockContextDb + _, err := rtc.RtcInit() + if err != nil { + if !strings.Contains(string(err.Error()), testCase.expectedError) { + t.Fatalf("Method returned an error (%s)", err) + } + } + + }) + } +} + +func TestRtcLoad(t *testing.T) { + var rtc = RunTimeContext{""} + testCases := []struct { + label string + mockContextDb *MockContextDb + id string + expectedError string + }{ + { + label: "Success case", + id: "5345674458787728", + mockContextDb: &MockContextDb{}, + }, + { + label: "reinit returns error case", + mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")}, + id: "8885674458787728", + expectedError: "Error finding the context id:", + }, + } + + for _, testCase := range testCases { + t.Run(testCase.label, func(t *testing.T) { + contextdb.Db = testCase.mockContextDb + _, err := rtc.RtcLoad("5345674458787728") + if err != nil { + if !strings.Contains(string(err.Error()), testCase.expectedError) { + t.Fatalf("Method returned an error (%s)", err) + } + } + + }) + } +} + +func TestRtcCreate(t *testing.T) { + var rtc = RunTimeContext{"/context/5345674458787728/"} + testCases := []struct { + label string mockContextDb *MockContextDb expectedError string }{ { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, }, { - label: "Create returns error case", + label: "Create returns error case", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")}, expectedError: "Error creating run time context:", }, @@ -113,24 +179,23 @@ func TestRtcCreate(t *testing.T) { } func TestRtcGet(t *testing.T) { - var rtc = RunTimeContext{} - var rtc1 = RunTimeContext{"/context/5345674458787728/"} + var rtc = RunTimeContext{"/context/5345674458787728/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb expectedError string }{ { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, }, { - label: "Get returns error case", + label: "Get returns error case", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")}, expectedError: "Error getting run time context metadata:", }, { - label: "Context handle does not match", + label: "Context handle does not match", mockContextDb: &MockContextDb{Err: nil}, expectedError: "Error matching run time context metadata", }, @@ -139,36 +204,36 @@ func TestRtcGet(t *testing.T) { for _, testCase := range testCases { t.Run(testCase.label, func(t *testing.T) { switch testCase.label { - case "Success case": - contextdb.Db = testCase.mockContextDb - chandle, err := rtc.RtcCreate() - if err != nil { - t.Fatalf("Create returned an error (%s)", err) - } - ghandle, err := rtc.RtcGet() - if err != nil { - t.Fatalf("Get returned an error (%s)", err) - } - if ( chandle != ghandle ) { - t.Fatalf("Create and Get does not match") - } - case "Get returns error case": - contextdb.Db = testCase.mockContextDb - _, err := rtc.RtcGet() - if err != nil { - if !strings.Contains(string(err.Error()), testCase.expectedError) { - t.Fatalf("Method returned an error (%s)", err) - } + case "Success case": + contextdb.Db = testCase.mockContextDb + chandle, err := rtc.RtcCreate() + if err != nil { + t.Fatalf("Create returned an error (%s)", err) + } + ghandle, err := rtc.RtcGet() + if err != nil { + t.Fatalf("Get returned an error (%s)", err) + } + if chandle != ghandle { + t.Fatalf("Create and Get does not match") + } + case "Get returns error case": + contextdb.Db = testCase.mockContextDb + _, err := rtc.RtcGet() + if err != nil { + if !strings.Contains(string(err.Error()), testCase.expectedError) { + t.Fatalf("Method returned an error (%s)", err) } - case "Context handle does not match": - contextdb.Db = testCase.mockContextDb - contextdb.Db.Put("/context/5345674458787728/", "6345674458787728") - _, err := rtc1.RtcGet() - if err != nil { - if !strings.Contains(string(err.Error()), testCase.expectedError) { - t.Fatalf("Method returned an error (%s)", err) - } + } + case "Context handle does not match": + contextdb.Db = testCase.mockContextDb + contextdb.Db.Put("/context/5345674458787728/", "6345674458787728") + _, err := rtc.RtcGet() + if err != nil { + if !strings.Contains(string(err.Error()), testCase.expectedError) { + t.Fatalf("Method returned an error (%s)", err) } + } } }) } @@ -177,50 +242,50 @@ func TestRtcGet(t *testing.T) { func TestRtcAddLevel(t *testing.T) { var rtc = RunTimeContext{"/context/3528435435454354/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - handle interface{} - level string - value string + handle interface{} + level string + value string expectedError string }{ { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/", - level: "app", - value: "testapp1", + handle: "/context/3528435435454354/", + level: "app", + value: "testapp1", }, { - label: "Not a valid rtc handle", + label: "Not a valid rtc handle", mockContextDb: &MockContextDb{}, - handle: "/context/9528435435454354/", - level: "app", - value: "testapp1", + handle: "/context/9528435435454354/", + level: "app", + value: "testapp1", expectedError: "Not a valid run time context handle", }, { - label: "Not a valid rtc level", + label: "Not a valid rtc level", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/", - level: "", - value: "testapp1", + handle: "/context/3528435435454354/", + level: "", + value: "testapp1", expectedError: "Not a valid run time context level", }, { - label: "Not a valid rtc value", + label: "Not a valid rtc value", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/", - level: "app", - value: "", + handle: "/context/3528435435454354/", + level: "app", + value: "", expectedError: "Not a valid run time context level value", }, { - label: "Put returns error", + label: "Put returns error", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")}, - handle: "/context/3528435435454354/", - level: "app", - value: "testapp1", + handle: "/context/3528435435454354/", + level: "app", + value: "testapp1", expectedError: "Error adding run time context level:", }, } @@ -241,50 +306,50 @@ func TestRtcAddLevel(t *testing.T) { func TestRtcAddResource(t *testing.T) { var rtc = RunTimeContext{"/context/3528435435454354/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - handle interface{} - resname string - value interface{} + handle interface{} + resname string + value interface{} expectedError string }{ { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - resname: "R1", - value: "res1", + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + resname: "R1", + value: "res1", }, { - label: "Not a valid rtc handle", + label: "Not a valid rtc handle", mockContextDb: &MockContextDb{}, - handle: "/context/9528435435454354/app/apptest1/cluster/cluster1/", - resname: "R1", - value: "res1", + handle: "/context/9528435435454354/app/apptest1/cluster/cluster1/", + resname: "R1", + value: "res1", expectedError: "Not a valid run time context handle", }, { - label: "Not a valid rtc resource name", + label: "Not a valid rtc resource name", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - resname: "", - value: "res1", + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + resname: "", + value: "res1", expectedError: "Not a valid run time context resource name", }, { - label: "Not a valid rtc value", + label: "Not a valid rtc value", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - resname: "R1", - value: nil, + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + resname: "R1", + value: nil, expectedError: "Not a valid run time context resource value", }, { - label: "Put returns error", + label: "Put returns error", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - resname: "R1", - value: "res1", + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + resname: "R1", + value: "res1", expectedError: "Error adding run time context resource:", }, } @@ -305,65 +370,65 @@ func TestRtcAddResource(t *testing.T) { func TestRtcAddInstruction(t *testing.T) { var rtc = RunTimeContext{"/context/3528435435454354/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - handle interface{} - level string - insttype string - value interface{} + handle interface{} + level string + insttype string + value interface{} expectedError string }{ { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - level: "resource", - insttype: "order", - value: "{resorder: [R3, R1, R2]}", + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + level: "resource", + insttype: "order", + value: "{resorder: [R3, R1, R2]}", }, { - label: "Not a valid rtc handle", + label: "Not a valid rtc handle", mockContextDb: &MockContextDb{}, - handle: "/context/9528435435454354/app/apptest1/cluster/cluster1/", - level: "resource", - insttype: "order", - value: "{resorder: [R3, R1, R2]}", + handle: "/context/9528435435454354/app/apptest1/cluster/cluster1/", + level: "resource", + insttype: "order", + value: "{resorder: [R3, R1, R2]}", expectedError: "Not a valid run time context handle", }, { - label: "Not a valid rtc level name", + label: "Not a valid rtc level name", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - level: "", - insttype: "order", - value: "{resorder: [R3, R1, R2]}", + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + level: "", + insttype: "order", + value: "{resorder: [R3, R1, R2]}", expectedError: "Not a valid run time context level", }, { - label: "Not a valid rtc instruction type", + label: "Not a valid rtc instruction type", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - level: "resource", - insttype: "", - value: "{resorder: [R3, R1, R2]}", + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + level: "resource", + insttype: "", + value: "{resorder: [R3, R1, R2]}", expectedError: "Not a valid run time context instruction type", }, { - label: "Not a valid rtc value", + label: "Not a valid rtc value", mockContextDb: &MockContextDb{}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - level: "resource", - insttype: "order", - value: nil, + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + level: "resource", + insttype: "order", + value: nil, expectedError: "Not a valid run time context instruction value", }, { - label: "Put returns error", + label: "Put returns error", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Client not intialized")}, - handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", - level: "resource", - insttype: "order", - value: "{resorder: [R3, R1, R2]}", + handle: "/context/3528435435454354/app/apptest1/cluster/cluster1/", + level: "resource", + insttype: "order", + value: "{resorder: [R3, R1, R2]}", expectedError: "Error adding run time context instruction:", }, } @@ -384,34 +449,34 @@ func TestRtcAddInstruction(t *testing.T) { func TestRtcGetHandles(t *testing.T) { var rtc = RunTimeContext{"/context/5345674458787728/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - key interface{} + key interface{} expectedError string }{ { - label: "Not valid input handle case", + label: "Not valid input handle case", mockContextDb: &MockContextDb{}, - key: "/context/3528435435454354/", + key: "/context/3528435435454354/", expectedError: "Not a valid run time context handle", }, { - label: "Contextdb call returns error case", + label: "Contextdb call returns error case", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", expectedError: "Error getting run time context handles:", }, { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", }, } for _, testCase := range testCases { t.Run(testCase.label, func(t *testing.T) { contextdb.Db = testCase.mockContextDb - if testCase.label == "Success case" { + if testCase.label == "Success case" { contextdb.Db.Put("/context/5345674458787728/", 5345674458787728) } _, err := rtc.RtcGetHandles(testCase.key) @@ -427,34 +492,34 @@ func TestRtcGetHandles(t *testing.T) { func TestRtcGetValue(t *testing.T) { var rtc = RunTimeContext{"/context/5345674458787728/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - key interface{} + key interface{} expectedError string }{ { - label: "Not valid input handle case", + label: "Not valid input handle case", mockContextDb: &MockContextDb{}, - key: "/context/3528435435454354/", + key: "/context/3528435435454354/", expectedError: "Not a valid run time context handle", }, { - label: "Contextdb call returns error case", + label: "Contextdb call returns error case", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", expectedError: "Error getting run time context value:", }, { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", }, } for _, testCase := range testCases { t.Run(testCase.label, func(t *testing.T) { contextdb.Db = testCase.mockContextDb - if testCase.label == "Success case" { + if testCase.label == "Success case" { contextdb.Db.Put("/context/5345674458787728/", "5345674458787728") } var val string @@ -471,38 +536,38 @@ func TestRtcGetValue(t *testing.T) { func TestRtcUpdateValue(t *testing.T) { var rtc = RunTimeContext{"/context/5345674458787728/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - key interface{} - value interface{} + key interface{} + value interface{} expectedError string }{ { - label: "Not valid input handle case", + label: "Not valid input handle case", mockContextDb: &MockContextDb{}, - key: "/context/3528435435454354/", - value: "{apporder: [app1, app2, app3]}", + key: "/context/3528435435454354/", + value: "{apporder: [app1, app2, app3]}", expectedError: "Not a valid run time context handle", }, { - label: "Contextdb call returns error case", + label: "Contextdb call returns error case", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")}, - key: "/context/5345674458787728/", - value: "{apporder: [app1, app2, app3]}", + key: "/context/5345674458787728/", + value: "{apporder: [app1, app2, app3]}", expectedError: "Error updating run time context value:", }, { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - key: "/context/5345674458787728/", - value: "{apporder: [app2, app3, app1]}", + key: "/context/5345674458787728/", + value: "{apporder: [app2, app3, app1]}", }, } for _, testCase := range testCases { t.Run(testCase.label, func(t *testing.T) { contextdb.Db = testCase.mockContextDb - if testCase.label == "Success case" { + if testCase.label == "Success case" { contextdb.Db.Put("/context/5345674458787728/", "5345674458787728") } err := rtc.RtcUpdateValue(testCase.key, testCase.value) @@ -518,27 +583,27 @@ func TestRtcUpdateValue(t *testing.T) { func TestRtcDeletePair(t *testing.T) { var rtc = RunTimeContext{"/context/5345674458787728/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - key interface{} + key interface{} expectedError string }{ { - label: "Not valid input handle case", + label: "Not valid input handle case", mockContextDb: &MockContextDb{}, - key: "/context/3528435435454354/", + key: "/context/3528435435454354/", expectedError: "Not a valid run time context handle", }, { - label: "Contextdb call returns error case", + label: "Contextdb call returns error case", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", expectedError: "Error deleting run time context pair:", }, { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", }, } @@ -558,27 +623,27 @@ func TestRtcDeletePair(t *testing.T) { func TestRtcDeletePrefix(t *testing.T) { var rtc = RunTimeContext{"/context/5345674458787728/"} testCases := []struct { - label string + label string mockContextDb *MockContextDb - key interface{} + key interface{} expectedError string }{ { - label: "Not valid input handle case", + label: "Not valid input handle case", mockContextDb: &MockContextDb{}, - key: "/context/3528435435454354/", + key: "/context/3528435435454354/", expectedError: "Not a valid run time context handle", }, { - label: "Contextdb call returns error case", + label: "Contextdb call returns error case", mockContextDb: &MockContextDb{Err: pkgerrors.Errorf("Key does not exist")}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", expectedError: "Error deleting run time context with prefix:", }, { - label: "Success case", + label: "Success case", mockContextDb: &MockContextDb{}, - key: "/context/5345674458787728/", + key: "/context/5345674458787728/", }, } -- cgit 1.2.3-korg