gitee.com/zhaochuninhefei/fabric-ca-gm@v0.0.2/lib/server/user/mocks/userTx.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 UserTx 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 QueryxStub func(string, string, ...interface{}) (*sqlx.Rows, error) 28 queryxMutex sync.RWMutex 29 queryxArgsForCall []struct { 30 arg1 string 31 arg2 string 32 arg3 []interface{} 33 } 34 queryxReturns struct { 35 result1 *sqlx.Rows 36 result2 error 37 } 38 queryxReturnsOnCall map[int]struct { 39 result1 *sqlx.Rows 40 result2 error 41 } 42 RebindStub func(string) string 43 rebindMutex sync.RWMutex 44 rebindArgsForCall []struct { 45 arg1 string 46 } 47 rebindReturns struct { 48 result1 string 49 } 50 rebindReturnsOnCall map[int]struct { 51 result1 string 52 } 53 invocations map[string][][]interface{} 54 invocationsMutex sync.RWMutex 55 } 56 57 func (fake *UserTx) Exec(arg1 string, arg2 string, arg3 ...interface{}) (sql.Result, error) { 58 fake.execMutex.Lock() 59 ret, specificReturn := fake.execReturnsOnCall[len(fake.execArgsForCall)] 60 fake.execArgsForCall = append(fake.execArgsForCall, struct { 61 arg1 string 62 arg2 string 63 arg3 []interface{} 64 }{arg1, arg2, arg3}) 65 fake.recordInvocation("Exec", []interface{}{arg1, arg2, arg3}) 66 fake.execMutex.Unlock() 67 if fake.ExecStub != nil { 68 return fake.ExecStub(arg1, arg2, arg3...) 69 } 70 if specificReturn { 71 return ret.result1, ret.result2 72 } 73 fakeReturns := fake.execReturns 74 return fakeReturns.result1, fakeReturns.result2 75 } 76 77 func (fake *UserTx) ExecCallCount() int { 78 fake.execMutex.RLock() 79 defer fake.execMutex.RUnlock() 80 return len(fake.execArgsForCall) 81 } 82 83 func (fake *UserTx) ExecCalls(stub func(string, string, ...interface{}) (sql.Result, error)) { 84 fake.execMutex.Lock() 85 defer fake.execMutex.Unlock() 86 fake.ExecStub = stub 87 } 88 89 func (fake *UserTx) ExecArgsForCall(i int) (string, string, []interface{}) { 90 fake.execMutex.RLock() 91 defer fake.execMutex.RUnlock() 92 argsForCall := fake.execArgsForCall[i] 93 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 94 } 95 96 func (fake *UserTx) ExecReturns(result1 sql.Result, result2 error) { 97 fake.execMutex.Lock() 98 defer fake.execMutex.Unlock() 99 fake.ExecStub = nil 100 fake.execReturns = struct { 101 result1 sql.Result 102 result2 error 103 }{result1, result2} 104 } 105 106 func (fake *UserTx) ExecReturnsOnCall(i int, result1 sql.Result, result2 error) { 107 fake.execMutex.Lock() 108 defer fake.execMutex.Unlock() 109 fake.ExecStub = nil 110 if fake.execReturnsOnCall == nil { 111 fake.execReturnsOnCall = make(map[int]struct { 112 result1 sql.Result 113 result2 error 114 }) 115 } 116 fake.execReturnsOnCall[i] = struct { 117 result1 sql.Result 118 result2 error 119 }{result1, result2} 120 } 121 122 func (fake *UserTx) Queryx(arg1 string, arg2 string, arg3 ...interface{}) (*sqlx.Rows, error) { 123 fake.queryxMutex.Lock() 124 ret, specificReturn := fake.queryxReturnsOnCall[len(fake.queryxArgsForCall)] 125 fake.queryxArgsForCall = append(fake.queryxArgsForCall, struct { 126 arg1 string 127 arg2 string 128 arg3 []interface{} 129 }{arg1, arg2, arg3}) 130 fake.recordInvocation("Queryx", []interface{}{arg1, arg2, arg3}) 131 fake.queryxMutex.Unlock() 132 if fake.QueryxStub != nil { 133 return fake.QueryxStub(arg1, arg2, arg3...) 134 } 135 if specificReturn { 136 return ret.result1, ret.result2 137 } 138 fakeReturns := fake.queryxReturns 139 return fakeReturns.result1, fakeReturns.result2 140 } 141 142 func (fake *UserTx) QueryxCallCount() int { 143 fake.queryxMutex.RLock() 144 defer fake.queryxMutex.RUnlock() 145 return len(fake.queryxArgsForCall) 146 } 147 148 func (fake *UserTx) QueryxCalls(stub func(string, string, ...interface{}) (*sqlx.Rows, error)) { 149 fake.queryxMutex.Lock() 150 defer fake.queryxMutex.Unlock() 151 fake.QueryxStub = stub 152 } 153 154 func (fake *UserTx) QueryxArgsForCall(i int) (string, string, []interface{}) { 155 fake.queryxMutex.RLock() 156 defer fake.queryxMutex.RUnlock() 157 argsForCall := fake.queryxArgsForCall[i] 158 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 159 } 160 161 func (fake *UserTx) QueryxReturns(result1 *sqlx.Rows, result2 error) { 162 fake.queryxMutex.Lock() 163 defer fake.queryxMutex.Unlock() 164 fake.QueryxStub = nil 165 fake.queryxReturns = struct { 166 result1 *sqlx.Rows 167 result2 error 168 }{result1, result2} 169 } 170 171 func (fake *UserTx) QueryxReturnsOnCall(i int, result1 *sqlx.Rows, result2 error) { 172 fake.queryxMutex.Lock() 173 defer fake.queryxMutex.Unlock() 174 fake.QueryxStub = nil 175 if fake.queryxReturnsOnCall == nil { 176 fake.queryxReturnsOnCall = make(map[int]struct { 177 result1 *sqlx.Rows 178 result2 error 179 }) 180 } 181 fake.queryxReturnsOnCall[i] = struct { 182 result1 *sqlx.Rows 183 result2 error 184 }{result1, result2} 185 } 186 187 func (fake *UserTx) Rebind(arg1 string) string { 188 fake.rebindMutex.Lock() 189 ret, specificReturn := fake.rebindReturnsOnCall[len(fake.rebindArgsForCall)] 190 fake.rebindArgsForCall = append(fake.rebindArgsForCall, struct { 191 arg1 string 192 }{arg1}) 193 fake.recordInvocation("Rebind", []interface{}{arg1}) 194 fake.rebindMutex.Unlock() 195 if fake.RebindStub != nil { 196 return fake.RebindStub(arg1) 197 } 198 if specificReturn { 199 return ret.result1 200 } 201 fakeReturns := fake.rebindReturns 202 return fakeReturns.result1 203 } 204 205 func (fake *UserTx) RebindCallCount() int { 206 fake.rebindMutex.RLock() 207 defer fake.rebindMutex.RUnlock() 208 return len(fake.rebindArgsForCall) 209 } 210 211 func (fake *UserTx) RebindCalls(stub func(string) string) { 212 fake.rebindMutex.Lock() 213 defer fake.rebindMutex.Unlock() 214 fake.RebindStub = stub 215 } 216 217 func (fake *UserTx) RebindArgsForCall(i int) string { 218 fake.rebindMutex.RLock() 219 defer fake.rebindMutex.RUnlock() 220 argsForCall := fake.rebindArgsForCall[i] 221 return argsForCall.arg1 222 } 223 224 func (fake *UserTx) RebindReturns(result1 string) { 225 fake.rebindMutex.Lock() 226 defer fake.rebindMutex.Unlock() 227 fake.RebindStub = nil 228 fake.rebindReturns = struct { 229 result1 string 230 }{result1} 231 } 232 233 func (fake *UserTx) RebindReturnsOnCall(i int, result1 string) { 234 fake.rebindMutex.Lock() 235 defer fake.rebindMutex.Unlock() 236 fake.RebindStub = nil 237 if fake.rebindReturnsOnCall == nil { 238 fake.rebindReturnsOnCall = make(map[int]struct { 239 result1 string 240 }) 241 } 242 fake.rebindReturnsOnCall[i] = struct { 243 result1 string 244 }{result1} 245 } 246 247 func (fake *UserTx) Invocations() map[string][][]interface{} { 248 fake.invocationsMutex.RLock() 249 defer fake.invocationsMutex.RUnlock() 250 fake.execMutex.RLock() 251 defer fake.execMutex.RUnlock() 252 fake.queryxMutex.RLock() 253 defer fake.queryxMutex.RUnlock() 254 fake.rebindMutex.RLock() 255 defer fake.rebindMutex.RUnlock() 256 copiedInvocations := map[string][][]interface{}{} 257 for key, value := range fake.invocations { 258 copiedInvocations[key] = value 259 } 260 return copiedInvocations 261 } 262 263 func (fake *UserTx) recordInvocation(key string, args []interface{}) { 264 fake.invocationsMutex.Lock() 265 defer fake.invocationsMutex.Unlock() 266 if fake.invocations == nil { 267 fake.invocations = map[string][][]interface{}{} 268 } 269 if fake.invocations[key] == nil { 270 fake.invocations[key] = [][]interface{}{} 271 } 272 fake.invocations[key] = append(fake.invocations[key], args) 273 }