github.com/DelineaXPM/dsv-cli@v1.40.6/tests/fake/fake_store.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package fake 3 4 import ( 5 "sync" 6 7 "github.com/DelineaXPM/dsv-cli/internal/store" 8 ) 9 10 type FakeStore struct { 11 DeleteStub func(string) error 12 deleteMutex sync.RWMutex 13 deleteArgsForCall []struct { 14 arg1 string 15 } 16 deleteReturns struct { 17 result1 error 18 } 19 deleteReturnsOnCall map[int]struct { 20 result1 error 21 } 22 GetStub func(string, any) error 23 getMutex sync.RWMutex 24 getArgsForCall []struct { 25 arg1 string 26 arg2 any 27 } 28 getReturns struct { 29 result1 error 30 } 31 getReturnsOnCall map[int]struct { 32 result1 error 33 } 34 ListStub func(string) ([]string, error) 35 listMutex sync.RWMutex 36 listArgsForCall []struct { 37 arg1 string 38 } 39 listReturns struct { 40 result1 []string 41 result2 error 42 } 43 listReturnsOnCall map[int]struct { 44 result1 []string 45 result2 error 46 } 47 StoreStub func(string, any) error 48 storeMutex sync.RWMutex 49 storeArgsForCall []struct { 50 arg1 string 51 arg2 any 52 } 53 storeReturns struct { 54 result1 error 55 } 56 storeReturnsOnCall map[int]struct { 57 result1 error 58 } 59 StoreStringStub func(string, string) error 60 storeStringMutex sync.RWMutex 61 storeStringArgsForCall []struct { 62 arg1 string 63 arg2 string 64 } 65 storeStringReturns struct { 66 result1 error 67 } 68 storeStringReturnsOnCall map[int]struct { 69 result1 error 70 } 71 WipeStub func(string) error 72 wipeMutex sync.RWMutex 73 wipeArgsForCall []struct { 74 arg1 string 75 } 76 wipeReturns struct { 77 result1 error 78 } 79 wipeReturnsOnCall map[int]struct { 80 result1 error 81 } 82 invocations map[string][][]interface{} 83 invocationsMutex sync.RWMutex 84 } 85 86 func (fake *FakeStore) Delete(arg1 string) error { 87 fake.deleteMutex.Lock() 88 ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] 89 fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { 90 arg1 string 91 }{arg1}) 92 stub := fake.DeleteStub 93 fakeReturns := fake.deleteReturns 94 fake.recordInvocation("Delete", []interface{}{arg1}) 95 fake.deleteMutex.Unlock() 96 if stub != nil { 97 return stub(arg1) 98 } 99 if specificReturn { 100 return ret.result1 101 } 102 return fakeReturns.result1 103 } 104 105 func (fake *FakeStore) DeleteCallCount() int { 106 fake.deleteMutex.RLock() 107 defer fake.deleteMutex.RUnlock() 108 return len(fake.deleteArgsForCall) 109 } 110 111 func (fake *FakeStore) DeleteCalls(stub func(string) error) { 112 fake.deleteMutex.Lock() 113 defer fake.deleteMutex.Unlock() 114 fake.DeleteStub = stub 115 } 116 117 func (fake *FakeStore) DeleteArgsForCall(i int) string { 118 fake.deleteMutex.RLock() 119 defer fake.deleteMutex.RUnlock() 120 argsForCall := fake.deleteArgsForCall[i] 121 return argsForCall.arg1 122 } 123 124 func (fake *FakeStore) DeleteReturns(result1 error) { 125 fake.deleteMutex.Lock() 126 defer fake.deleteMutex.Unlock() 127 fake.DeleteStub = nil 128 fake.deleteReturns = struct { 129 result1 error 130 }{result1} 131 } 132 133 func (fake *FakeStore) DeleteReturnsOnCall(i int, result1 error) { 134 fake.deleteMutex.Lock() 135 defer fake.deleteMutex.Unlock() 136 fake.DeleteStub = nil 137 if fake.deleteReturnsOnCall == nil { 138 fake.deleteReturnsOnCall = make(map[int]struct { 139 result1 error 140 }) 141 } 142 fake.deleteReturnsOnCall[i] = struct { 143 result1 error 144 }{result1} 145 } 146 147 func (fake *FakeStore) Get(arg1 string, arg2 any) error { 148 fake.getMutex.Lock() 149 ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] 150 fake.getArgsForCall = append(fake.getArgsForCall, struct { 151 arg1 string 152 arg2 any 153 }{arg1, arg2}) 154 stub := fake.GetStub 155 fakeReturns := fake.getReturns 156 fake.recordInvocation("Get", []interface{}{arg1, arg2}) 157 fake.getMutex.Unlock() 158 if stub != nil { 159 return stub(arg1, arg2) 160 } 161 if specificReturn { 162 return ret.result1 163 } 164 return fakeReturns.result1 165 } 166 167 func (fake *FakeStore) GetCallCount() int { 168 fake.getMutex.RLock() 169 defer fake.getMutex.RUnlock() 170 return len(fake.getArgsForCall) 171 } 172 173 func (fake *FakeStore) GetCalls(stub func(string, any) error) { 174 fake.getMutex.Lock() 175 defer fake.getMutex.Unlock() 176 fake.GetStub = stub 177 } 178 179 func (fake *FakeStore) GetArgsForCall(i int) (string, any) { 180 fake.getMutex.RLock() 181 defer fake.getMutex.RUnlock() 182 argsForCall := fake.getArgsForCall[i] 183 return argsForCall.arg1, argsForCall.arg2 184 } 185 186 func (fake *FakeStore) GetReturns(result1 error) { 187 fake.getMutex.Lock() 188 defer fake.getMutex.Unlock() 189 fake.GetStub = nil 190 fake.getReturns = struct { 191 result1 error 192 }{result1} 193 } 194 195 func (fake *FakeStore) GetReturnsOnCall(i int, result1 error) { 196 fake.getMutex.Lock() 197 defer fake.getMutex.Unlock() 198 fake.GetStub = nil 199 if fake.getReturnsOnCall == nil { 200 fake.getReturnsOnCall = make(map[int]struct { 201 result1 error 202 }) 203 } 204 fake.getReturnsOnCall[i] = struct { 205 result1 error 206 }{result1} 207 } 208 209 func (fake *FakeStore) List(arg1 string) ([]string, error) { 210 fake.listMutex.Lock() 211 ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] 212 fake.listArgsForCall = append(fake.listArgsForCall, struct { 213 arg1 string 214 }{arg1}) 215 stub := fake.ListStub 216 fakeReturns := fake.listReturns 217 fake.recordInvocation("List", []interface{}{arg1}) 218 fake.listMutex.Unlock() 219 if stub != nil { 220 return stub(arg1) 221 } 222 if specificReturn { 223 return ret.result1, ret.result2 224 } 225 return fakeReturns.result1, fakeReturns.result2 226 } 227 228 func (fake *FakeStore) ListCallCount() int { 229 fake.listMutex.RLock() 230 defer fake.listMutex.RUnlock() 231 return len(fake.listArgsForCall) 232 } 233 234 func (fake *FakeStore) ListCalls(stub func(string) ([]string, error)) { 235 fake.listMutex.Lock() 236 defer fake.listMutex.Unlock() 237 fake.ListStub = stub 238 } 239 240 func (fake *FakeStore) ListArgsForCall(i int) string { 241 fake.listMutex.RLock() 242 defer fake.listMutex.RUnlock() 243 argsForCall := fake.listArgsForCall[i] 244 return argsForCall.arg1 245 } 246 247 func (fake *FakeStore) ListReturns(result1 []string, result2 error) { 248 fake.listMutex.Lock() 249 defer fake.listMutex.Unlock() 250 fake.ListStub = nil 251 fake.listReturns = struct { 252 result1 []string 253 result2 error 254 }{result1, result2} 255 } 256 257 func (fake *FakeStore) ListReturnsOnCall(i int, result1 []string, result2 error) { 258 fake.listMutex.Lock() 259 defer fake.listMutex.Unlock() 260 fake.ListStub = nil 261 if fake.listReturnsOnCall == nil { 262 fake.listReturnsOnCall = make(map[int]struct { 263 result1 []string 264 result2 error 265 }) 266 } 267 fake.listReturnsOnCall[i] = struct { 268 result1 []string 269 result2 error 270 }{result1, result2} 271 } 272 273 func (fake *FakeStore) Store(arg1 string, arg2 any) error { 274 fake.storeMutex.Lock() 275 ret, specificReturn := fake.storeReturnsOnCall[len(fake.storeArgsForCall)] 276 fake.storeArgsForCall = append(fake.storeArgsForCall, struct { 277 arg1 string 278 arg2 any 279 }{arg1, arg2}) 280 stub := fake.StoreStub 281 fakeReturns := fake.storeReturns 282 fake.recordInvocation("Store", []interface{}{arg1, arg2}) 283 fake.storeMutex.Unlock() 284 if stub != nil { 285 return stub(arg1, arg2) 286 } 287 if specificReturn { 288 return ret.result1 289 } 290 return fakeReturns.result1 291 } 292 293 func (fake *FakeStore) StoreCallCount() int { 294 fake.storeMutex.RLock() 295 defer fake.storeMutex.RUnlock() 296 return len(fake.storeArgsForCall) 297 } 298 299 func (fake *FakeStore) StoreCalls(stub func(string, any) error) { 300 fake.storeMutex.Lock() 301 defer fake.storeMutex.Unlock() 302 fake.StoreStub = stub 303 } 304 305 func (fake *FakeStore) StoreArgsForCall(i int) (string, any) { 306 fake.storeMutex.RLock() 307 defer fake.storeMutex.RUnlock() 308 argsForCall := fake.storeArgsForCall[i] 309 return argsForCall.arg1, argsForCall.arg2 310 } 311 312 func (fake *FakeStore) StoreReturns(result1 error) { 313 fake.storeMutex.Lock() 314 defer fake.storeMutex.Unlock() 315 fake.StoreStub = nil 316 fake.storeReturns = struct { 317 result1 error 318 }{result1} 319 } 320 321 func (fake *FakeStore) StoreReturnsOnCall(i int, result1 error) { 322 fake.storeMutex.Lock() 323 defer fake.storeMutex.Unlock() 324 fake.StoreStub = nil 325 if fake.storeReturnsOnCall == nil { 326 fake.storeReturnsOnCall = make(map[int]struct { 327 result1 error 328 }) 329 } 330 fake.storeReturnsOnCall[i] = struct { 331 result1 error 332 }{result1} 333 } 334 335 func (fake *FakeStore) StoreString(arg1 string, arg2 string) error { 336 fake.storeStringMutex.Lock() 337 ret, specificReturn := fake.storeStringReturnsOnCall[len(fake.storeStringArgsForCall)] 338 fake.storeStringArgsForCall = append(fake.storeStringArgsForCall, struct { 339 arg1 string 340 arg2 string 341 }{arg1, arg2}) 342 stub := fake.StoreStringStub 343 fakeReturns := fake.storeStringReturns 344 fake.recordInvocation("StoreString", []interface{}{arg1, arg2}) 345 fake.storeStringMutex.Unlock() 346 if stub != nil { 347 return stub(arg1, arg2) 348 } 349 if specificReturn { 350 return ret.result1 351 } 352 return fakeReturns.result1 353 } 354 355 func (fake *FakeStore) StoreStringCallCount() int { 356 fake.storeStringMutex.RLock() 357 defer fake.storeStringMutex.RUnlock() 358 return len(fake.storeStringArgsForCall) 359 } 360 361 func (fake *FakeStore) StoreStringCalls(stub func(string, string) error) { 362 fake.storeStringMutex.Lock() 363 defer fake.storeStringMutex.Unlock() 364 fake.StoreStringStub = stub 365 } 366 367 func (fake *FakeStore) StoreStringArgsForCall(i int) (string, string) { 368 fake.storeStringMutex.RLock() 369 defer fake.storeStringMutex.RUnlock() 370 argsForCall := fake.storeStringArgsForCall[i] 371 return argsForCall.arg1, argsForCall.arg2 372 } 373 374 func (fake *FakeStore) StoreStringReturns(result1 error) { 375 fake.storeStringMutex.Lock() 376 defer fake.storeStringMutex.Unlock() 377 fake.StoreStringStub = nil 378 fake.storeStringReturns = struct { 379 result1 error 380 }{result1} 381 } 382 383 func (fake *FakeStore) StoreStringReturnsOnCall(i int, result1 error) { 384 fake.storeStringMutex.Lock() 385 defer fake.storeStringMutex.Unlock() 386 fake.StoreStringStub = nil 387 if fake.storeStringReturnsOnCall == nil { 388 fake.storeStringReturnsOnCall = make(map[int]struct { 389 result1 error 390 }) 391 } 392 fake.storeStringReturnsOnCall[i] = struct { 393 result1 error 394 }{result1} 395 } 396 397 func (fake *FakeStore) Wipe(arg1 string) error { 398 fake.wipeMutex.Lock() 399 ret, specificReturn := fake.wipeReturnsOnCall[len(fake.wipeArgsForCall)] 400 fake.wipeArgsForCall = append(fake.wipeArgsForCall, struct { 401 arg1 string 402 }{arg1}) 403 stub := fake.WipeStub 404 fakeReturns := fake.wipeReturns 405 fake.recordInvocation("Wipe", []interface{}{arg1}) 406 fake.wipeMutex.Unlock() 407 if stub != nil { 408 return stub(arg1) 409 } 410 if specificReturn { 411 return ret.result1 412 } 413 return fakeReturns.result1 414 } 415 416 func (fake *FakeStore) WipeCallCount() int { 417 fake.wipeMutex.RLock() 418 defer fake.wipeMutex.RUnlock() 419 return len(fake.wipeArgsForCall) 420 } 421 422 func (fake *FakeStore) WipeCalls(stub func(string) error) { 423 fake.wipeMutex.Lock() 424 defer fake.wipeMutex.Unlock() 425 fake.WipeStub = stub 426 } 427 428 func (fake *FakeStore) WipeArgsForCall(i int) string { 429 fake.wipeMutex.RLock() 430 defer fake.wipeMutex.RUnlock() 431 argsForCall := fake.wipeArgsForCall[i] 432 return argsForCall.arg1 433 } 434 435 func (fake *FakeStore) WipeReturns(result1 error) { 436 fake.wipeMutex.Lock() 437 defer fake.wipeMutex.Unlock() 438 fake.WipeStub = nil 439 fake.wipeReturns = struct { 440 result1 error 441 }{result1} 442 } 443 444 func (fake *FakeStore) WipeReturnsOnCall(i int, result1 error) { 445 fake.wipeMutex.Lock() 446 defer fake.wipeMutex.Unlock() 447 fake.WipeStub = nil 448 if fake.wipeReturnsOnCall == nil { 449 fake.wipeReturnsOnCall = make(map[int]struct { 450 result1 error 451 }) 452 } 453 fake.wipeReturnsOnCall[i] = struct { 454 result1 error 455 }{result1} 456 } 457 458 func (fake *FakeStore) Invocations() map[string][][]interface{} { 459 fake.invocationsMutex.RLock() 460 defer fake.invocationsMutex.RUnlock() 461 fake.deleteMutex.RLock() 462 defer fake.deleteMutex.RUnlock() 463 fake.getMutex.RLock() 464 defer fake.getMutex.RUnlock() 465 fake.listMutex.RLock() 466 defer fake.listMutex.RUnlock() 467 fake.storeMutex.RLock() 468 defer fake.storeMutex.RUnlock() 469 fake.storeStringMutex.RLock() 470 defer fake.storeStringMutex.RUnlock() 471 fake.wipeMutex.RLock() 472 defer fake.wipeMutex.RUnlock() 473 copiedInvocations := map[string][][]interface{}{} 474 for key, value := range fake.invocations { 475 copiedInvocations[key] = value 476 } 477 return copiedInvocations 478 } 479 480 func (fake *FakeStore) recordInvocation(key string, args []interface{}) { 481 fake.invocationsMutex.Lock() 482 defer fake.invocationsMutex.Unlock() 483 if fake.invocations == nil { 484 fake.invocations = map[string][][]interface{}{} 485 } 486 if fake.invocations[key] == nil { 487 fake.invocations[key] = [][]interface{}{} 488 } 489 fake.invocations[key] = append(fake.invocations[key], args) 490 } 491 492 var _ store.Store = new(FakeStore)