gitee.com/zhaochuninhefei/fabric-ca-gm@v0.0.2/lib/server/db/mocks/sqlxTx.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package mocks 3 4 import ( 5 sql "database/sql" 6 sync "sync" 7 8 db "gitee.com/zhaochuninhefei/fabric-ca-gm/lib/server/db" 9 sqlx "github.com/jmoiron/sqlx" 10 ) 11 12 type SqlxTx struct { 13 CommitStub func() error 14 commitMutex sync.RWMutex 15 commitArgsForCall []struct { 16 } 17 commitReturns struct { 18 result1 error 19 } 20 commitReturnsOnCall map[int]struct { 21 result1 error 22 } 23 ExecStub func(string, ...interface{}) (sql.Result, error) 24 execMutex sync.RWMutex 25 execArgsForCall []struct { 26 arg1 string 27 arg2 []interface{} 28 } 29 execReturns struct { 30 result1 sql.Result 31 result2 error 32 } 33 execReturnsOnCall map[int]struct { 34 result1 sql.Result 35 result2 error 36 } 37 GetStub func(interface{}, string, ...interface{}) error 38 getMutex sync.RWMutex 39 getArgsForCall []struct { 40 arg1 interface{} 41 arg2 string 42 arg3 []interface{} 43 } 44 getReturns struct { 45 result1 error 46 } 47 getReturnsOnCall map[int]struct { 48 result1 error 49 } 50 QueryxStub func(string, ...interface{}) (*sqlx.Rows, error) 51 queryxMutex sync.RWMutex 52 queryxArgsForCall []struct { 53 arg1 string 54 arg2 []interface{} 55 } 56 queryxReturns struct { 57 result1 *sqlx.Rows 58 result2 error 59 } 60 queryxReturnsOnCall map[int]struct { 61 result1 *sqlx.Rows 62 result2 error 63 } 64 RebindStub func(string) string 65 rebindMutex sync.RWMutex 66 rebindArgsForCall []struct { 67 arg1 string 68 } 69 rebindReturns struct { 70 result1 string 71 } 72 rebindReturnsOnCall map[int]struct { 73 result1 string 74 } 75 RollbackStub func() error 76 rollbackMutex sync.RWMutex 77 rollbackArgsForCall []struct { 78 } 79 rollbackReturns struct { 80 result1 error 81 } 82 rollbackReturnsOnCall map[int]struct { 83 result1 error 84 } 85 SelectStub func(interface{}, string, ...interface{}) error 86 selectMutex sync.RWMutex 87 selectArgsForCall []struct { 88 arg1 interface{} 89 arg2 string 90 arg3 []interface{} 91 } 92 selectReturns struct { 93 result1 error 94 } 95 selectReturnsOnCall map[int]struct { 96 result1 error 97 } 98 invocations map[string][][]interface{} 99 invocationsMutex sync.RWMutex 100 } 101 102 func (fake *SqlxTx) Commit() error { 103 fake.commitMutex.Lock() 104 ret, specificReturn := fake.commitReturnsOnCall[len(fake.commitArgsForCall)] 105 fake.commitArgsForCall = append(fake.commitArgsForCall, struct { 106 }{}) 107 fake.recordInvocation("Commit", []interface{}{}) 108 fake.commitMutex.Unlock() 109 if fake.CommitStub != nil { 110 return fake.CommitStub() 111 } 112 if specificReturn { 113 return ret.result1 114 } 115 fakeReturns := fake.commitReturns 116 return fakeReturns.result1 117 } 118 119 func (fake *SqlxTx) CommitCallCount() int { 120 fake.commitMutex.RLock() 121 defer fake.commitMutex.RUnlock() 122 return len(fake.commitArgsForCall) 123 } 124 125 func (fake *SqlxTx) CommitCalls(stub func() error) { 126 fake.commitMutex.Lock() 127 defer fake.commitMutex.Unlock() 128 fake.CommitStub = stub 129 } 130 131 func (fake *SqlxTx) CommitReturns(result1 error) { 132 fake.commitMutex.Lock() 133 defer fake.commitMutex.Unlock() 134 fake.CommitStub = nil 135 fake.commitReturns = struct { 136 result1 error 137 }{result1} 138 } 139 140 func (fake *SqlxTx) CommitReturnsOnCall(i int, result1 error) { 141 fake.commitMutex.Lock() 142 defer fake.commitMutex.Unlock() 143 fake.CommitStub = nil 144 if fake.commitReturnsOnCall == nil { 145 fake.commitReturnsOnCall = make(map[int]struct { 146 result1 error 147 }) 148 } 149 fake.commitReturnsOnCall[i] = struct { 150 result1 error 151 }{result1} 152 } 153 154 func (fake *SqlxTx) Exec(arg1 string, arg2 ...interface{}) (sql.Result, error) { 155 fake.execMutex.Lock() 156 ret, specificReturn := fake.execReturnsOnCall[len(fake.execArgsForCall)] 157 fake.execArgsForCall = append(fake.execArgsForCall, struct { 158 arg1 string 159 arg2 []interface{} 160 }{arg1, arg2}) 161 fake.recordInvocation("Exec", []interface{}{arg1, arg2}) 162 fake.execMutex.Unlock() 163 if fake.ExecStub != nil { 164 return fake.ExecStub(arg1, arg2...) 165 } 166 if specificReturn { 167 return ret.result1, ret.result2 168 } 169 fakeReturns := fake.execReturns 170 return fakeReturns.result1, fakeReturns.result2 171 } 172 173 func (fake *SqlxTx) ExecCallCount() int { 174 fake.execMutex.RLock() 175 defer fake.execMutex.RUnlock() 176 return len(fake.execArgsForCall) 177 } 178 179 func (fake *SqlxTx) ExecCalls(stub func(string, ...interface{}) (sql.Result, error)) { 180 fake.execMutex.Lock() 181 defer fake.execMutex.Unlock() 182 fake.ExecStub = stub 183 } 184 185 func (fake *SqlxTx) ExecArgsForCall(i int) (string, []interface{}) { 186 fake.execMutex.RLock() 187 defer fake.execMutex.RUnlock() 188 argsForCall := fake.execArgsForCall[i] 189 return argsForCall.arg1, argsForCall.arg2 190 } 191 192 func (fake *SqlxTx) ExecReturns(result1 sql.Result, result2 error) { 193 fake.execMutex.Lock() 194 defer fake.execMutex.Unlock() 195 fake.ExecStub = nil 196 fake.execReturns = struct { 197 result1 sql.Result 198 result2 error 199 }{result1, result2} 200 } 201 202 func (fake *SqlxTx) ExecReturnsOnCall(i int, result1 sql.Result, result2 error) { 203 fake.execMutex.Lock() 204 defer fake.execMutex.Unlock() 205 fake.ExecStub = nil 206 if fake.execReturnsOnCall == nil { 207 fake.execReturnsOnCall = make(map[int]struct { 208 result1 sql.Result 209 result2 error 210 }) 211 } 212 fake.execReturnsOnCall[i] = struct { 213 result1 sql.Result 214 result2 error 215 }{result1, result2} 216 } 217 218 func (fake *SqlxTx) Get(arg1 interface{}, arg2 string, arg3 ...interface{}) error { 219 fake.getMutex.Lock() 220 ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] 221 fake.getArgsForCall = append(fake.getArgsForCall, struct { 222 arg1 interface{} 223 arg2 string 224 arg3 []interface{} 225 }{arg1, arg2, arg3}) 226 fake.recordInvocation("Get", []interface{}{arg1, arg2, arg3}) 227 fake.getMutex.Unlock() 228 if fake.GetStub != nil { 229 return fake.GetStub(arg1, arg2, arg3...) 230 } 231 if specificReturn { 232 return ret.result1 233 } 234 fakeReturns := fake.getReturns 235 return fakeReturns.result1 236 } 237 238 func (fake *SqlxTx) GetCallCount() int { 239 fake.getMutex.RLock() 240 defer fake.getMutex.RUnlock() 241 return len(fake.getArgsForCall) 242 } 243 244 func (fake *SqlxTx) GetCalls(stub func(interface{}, string, ...interface{}) error) { 245 fake.getMutex.Lock() 246 defer fake.getMutex.Unlock() 247 fake.GetStub = stub 248 } 249 250 func (fake *SqlxTx) GetArgsForCall(i int) (interface{}, string, []interface{}) { 251 fake.getMutex.RLock() 252 defer fake.getMutex.RUnlock() 253 argsForCall := fake.getArgsForCall[i] 254 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 255 } 256 257 func (fake *SqlxTx) GetReturns(result1 error) { 258 fake.getMutex.Lock() 259 defer fake.getMutex.Unlock() 260 fake.GetStub = nil 261 fake.getReturns = struct { 262 result1 error 263 }{result1} 264 } 265 266 func (fake *SqlxTx) GetReturnsOnCall(i int, result1 error) { 267 fake.getMutex.Lock() 268 defer fake.getMutex.Unlock() 269 fake.GetStub = nil 270 if fake.getReturnsOnCall == nil { 271 fake.getReturnsOnCall = make(map[int]struct { 272 result1 error 273 }) 274 } 275 fake.getReturnsOnCall[i] = struct { 276 result1 error 277 }{result1} 278 } 279 280 func (fake *SqlxTx) Queryx(arg1 string, arg2 ...interface{}) (*sqlx.Rows, error) { 281 fake.queryxMutex.Lock() 282 ret, specificReturn := fake.queryxReturnsOnCall[len(fake.queryxArgsForCall)] 283 fake.queryxArgsForCall = append(fake.queryxArgsForCall, struct { 284 arg1 string 285 arg2 []interface{} 286 }{arg1, arg2}) 287 fake.recordInvocation("Queryx", []interface{}{arg1, arg2}) 288 fake.queryxMutex.Unlock() 289 if fake.QueryxStub != nil { 290 return fake.QueryxStub(arg1, arg2...) 291 } 292 if specificReturn { 293 return ret.result1, ret.result2 294 } 295 fakeReturns := fake.queryxReturns 296 return fakeReturns.result1, fakeReturns.result2 297 } 298 299 func (fake *SqlxTx) QueryxCallCount() int { 300 fake.queryxMutex.RLock() 301 defer fake.queryxMutex.RUnlock() 302 return len(fake.queryxArgsForCall) 303 } 304 305 func (fake *SqlxTx) QueryxCalls(stub func(string, ...interface{}) (*sqlx.Rows, error)) { 306 fake.queryxMutex.Lock() 307 defer fake.queryxMutex.Unlock() 308 fake.QueryxStub = stub 309 } 310 311 func (fake *SqlxTx) QueryxArgsForCall(i int) (string, []interface{}) { 312 fake.queryxMutex.RLock() 313 defer fake.queryxMutex.RUnlock() 314 argsForCall := fake.queryxArgsForCall[i] 315 return argsForCall.arg1, argsForCall.arg2 316 } 317 318 func (fake *SqlxTx) QueryxReturns(result1 *sqlx.Rows, result2 error) { 319 fake.queryxMutex.Lock() 320 defer fake.queryxMutex.Unlock() 321 fake.QueryxStub = nil 322 fake.queryxReturns = struct { 323 result1 *sqlx.Rows 324 result2 error 325 }{result1, result2} 326 } 327 328 func (fake *SqlxTx) QueryxReturnsOnCall(i int, result1 *sqlx.Rows, result2 error) { 329 fake.queryxMutex.Lock() 330 defer fake.queryxMutex.Unlock() 331 fake.QueryxStub = nil 332 if fake.queryxReturnsOnCall == nil { 333 fake.queryxReturnsOnCall = make(map[int]struct { 334 result1 *sqlx.Rows 335 result2 error 336 }) 337 } 338 fake.queryxReturnsOnCall[i] = struct { 339 result1 *sqlx.Rows 340 result2 error 341 }{result1, result2} 342 } 343 344 func (fake *SqlxTx) Rebind(arg1 string) string { 345 fake.rebindMutex.Lock() 346 ret, specificReturn := fake.rebindReturnsOnCall[len(fake.rebindArgsForCall)] 347 fake.rebindArgsForCall = append(fake.rebindArgsForCall, struct { 348 arg1 string 349 }{arg1}) 350 fake.recordInvocation("Rebind", []interface{}{arg1}) 351 fake.rebindMutex.Unlock() 352 if fake.RebindStub != nil { 353 return fake.RebindStub(arg1) 354 } 355 if specificReturn { 356 return ret.result1 357 } 358 fakeReturns := fake.rebindReturns 359 return fakeReturns.result1 360 } 361 362 func (fake *SqlxTx) RebindCallCount() int { 363 fake.rebindMutex.RLock() 364 defer fake.rebindMutex.RUnlock() 365 return len(fake.rebindArgsForCall) 366 } 367 368 func (fake *SqlxTx) RebindCalls(stub func(string) string) { 369 fake.rebindMutex.Lock() 370 defer fake.rebindMutex.Unlock() 371 fake.RebindStub = stub 372 } 373 374 func (fake *SqlxTx) RebindArgsForCall(i int) string { 375 fake.rebindMutex.RLock() 376 defer fake.rebindMutex.RUnlock() 377 argsForCall := fake.rebindArgsForCall[i] 378 return argsForCall.arg1 379 } 380 381 func (fake *SqlxTx) RebindReturns(result1 string) { 382 fake.rebindMutex.Lock() 383 defer fake.rebindMutex.Unlock() 384 fake.RebindStub = nil 385 fake.rebindReturns = struct { 386 result1 string 387 }{result1} 388 } 389 390 func (fake *SqlxTx) RebindReturnsOnCall(i int, result1 string) { 391 fake.rebindMutex.Lock() 392 defer fake.rebindMutex.Unlock() 393 fake.RebindStub = nil 394 if fake.rebindReturnsOnCall == nil { 395 fake.rebindReturnsOnCall = make(map[int]struct { 396 result1 string 397 }) 398 } 399 fake.rebindReturnsOnCall[i] = struct { 400 result1 string 401 }{result1} 402 } 403 404 func (fake *SqlxTx) Rollback() error { 405 fake.rollbackMutex.Lock() 406 ret, specificReturn := fake.rollbackReturnsOnCall[len(fake.rollbackArgsForCall)] 407 fake.rollbackArgsForCall = append(fake.rollbackArgsForCall, struct { 408 }{}) 409 fake.recordInvocation("Rollback", []interface{}{}) 410 fake.rollbackMutex.Unlock() 411 if fake.RollbackStub != nil { 412 return fake.RollbackStub() 413 } 414 if specificReturn { 415 return ret.result1 416 } 417 fakeReturns := fake.rollbackReturns 418 return fakeReturns.result1 419 } 420 421 func (fake *SqlxTx) RollbackCallCount() int { 422 fake.rollbackMutex.RLock() 423 defer fake.rollbackMutex.RUnlock() 424 return len(fake.rollbackArgsForCall) 425 } 426 427 func (fake *SqlxTx) RollbackCalls(stub func() error) { 428 fake.rollbackMutex.Lock() 429 defer fake.rollbackMutex.Unlock() 430 fake.RollbackStub = stub 431 } 432 433 func (fake *SqlxTx) RollbackReturns(result1 error) { 434 fake.rollbackMutex.Lock() 435 defer fake.rollbackMutex.Unlock() 436 fake.RollbackStub = nil 437 fake.rollbackReturns = struct { 438 result1 error 439 }{result1} 440 } 441 442 func (fake *SqlxTx) RollbackReturnsOnCall(i int, result1 error) { 443 fake.rollbackMutex.Lock() 444 defer fake.rollbackMutex.Unlock() 445 fake.RollbackStub = nil 446 if fake.rollbackReturnsOnCall == nil { 447 fake.rollbackReturnsOnCall = make(map[int]struct { 448 result1 error 449 }) 450 } 451 fake.rollbackReturnsOnCall[i] = struct { 452 result1 error 453 }{result1} 454 } 455 456 func (fake *SqlxTx) Select(arg1 interface{}, arg2 string, arg3 ...interface{}) error { 457 fake.selectMutex.Lock() 458 ret, specificReturn := fake.selectReturnsOnCall[len(fake.selectArgsForCall)] 459 fake.selectArgsForCall = append(fake.selectArgsForCall, struct { 460 arg1 interface{} 461 arg2 string 462 arg3 []interface{} 463 }{arg1, arg2, arg3}) 464 fake.recordInvocation("Select", []interface{}{arg1, arg2, arg3}) 465 fake.selectMutex.Unlock() 466 if fake.SelectStub != nil { 467 return fake.SelectStub(arg1, arg2, arg3...) 468 } 469 if specificReturn { 470 return ret.result1 471 } 472 fakeReturns := fake.selectReturns 473 return fakeReturns.result1 474 } 475 476 func (fake *SqlxTx) SelectCallCount() int { 477 fake.selectMutex.RLock() 478 defer fake.selectMutex.RUnlock() 479 return len(fake.selectArgsForCall) 480 } 481 482 func (fake *SqlxTx) SelectCalls(stub func(interface{}, string, ...interface{}) error) { 483 fake.selectMutex.Lock() 484 defer fake.selectMutex.Unlock() 485 fake.SelectStub = stub 486 } 487 488 func (fake *SqlxTx) SelectArgsForCall(i int) (interface{}, string, []interface{}) { 489 fake.selectMutex.RLock() 490 defer fake.selectMutex.RUnlock() 491 argsForCall := fake.selectArgsForCall[i] 492 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 493 } 494 495 func (fake *SqlxTx) SelectReturns(result1 error) { 496 fake.selectMutex.Lock() 497 defer fake.selectMutex.Unlock() 498 fake.SelectStub = nil 499 fake.selectReturns = struct { 500 result1 error 501 }{result1} 502 } 503 504 func (fake *SqlxTx) SelectReturnsOnCall(i int, result1 error) { 505 fake.selectMutex.Lock() 506 defer fake.selectMutex.Unlock() 507 fake.SelectStub = nil 508 if fake.selectReturnsOnCall == nil { 509 fake.selectReturnsOnCall = make(map[int]struct { 510 result1 error 511 }) 512 } 513 fake.selectReturnsOnCall[i] = struct { 514 result1 error 515 }{result1} 516 } 517 518 func (fake *SqlxTx) Invocations() map[string][][]interface{} { 519 fake.invocationsMutex.RLock() 520 defer fake.invocationsMutex.RUnlock() 521 fake.commitMutex.RLock() 522 defer fake.commitMutex.RUnlock() 523 fake.execMutex.RLock() 524 defer fake.execMutex.RUnlock() 525 fake.getMutex.RLock() 526 defer fake.getMutex.RUnlock() 527 fake.queryxMutex.RLock() 528 defer fake.queryxMutex.RUnlock() 529 fake.rebindMutex.RLock() 530 defer fake.rebindMutex.RUnlock() 531 fake.rollbackMutex.RLock() 532 defer fake.rollbackMutex.RUnlock() 533 fake.selectMutex.RLock() 534 defer fake.selectMutex.RUnlock() 535 copiedInvocations := map[string][][]interface{}{} 536 for key, value := range fake.invocations { 537 copiedInvocations[key] = value 538 } 539 return copiedInvocations 540 } 541 542 func (fake *SqlxTx) recordInvocation(key string, args []interface{}) { 543 fake.invocationsMutex.Lock() 544 defer fake.invocationsMutex.Unlock() 545 if fake.invocations == nil { 546 fake.invocations = map[string][][]interface{}{} 547 } 548 if fake.invocations[key] == nil { 549 fake.invocations[key] = [][]interface{}{} 550 } 551 fake.invocations[key] = append(fake.invocations[key], args) 552 } 553 554 var _ db.SqlxTx = new(SqlxTx)