gitee.com/zhaochuninhefei/fabric-ca-gm@v0.0.2/lib/server/user/mocks/userDB.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 sqlx "github.com/jmoiron/sqlx" 9 ) 10 11 type UserDB struct { 12 ExecStub func(string, string, ...interface{}) (sql.Result, error) 13 execMutex sync.RWMutex 14 execArgsForCall []struct { 15 arg1 string 16 arg2 string 17 arg3 []interface{} 18 } 19 execReturns struct { 20 result1 sql.Result 21 result2 error 22 } 23 execReturnsOnCall map[int]struct { 24 result1 sql.Result 25 result2 error 26 } 27 GetStub func(string, interface{}, string, ...interface{}) error 28 getMutex sync.RWMutex 29 getArgsForCall []struct { 30 arg1 string 31 arg2 interface{} 32 arg3 string 33 arg4 []interface{} 34 } 35 getReturns struct { 36 result1 error 37 } 38 getReturnsOnCall map[int]struct { 39 result1 error 40 } 41 QueryxStub func(string, string, ...interface{}) (*sqlx.Rows, error) 42 queryxMutex sync.RWMutex 43 queryxArgsForCall []struct { 44 arg1 string 45 arg2 string 46 arg3 []interface{} 47 } 48 queryxReturns struct { 49 result1 *sqlx.Rows 50 result2 error 51 } 52 queryxReturnsOnCall map[int]struct { 53 result1 *sqlx.Rows 54 result2 error 55 } 56 RebindStub func(string) string 57 rebindMutex sync.RWMutex 58 rebindArgsForCall []struct { 59 arg1 string 60 } 61 rebindReturns struct { 62 result1 string 63 } 64 rebindReturnsOnCall map[int]struct { 65 result1 string 66 } 67 invocations map[string][][]interface{} 68 invocationsMutex sync.RWMutex 69 } 70 71 func (fake *UserDB) Exec(arg1 string, arg2 string, arg3 ...interface{}) (sql.Result, error) { 72 fake.execMutex.Lock() 73 ret, specificReturn := fake.execReturnsOnCall[len(fake.execArgsForCall)] 74 fake.execArgsForCall = append(fake.execArgsForCall, struct { 75 arg1 string 76 arg2 string 77 arg3 []interface{} 78 }{arg1, arg2, arg3}) 79 fake.recordInvocation("Exec", []interface{}{arg1, arg2, arg3}) 80 fake.execMutex.Unlock() 81 if fake.ExecStub != nil { 82 return fake.ExecStub(arg1, arg2, arg3...) 83 } 84 if specificReturn { 85 return ret.result1, ret.result2 86 } 87 fakeReturns := fake.execReturns 88 return fakeReturns.result1, fakeReturns.result2 89 } 90 91 func (fake *UserDB) ExecCallCount() int { 92 fake.execMutex.RLock() 93 defer fake.execMutex.RUnlock() 94 return len(fake.execArgsForCall) 95 } 96 97 func (fake *UserDB) ExecCalls(stub func(string, string, ...interface{}) (sql.Result, error)) { 98 fake.execMutex.Lock() 99 defer fake.execMutex.Unlock() 100 fake.ExecStub = stub 101 } 102 103 func (fake *UserDB) ExecArgsForCall(i int) (string, string, []interface{}) { 104 fake.execMutex.RLock() 105 defer fake.execMutex.RUnlock() 106 argsForCall := fake.execArgsForCall[i] 107 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 108 } 109 110 func (fake *UserDB) ExecReturns(result1 sql.Result, result2 error) { 111 fake.execMutex.Lock() 112 defer fake.execMutex.Unlock() 113 fake.ExecStub = nil 114 fake.execReturns = struct { 115 result1 sql.Result 116 result2 error 117 }{result1, result2} 118 } 119 120 func (fake *UserDB) ExecReturnsOnCall(i int, result1 sql.Result, result2 error) { 121 fake.execMutex.Lock() 122 defer fake.execMutex.Unlock() 123 fake.ExecStub = nil 124 if fake.execReturnsOnCall == nil { 125 fake.execReturnsOnCall = make(map[int]struct { 126 result1 sql.Result 127 result2 error 128 }) 129 } 130 fake.execReturnsOnCall[i] = struct { 131 result1 sql.Result 132 result2 error 133 }{result1, result2} 134 } 135 136 func (fake *UserDB) Get(arg1 string, arg2 interface{}, arg3 string, arg4 ...interface{}) error { 137 fake.getMutex.Lock() 138 ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] 139 fake.getArgsForCall = append(fake.getArgsForCall, struct { 140 arg1 string 141 arg2 interface{} 142 arg3 string 143 arg4 []interface{} 144 }{arg1, arg2, arg3, arg4}) 145 fake.recordInvocation("Get", []interface{}{arg1, arg2, arg3, arg4}) 146 fake.getMutex.Unlock() 147 if fake.GetStub != nil { 148 return fake.GetStub(arg1, arg2, arg3, arg4...) 149 } 150 if specificReturn { 151 return ret.result1 152 } 153 fakeReturns := fake.getReturns 154 return fakeReturns.result1 155 } 156 157 func (fake *UserDB) GetCallCount() int { 158 fake.getMutex.RLock() 159 defer fake.getMutex.RUnlock() 160 return len(fake.getArgsForCall) 161 } 162 163 func (fake *UserDB) GetCalls(stub func(string, interface{}, string, ...interface{}) error) { 164 fake.getMutex.Lock() 165 defer fake.getMutex.Unlock() 166 fake.GetStub = stub 167 } 168 169 func (fake *UserDB) GetArgsForCall(i int) (string, interface{}, string, []interface{}) { 170 fake.getMutex.RLock() 171 defer fake.getMutex.RUnlock() 172 argsForCall := fake.getArgsForCall[i] 173 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 174 } 175 176 func (fake *UserDB) GetReturns(result1 error) { 177 fake.getMutex.Lock() 178 defer fake.getMutex.Unlock() 179 fake.GetStub = nil 180 fake.getReturns = struct { 181 result1 error 182 }{result1} 183 } 184 185 func (fake *UserDB) GetReturnsOnCall(i int, result1 error) { 186 fake.getMutex.Lock() 187 defer fake.getMutex.Unlock() 188 fake.GetStub = nil 189 if fake.getReturnsOnCall == nil { 190 fake.getReturnsOnCall = make(map[int]struct { 191 result1 error 192 }) 193 } 194 fake.getReturnsOnCall[i] = struct { 195 result1 error 196 }{result1} 197 } 198 199 func (fake *UserDB) Queryx(arg1 string, arg2 string, arg3 ...interface{}) (*sqlx.Rows, error) { 200 fake.queryxMutex.Lock() 201 ret, specificReturn := fake.queryxReturnsOnCall[len(fake.queryxArgsForCall)] 202 fake.queryxArgsForCall = append(fake.queryxArgsForCall, struct { 203 arg1 string 204 arg2 string 205 arg3 []interface{} 206 }{arg1, arg2, arg3}) 207 fake.recordInvocation("Queryx", []interface{}{arg1, arg2, arg3}) 208 fake.queryxMutex.Unlock() 209 if fake.QueryxStub != nil { 210 return fake.QueryxStub(arg1, arg2, arg3...) 211 } 212 if specificReturn { 213 return ret.result1, ret.result2 214 } 215 fakeReturns := fake.queryxReturns 216 return fakeReturns.result1, fakeReturns.result2 217 } 218 219 func (fake *UserDB) QueryxCallCount() int { 220 fake.queryxMutex.RLock() 221 defer fake.queryxMutex.RUnlock() 222 return len(fake.queryxArgsForCall) 223 } 224 225 func (fake *UserDB) QueryxCalls(stub func(string, string, ...interface{}) (*sqlx.Rows, error)) { 226 fake.queryxMutex.Lock() 227 defer fake.queryxMutex.Unlock() 228 fake.QueryxStub = stub 229 } 230 231 func (fake *UserDB) QueryxArgsForCall(i int) (string, string, []interface{}) { 232 fake.queryxMutex.RLock() 233 defer fake.queryxMutex.RUnlock() 234 argsForCall := fake.queryxArgsForCall[i] 235 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 236 } 237 238 func (fake *UserDB) QueryxReturns(result1 *sqlx.Rows, result2 error) { 239 fake.queryxMutex.Lock() 240 defer fake.queryxMutex.Unlock() 241 fake.QueryxStub = nil 242 fake.queryxReturns = struct { 243 result1 *sqlx.Rows 244 result2 error 245 }{result1, result2} 246 } 247 248 func (fake *UserDB) QueryxReturnsOnCall(i int, result1 *sqlx.Rows, result2 error) { 249 fake.queryxMutex.Lock() 250 defer fake.queryxMutex.Unlock() 251 fake.QueryxStub = nil 252 if fake.queryxReturnsOnCall == nil { 253 fake.queryxReturnsOnCall = make(map[int]struct { 254 result1 *sqlx.Rows 255 result2 error 256 }) 257 } 258 fake.queryxReturnsOnCall[i] = struct { 259 result1 *sqlx.Rows 260 result2 error 261 }{result1, result2} 262 } 263 264 func (fake *UserDB) Rebind(arg1 string) string { 265 fake.rebindMutex.Lock() 266 ret, specificReturn := fake.rebindReturnsOnCall[len(fake.rebindArgsForCall)] 267 fake.rebindArgsForCall = append(fake.rebindArgsForCall, struct { 268 arg1 string 269 }{arg1}) 270 fake.recordInvocation("Rebind", []interface{}{arg1}) 271 fake.rebindMutex.Unlock() 272 if fake.RebindStub != nil { 273 return fake.RebindStub(arg1) 274 } 275 if specificReturn { 276 return ret.result1 277 } 278 fakeReturns := fake.rebindReturns 279 return fakeReturns.result1 280 } 281 282 func (fake *UserDB) RebindCallCount() int { 283 fake.rebindMutex.RLock() 284 defer fake.rebindMutex.RUnlock() 285 return len(fake.rebindArgsForCall) 286 } 287 288 func (fake *UserDB) RebindCalls(stub func(string) string) { 289 fake.rebindMutex.Lock() 290 defer fake.rebindMutex.Unlock() 291 fake.RebindStub = stub 292 } 293 294 func (fake *UserDB) RebindArgsForCall(i int) string { 295 fake.rebindMutex.RLock() 296 defer fake.rebindMutex.RUnlock() 297 argsForCall := fake.rebindArgsForCall[i] 298 return argsForCall.arg1 299 } 300 301 func (fake *UserDB) RebindReturns(result1 string) { 302 fake.rebindMutex.Lock() 303 defer fake.rebindMutex.Unlock() 304 fake.RebindStub = nil 305 fake.rebindReturns = struct { 306 result1 string 307 }{result1} 308 } 309 310 func (fake *UserDB) RebindReturnsOnCall(i int, result1 string) { 311 fake.rebindMutex.Lock() 312 defer fake.rebindMutex.Unlock() 313 fake.RebindStub = nil 314 if fake.rebindReturnsOnCall == nil { 315 fake.rebindReturnsOnCall = make(map[int]struct { 316 result1 string 317 }) 318 } 319 fake.rebindReturnsOnCall[i] = struct { 320 result1 string 321 }{result1} 322 } 323 324 func (fake *UserDB) Invocations() map[string][][]interface{} { 325 fake.invocationsMutex.RLock() 326 defer fake.invocationsMutex.RUnlock() 327 fake.execMutex.RLock() 328 defer fake.execMutex.RUnlock() 329 fake.getMutex.RLock() 330 defer fake.getMutex.RUnlock() 331 fake.queryxMutex.RLock() 332 defer fake.queryxMutex.RUnlock() 333 fake.rebindMutex.RLock() 334 defer fake.rebindMutex.RUnlock() 335 copiedInvocations := map[string][][]interface{}{} 336 for key, value := range fake.invocations { 337 copiedInvocations[key] = value 338 } 339 return copiedInvocations 340 } 341 342 func (fake *UserDB) recordInvocation(key string, args []interface{}) { 343 fake.invocationsMutex.Lock() 344 defer fake.invocationsMutex.Unlock() 345 if fake.invocations == nil { 346 fake.invocations = map[string][][]interface{}{} 347 } 348 if fake.invocations[key] == nil { 349 fake.invocations[key] = [][]interface{}{} 350 } 351 fake.invocations[key] = append(fake.invocations[key], args) 352 }