Prince Pereira | 32d40f2 | 2021-05-27 06:14:29 +0000 | [diff] [blame^] | 1 | /* |
| 2 | * Copyright 2020-present Open Networking Foundation |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | // Package modifiablecomponent stores ModifiableComponent methods and functions |
| 18 | package device |
| 19 | |
| 20 | import ( |
| 21 | "context" |
| 22 | "fmt" |
| 23 | "strings" |
| 24 | "testing" |
| 25 | |
| 26 | timestamp "github.com/golang/protobuf/ptypes/timestamp" |
| 27 | "github.com/opencord/device-management-interface/go/dmi" |
| 28 | "github.com/opencord/opendevice-manager/pkg/db" |
| 29 | ) |
| 30 | |
| 31 | // mockModifiableComp refers to mocking of modifiable component req |
| 32 | func mockModifiableComp(id string) *dmi.ModifiableComponent { |
| 33 | req := new(dmi.ModifiableComponent) |
| 34 | req.Name = "olt-name-" + id |
| 35 | req.Alias = "olt-1-alias-" + id |
| 36 | req.AssetId = "olt-1-assetid-" + id |
| 37 | req.Uri = new(dmi.Uri) |
| 38 | req.Uri.Uri = "127.0.0." + id |
| 39 | req.Parent = new(dmi.Component) |
| 40 | req.AdminState = dmi.ComponentAdminState_COMP_ADMIN_STATE_UNLOCKED |
| 41 | return req |
| 42 | } |
| 43 | |
| 44 | func mockHardware(id string) *dmi.Hardware { |
| 45 | hw := new(dmi.Hardware) |
| 46 | hw.LastChange = new(timestamp.Timestamp) |
| 47 | hw.LastBooted = new(timestamp.Timestamp) |
| 48 | hw.Root = new(dmi.Component) |
| 49 | hw.Root.ModelName = "model-name-" + id |
| 50 | return hw |
| 51 | } |
| 52 | |
| 53 | func runTcase(tcaseName string, t *testing.T, tcaseFunc func() (bool, error)) (string, bool) { |
| 54 | fmt.Println("\n#======= TESTCASE STARTED : " + tcaseName + " ========#") |
| 55 | if ok, err := tcaseFunc(); !ok { |
| 56 | fmt.Println("#======= TESTCASE FAILED : "+tcaseName+" ========#", err) |
| 57 | return tcaseName, false |
| 58 | } |
| 59 | fmt.Println("#======= TESTCASE PASSED : " + tcaseName + " ========#") |
| 60 | return tcaseName, true |
| 61 | } |
| 62 | |
| 63 | // _Test_PositiveTcaseNewDeviceRecord refers to the positive tcase defined for testing func NewDeviceRecord |
| 64 | func Test_PositiveTcaseNewDeviceRecord(t *testing.T) { |
| 65 | req := mockModifiableComp("1") |
| 66 | var rec *DeviceRecord |
| 67 | |
| 68 | db.MockKVClient() |
| 69 | ctx := context.Background() |
| 70 | defer db.ClearCache() |
| 71 | |
| 72 | // Positive Testcase for NewDeviceRecord |
| 73 | tcase1 := func() (bool, error) { |
| 74 | var err error |
| 75 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 76 | return false, err |
| 77 | } |
| 78 | return true, nil |
| 79 | } |
| 80 | |
| 81 | if name, ok := runTcase("Positive Testcase for NewDeviceRecord-1", t, tcase1); !ok { |
| 82 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 83 | return |
| 84 | } |
| 85 | } |
| 86 | |
| 87 | // _Test_NegativeTcaseDBGetByName refers to the negative tcase defined for testing func DBGetByName |
| 88 | func Test_NegativeTcaseDBGetByName(t *testing.T) { |
| 89 | req := mockModifiableComp("1") |
| 90 | |
| 91 | db.MockKVClient() |
| 92 | ctx := context.Background() |
| 93 | defer db.ClearCache() |
| 94 | |
| 95 | // Negative Testcase for DBGetByName |
| 96 | tcase2 := func() (bool, error) { |
| 97 | if rec, err := DBGetByName(ctx, req.Name); rec != nil { |
| 98 | return false, err |
| 99 | } |
| 100 | return true, nil |
| 101 | } |
| 102 | |
| 103 | if name, ok := runTcase("Negative Testcase for DBGetByName-1", t, tcase2); !ok { |
| 104 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 105 | return |
| 106 | } |
| 107 | } |
| 108 | |
| 109 | // _Test_Suite refers to all component testcases belongs to all packages |
| 110 | func Test_Suite(t *testing.T) { |
| 111 | } |
| 112 | |
| 113 | // _Test_NegativeTcaseDBAddByName refers to the negative tcase defined for testing func DBAddByName |
| 114 | func Test_NegativeTcaseDBAddByName(t *testing.T) { |
| 115 | |
| 116 | db.MockKVClient() |
| 117 | ctx := context.Background() |
| 118 | defer db.ClearCache() |
| 119 | |
| 120 | // Negative Testcase for DBAddByName |
| 121 | tcase3 := func() (bool, error) { |
| 122 | emptyDevRec := new(DeviceRecord) |
| 123 | if err := emptyDevRec.DBAddByName(ctx); err == nil { |
| 124 | return false, err |
| 125 | } |
| 126 | return true, nil |
| 127 | } |
| 128 | |
| 129 | if name, ok := runTcase("Negative Testcase for DBAddByName-1", t, tcase3); !ok { |
| 130 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 131 | return |
| 132 | } |
| 133 | |
| 134 | } |
| 135 | |
| 136 | // _Test_PositiveTcaseDBAddByName refers to the positive tcase defined for testing func DBAddByName |
| 137 | func Test_PositiveTcaseDBAddByName(t *testing.T) { |
| 138 | req := mockModifiableComp("1") |
| 139 | var rec *DeviceRecord |
| 140 | db.MockKVClient() |
| 141 | ctx := context.Background() |
| 142 | defer db.ClearCache() |
| 143 | |
| 144 | // Positive Testcase for DBAddByName |
| 145 | tcase4 := func() (bool, error) { |
| 146 | var err error |
| 147 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 148 | return false, err |
| 149 | } |
| 150 | if err = rec.DBAddByName(ctx); err != nil { |
| 151 | return false, err |
| 152 | } |
| 153 | return true, nil |
| 154 | } |
| 155 | |
| 156 | if name, ok := runTcase("Positive Testcase for DBAddByName-1", t, tcase4); !ok { |
| 157 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 158 | return |
| 159 | } |
| 160 | |
| 161 | } |
| 162 | |
| 163 | // _Test_PositiveTcaseDBGetByName refers to the positive tcase defined for testing func DBGetByName |
| 164 | func Test_PositiveTcaseDBGetByName(t *testing.T) { |
| 165 | req := mockModifiableComp("1") |
| 166 | var rec *DeviceRecord |
| 167 | db.MockKVClient() |
| 168 | ctx := context.Background() |
| 169 | defer db.ClearCache() |
| 170 | |
| 171 | // Positive Testcase for DBGetByName |
| 172 | tcase5 := func() (bool, error) { |
| 173 | var err error |
| 174 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 175 | return false, err |
| 176 | } |
| 177 | if err = rec.DBAddByName(ctx); err != nil { |
| 178 | return false, err |
| 179 | } |
| 180 | if rec, err := DBGetByName(ctx, rec.Name); rec == nil || err != nil { |
| 181 | return false, err |
| 182 | } |
| 183 | return true, nil |
| 184 | } |
| 185 | |
| 186 | if name, ok := runTcase("Positive Testcase for DBGetByName-1", t, tcase5); !ok { |
| 187 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 188 | return |
| 189 | } |
| 190 | |
| 191 | } |
| 192 | |
| 193 | // _Test_PositiveTcaseDBGetByNameWithCacheMiss refers to the positive tcase defined for testing func DBGetByName with cache miss |
| 194 | func Test_PositiveTcaseDBGetByNameWithCacheMiss(t *testing.T) { |
| 195 | req := mockModifiableComp("1") |
| 196 | var rec *DeviceRecord |
| 197 | db.MockKVClient() |
| 198 | ctx := context.Background() |
| 199 | defer db.ClearCache() |
| 200 | |
| 201 | // Positive Testcase for DBGetByName with cache miss |
| 202 | tcase5 := func() (bool, error) { |
| 203 | var err error |
| 204 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 205 | return false, err |
| 206 | } |
| 207 | if err = rec.DBAddByName(ctx); err != nil { |
| 208 | return false, err |
| 209 | } |
| 210 | if rec, err := DBGetByName(ctx, rec.Name); rec == nil || err != nil { |
| 211 | return false, err |
| 212 | } |
| 213 | ClearCacheEntry(ctx, rec.Name, "") |
| 214 | if rec, err := DBGetByName(ctx, rec.Name); rec == nil || err != nil { |
| 215 | return false, err |
| 216 | } |
| 217 | return true, nil |
| 218 | } |
| 219 | |
| 220 | if name, ok := runTcase("Positive Testcase for DBGetByName-2 with cache miss", t, tcase5); !ok { |
| 221 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 222 | return |
| 223 | } |
| 224 | |
| 225 | } |
| 226 | |
| 227 | // _Test_PositiveTcaseDBAddUuidLookup refers to the positive tcase defined for testing func DBAddUuidLookup |
| 228 | func Test_PositiveTcaseDBAddUuidLookup(t *testing.T) { |
| 229 | req := mockModifiableComp("1") |
| 230 | var rec *DeviceRecord |
| 231 | db.MockKVClient() |
| 232 | ctx := context.Background() |
| 233 | defer db.ClearCache() |
| 234 | |
| 235 | // Positive Testcase for DBAddUuidLookup |
| 236 | tcase6 := func() (bool, error) { |
| 237 | var err error |
| 238 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 239 | return false, err |
| 240 | } |
| 241 | if err = rec.DBAddByName(ctx); err != nil { |
| 242 | return false, err |
| 243 | } |
| 244 | rec.Uuid = strings.Replace(rec.Name, "name", "uuid", 1) |
| 245 | if err := rec.DBAddUuidLookup(ctx); err != nil { |
| 246 | return false, err |
| 247 | } |
| 248 | if err := rec.DBAddByName(ctx); err != nil { |
| 249 | return false, err |
| 250 | } |
| 251 | if rec, err := DBGetByName(ctx, rec.Name); rec == nil || err != nil || rec.Uuid == "" { |
| 252 | return false, err |
| 253 | } |
| 254 | return true, nil |
| 255 | } |
| 256 | |
| 257 | if name, ok := runTcase("Positive Testcase for DBAddUuidLookup-1", t, tcase6); !ok { |
| 258 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 259 | return |
| 260 | } |
| 261 | |
| 262 | } |
| 263 | |
| 264 | // _Test_PositiveTcaseDBGetAll refers to the positive tcase defined for testing func DBGetAll |
| 265 | func Test_PositiveTcaseDBGetAll(t *testing.T) { |
| 266 | req := mockModifiableComp("1") |
| 267 | var rec *DeviceRecord |
| 268 | db.MockKVClient() |
| 269 | ctx := context.Background() |
| 270 | defer db.ClearCache() |
| 271 | |
| 272 | // Positive Testcase for DBGetAll |
| 273 | tcase8 := func() (bool, error) { |
| 274 | var err error |
| 275 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 276 | return false, err |
| 277 | } |
| 278 | if err = rec.DBAddByName(ctx); err != nil { |
| 279 | return false, err |
| 280 | } |
| 281 | if list, err := DBGetAll(ctx); list == nil || err != nil || len(list) != 1 { |
| 282 | return false, err |
| 283 | } |
| 284 | return true, nil |
| 285 | } |
| 286 | |
| 287 | if name, ok := runTcase("Positive Testcase for DBGetAll-1", t, tcase8); !ok { |
| 288 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 289 | return |
| 290 | } |
| 291 | |
| 292 | } |
| 293 | |
| 294 | // _Test_NegativeTcaseDBGetByUuid refers to the negative tcase defined for testing func DBGetByUuid |
| 295 | func Test_NegativeTcaseDBGetByUuid(t *testing.T) { |
| 296 | |
| 297 | db.MockKVClient() |
| 298 | ctx := context.Background() |
| 299 | defer db.ClearCache() |
| 300 | |
| 301 | // Negative Testcase for DBGetByUuid |
| 302 | tcase10 := func() (bool, error) { |
| 303 | if rec, err := DBGetByUuid(ctx, "invalid-uuid-1"); rec != nil || err == nil { |
| 304 | return false, err |
| 305 | } |
| 306 | return true, nil |
| 307 | } |
| 308 | |
| 309 | if name, ok := runTcase("Negative Testcase for DBGetByUuid-1", t, tcase10); !ok { |
| 310 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 311 | return |
| 312 | } |
| 313 | |
| 314 | } |
| 315 | |
| 316 | // _Test_PositiveTcaseDBDelRecord refers to the positive tcase defined for testing func DBDelRecord |
| 317 | func Test_PositiveTcaseDBDelRecord(t *testing.T) { |
| 318 | req := mockModifiableComp("1") |
| 319 | var rec *DeviceRecord |
| 320 | db.MockKVClient() |
| 321 | ctx := context.Background() |
| 322 | defer db.ClearCache() |
| 323 | |
| 324 | // Positive Testcase for DBDelRecord |
| 325 | tcase11 := func() (bool, error) { |
| 326 | var err error |
| 327 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 328 | return false, err |
| 329 | } |
| 330 | if err = rec.DBAddByName(ctx); err != nil { |
| 331 | return false, err |
| 332 | } |
| 333 | if err := rec.DBDelRecord(ctx); err != nil { |
| 334 | return false, err |
| 335 | } |
| 336 | return true, nil |
| 337 | } |
| 338 | |
| 339 | if name, ok := runTcase("Positive Testcase for DBDelRecord-1", t, tcase11); !ok { |
| 340 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 341 | return |
| 342 | } |
| 343 | |
| 344 | } |
| 345 | |
| 346 | // _Test_PositiveTcaseDBSaveHwInfo refers to the positive tcase defined for testing func DBSaveHwInfo |
| 347 | func Test_PositiveTcaseDBSaveHwInfo(t *testing.T) { |
| 348 | req := mockModifiableComp("1") |
| 349 | var rec *DeviceRecord |
| 350 | db.MockKVClient() |
| 351 | ctx := context.Background() |
| 352 | defer db.ClearCache() |
| 353 | |
| 354 | // Positive Testcase for DBSaveHwInfo |
| 355 | tcase := func() (bool, error) { |
| 356 | var err error |
| 357 | if rec, err = NewDeviceRecord(ctx, req); rec == nil || err != nil { |
| 358 | return false, err |
| 359 | } |
| 360 | if err = rec.DBAddByName(ctx); err != nil { |
| 361 | return false, err |
| 362 | } |
| 363 | rec.Uuid = strings.Replace(rec.Name, "name", "uuid", 1) |
| 364 | if err := rec.DBAddUuidLookup(ctx); err != nil { |
| 365 | return false, err |
| 366 | } |
| 367 | hwInfo := mockHardware("1") |
| 368 | if err := rec.DBSaveHwInfo(ctx, hwInfo); rec == nil || err != nil { |
| 369 | return false, err |
| 370 | } |
| 371 | if rec, err := DBGetByName(ctx, rec.Name); rec == nil || err != nil || rec.ModelName != hwInfo.Root.ModelName { |
| 372 | return false, err |
| 373 | } |
| 374 | return true, nil |
| 375 | } |
| 376 | |
| 377 | if name, ok := runTcase("Positive Testcase for DBSaveHwInfo-1", t, tcase); !ok { |
| 378 | t.Errorf("#======= FAILED : Testcase " + name + " ========#") |
| 379 | return |
| 380 | } |
| 381 | |
| 382 | } |