1// Code generated by counterfeiter. DO NOT EDIT.
2package dbfakes
3
4import (
5	"sync"
6	"time"
7
8	"github.com/concourse/concourse/atc"
9	"github.com/concourse/concourse/atc/db"
10)
11
12type FakeWorkerFactory struct {
13	BuildContainersCountPerWorkerStub        func() (map[string]int, error)
14	buildContainersCountPerWorkerMutex       sync.RWMutex
15	buildContainersCountPerWorkerArgsForCall []struct {
16	}
17	buildContainersCountPerWorkerReturns struct {
18		result1 map[string]int
19		result2 error
20	}
21	buildContainersCountPerWorkerReturnsOnCall map[int]struct {
22		result1 map[string]int
23		result2 error
24	}
25	FindWorkersForContainerByOwnerStub        func(db.ContainerOwner) ([]db.Worker, error)
26	findWorkersForContainerByOwnerMutex       sync.RWMutex
27	findWorkersForContainerByOwnerArgsForCall []struct {
28		arg1 db.ContainerOwner
29	}
30	findWorkersForContainerByOwnerReturns struct {
31		result1 []db.Worker
32		result2 error
33	}
34	findWorkersForContainerByOwnerReturnsOnCall map[int]struct {
35		result1 []db.Worker
36		result2 error
37	}
38	GetWorkerStub        func(string) (db.Worker, bool, error)
39	getWorkerMutex       sync.RWMutex
40	getWorkerArgsForCall []struct {
41		arg1 string
42	}
43	getWorkerReturns struct {
44		result1 db.Worker
45		result2 bool
46		result3 error
47	}
48	getWorkerReturnsOnCall map[int]struct {
49		result1 db.Worker
50		result2 bool
51		result3 error
52	}
53	HeartbeatWorkerStub        func(atc.Worker, time.Duration) (db.Worker, error)
54	heartbeatWorkerMutex       sync.RWMutex
55	heartbeatWorkerArgsForCall []struct {
56		arg1 atc.Worker
57		arg2 time.Duration
58	}
59	heartbeatWorkerReturns struct {
60		result1 db.Worker
61		result2 error
62	}
63	heartbeatWorkerReturnsOnCall map[int]struct {
64		result1 db.Worker
65		result2 error
66	}
67	SaveWorkerStub        func(atc.Worker, time.Duration) (db.Worker, error)
68	saveWorkerMutex       sync.RWMutex
69	saveWorkerArgsForCall []struct {
70		arg1 atc.Worker
71		arg2 time.Duration
72	}
73	saveWorkerReturns struct {
74		result1 db.Worker
75		result2 error
76	}
77	saveWorkerReturnsOnCall map[int]struct {
78		result1 db.Worker
79		result2 error
80	}
81	VisibleWorkersStub        func([]string) ([]db.Worker, error)
82	visibleWorkersMutex       sync.RWMutex
83	visibleWorkersArgsForCall []struct {
84		arg1 []string
85	}
86	visibleWorkersReturns struct {
87		result1 []db.Worker
88		result2 error
89	}
90	visibleWorkersReturnsOnCall map[int]struct {
91		result1 []db.Worker
92		result2 error
93	}
94	WorkersStub        func() ([]db.Worker, error)
95	workersMutex       sync.RWMutex
96	workersArgsForCall []struct {
97	}
98	workersReturns struct {
99		result1 []db.Worker
100		result2 error
101	}
102	workersReturnsOnCall map[int]struct {
103		result1 []db.Worker
104		result2 error
105	}
106	invocations      map[string][][]interface{}
107	invocationsMutex sync.RWMutex
108}
109
110func (fake *FakeWorkerFactory) BuildContainersCountPerWorker() (map[string]int, error) {
111	fake.buildContainersCountPerWorkerMutex.Lock()
112	ret, specificReturn := fake.buildContainersCountPerWorkerReturnsOnCall[len(fake.buildContainersCountPerWorkerArgsForCall)]
113	fake.buildContainersCountPerWorkerArgsForCall = append(fake.buildContainersCountPerWorkerArgsForCall, struct {
114	}{})
115	fake.recordInvocation("BuildContainersCountPerWorker", []interface{}{})
116	fake.buildContainersCountPerWorkerMutex.Unlock()
117	if fake.BuildContainersCountPerWorkerStub != nil {
118		return fake.BuildContainersCountPerWorkerStub()
119	}
120	if specificReturn {
121		return ret.result1, ret.result2
122	}
123	fakeReturns := fake.buildContainersCountPerWorkerReturns
124	return fakeReturns.result1, fakeReturns.result2
125}
126
127func (fake *FakeWorkerFactory) BuildContainersCountPerWorkerCallCount() int {
128	fake.buildContainersCountPerWorkerMutex.RLock()
129	defer fake.buildContainersCountPerWorkerMutex.RUnlock()
130	return len(fake.buildContainersCountPerWorkerArgsForCall)
131}
132
133func (fake *FakeWorkerFactory) BuildContainersCountPerWorkerCalls(stub func() (map[string]int, error)) {
134	fake.buildContainersCountPerWorkerMutex.Lock()
135	defer fake.buildContainersCountPerWorkerMutex.Unlock()
136	fake.BuildContainersCountPerWorkerStub = stub
137}
138
139func (fake *FakeWorkerFactory) BuildContainersCountPerWorkerReturns(result1 map[string]int, result2 error) {
140	fake.buildContainersCountPerWorkerMutex.Lock()
141	defer fake.buildContainersCountPerWorkerMutex.Unlock()
142	fake.BuildContainersCountPerWorkerStub = nil
143	fake.buildContainersCountPerWorkerReturns = struct {
144		result1 map[string]int
145		result2 error
146	}{result1, result2}
147}
148
149func (fake *FakeWorkerFactory) BuildContainersCountPerWorkerReturnsOnCall(i int, result1 map[string]int, result2 error) {
150	fake.buildContainersCountPerWorkerMutex.Lock()
151	defer fake.buildContainersCountPerWorkerMutex.Unlock()
152	fake.BuildContainersCountPerWorkerStub = nil
153	if fake.buildContainersCountPerWorkerReturnsOnCall == nil {
154		fake.buildContainersCountPerWorkerReturnsOnCall = make(map[int]struct {
155			result1 map[string]int
156			result2 error
157		})
158	}
159	fake.buildContainersCountPerWorkerReturnsOnCall[i] = struct {
160		result1 map[string]int
161		result2 error
162	}{result1, result2}
163}
164
165func (fake *FakeWorkerFactory) FindWorkersForContainerByOwner(arg1 db.ContainerOwner) ([]db.Worker, error) {
166	fake.findWorkersForContainerByOwnerMutex.Lock()
167	ret, specificReturn := fake.findWorkersForContainerByOwnerReturnsOnCall[len(fake.findWorkersForContainerByOwnerArgsForCall)]
168	fake.findWorkersForContainerByOwnerArgsForCall = append(fake.findWorkersForContainerByOwnerArgsForCall, struct {
169		arg1 db.ContainerOwner
170	}{arg1})
171	fake.recordInvocation("FindWorkersForContainerByOwner", []interface{}{arg1})
172	fake.findWorkersForContainerByOwnerMutex.Unlock()
173	if fake.FindWorkersForContainerByOwnerStub != nil {
174		return fake.FindWorkersForContainerByOwnerStub(arg1)
175	}
176	if specificReturn {
177		return ret.result1, ret.result2
178	}
179	fakeReturns := fake.findWorkersForContainerByOwnerReturns
180	return fakeReturns.result1, fakeReturns.result2
181}
182
183func (fake *FakeWorkerFactory) FindWorkersForContainerByOwnerCallCount() int {
184	fake.findWorkersForContainerByOwnerMutex.RLock()
185	defer fake.findWorkersForContainerByOwnerMutex.RUnlock()
186	return len(fake.findWorkersForContainerByOwnerArgsForCall)
187}
188
189func (fake *FakeWorkerFactory) FindWorkersForContainerByOwnerCalls(stub func(db.ContainerOwner) ([]db.Worker, error)) {
190	fake.findWorkersForContainerByOwnerMutex.Lock()
191	defer fake.findWorkersForContainerByOwnerMutex.Unlock()
192	fake.FindWorkersForContainerByOwnerStub = stub
193}
194
195func (fake *FakeWorkerFactory) FindWorkersForContainerByOwnerArgsForCall(i int) db.ContainerOwner {
196	fake.findWorkersForContainerByOwnerMutex.RLock()
197	defer fake.findWorkersForContainerByOwnerMutex.RUnlock()
198	argsForCall := fake.findWorkersForContainerByOwnerArgsForCall[i]
199	return argsForCall.arg1
200}
201
202func (fake *FakeWorkerFactory) FindWorkersForContainerByOwnerReturns(result1 []db.Worker, result2 error) {
203	fake.findWorkersForContainerByOwnerMutex.Lock()
204	defer fake.findWorkersForContainerByOwnerMutex.Unlock()
205	fake.FindWorkersForContainerByOwnerStub = nil
206	fake.findWorkersForContainerByOwnerReturns = struct {
207		result1 []db.Worker
208		result2 error
209	}{result1, result2}
210}
211
212func (fake *FakeWorkerFactory) FindWorkersForContainerByOwnerReturnsOnCall(i int, result1 []db.Worker, result2 error) {
213	fake.findWorkersForContainerByOwnerMutex.Lock()
214	defer fake.findWorkersForContainerByOwnerMutex.Unlock()
215	fake.FindWorkersForContainerByOwnerStub = nil
216	if fake.findWorkersForContainerByOwnerReturnsOnCall == nil {
217		fake.findWorkersForContainerByOwnerReturnsOnCall = make(map[int]struct {
218			result1 []db.Worker
219			result2 error
220		})
221	}
222	fake.findWorkersForContainerByOwnerReturnsOnCall[i] = struct {
223		result1 []db.Worker
224		result2 error
225	}{result1, result2}
226}
227
228func (fake *FakeWorkerFactory) GetWorker(arg1 string) (db.Worker, bool, error) {
229	fake.getWorkerMutex.Lock()
230	ret, specificReturn := fake.getWorkerReturnsOnCall[len(fake.getWorkerArgsForCall)]
231	fake.getWorkerArgsForCall = append(fake.getWorkerArgsForCall, struct {
232		arg1 string
233	}{arg1})
234	fake.recordInvocation("GetWorker", []interface{}{arg1})
235	fake.getWorkerMutex.Unlock()
236	if fake.GetWorkerStub != nil {
237		return fake.GetWorkerStub(arg1)
238	}
239	if specificReturn {
240		return ret.result1, ret.result2, ret.result3
241	}
242	fakeReturns := fake.getWorkerReturns
243	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
244}
245
246func (fake *FakeWorkerFactory) GetWorkerCallCount() int {
247	fake.getWorkerMutex.RLock()
248	defer fake.getWorkerMutex.RUnlock()
249	return len(fake.getWorkerArgsForCall)
250}
251
252func (fake *FakeWorkerFactory) GetWorkerCalls(stub func(string) (db.Worker, bool, error)) {
253	fake.getWorkerMutex.Lock()
254	defer fake.getWorkerMutex.Unlock()
255	fake.GetWorkerStub = stub
256}
257
258func (fake *FakeWorkerFactory) GetWorkerArgsForCall(i int) string {
259	fake.getWorkerMutex.RLock()
260	defer fake.getWorkerMutex.RUnlock()
261	argsForCall := fake.getWorkerArgsForCall[i]
262	return argsForCall.arg1
263}
264
265func (fake *FakeWorkerFactory) GetWorkerReturns(result1 db.Worker, result2 bool, result3 error) {
266	fake.getWorkerMutex.Lock()
267	defer fake.getWorkerMutex.Unlock()
268	fake.GetWorkerStub = nil
269	fake.getWorkerReturns = struct {
270		result1 db.Worker
271		result2 bool
272		result3 error
273	}{result1, result2, result3}
274}
275
276func (fake *FakeWorkerFactory) GetWorkerReturnsOnCall(i int, result1 db.Worker, result2 bool, result3 error) {
277	fake.getWorkerMutex.Lock()
278	defer fake.getWorkerMutex.Unlock()
279	fake.GetWorkerStub = nil
280	if fake.getWorkerReturnsOnCall == nil {
281		fake.getWorkerReturnsOnCall = make(map[int]struct {
282			result1 db.Worker
283			result2 bool
284			result3 error
285		})
286	}
287	fake.getWorkerReturnsOnCall[i] = struct {
288		result1 db.Worker
289		result2 bool
290		result3 error
291	}{result1, result2, result3}
292}
293
294func (fake *FakeWorkerFactory) HeartbeatWorker(arg1 atc.Worker, arg2 time.Duration) (db.Worker, error) {
295	fake.heartbeatWorkerMutex.Lock()
296	ret, specificReturn := fake.heartbeatWorkerReturnsOnCall[len(fake.heartbeatWorkerArgsForCall)]
297	fake.heartbeatWorkerArgsForCall = append(fake.heartbeatWorkerArgsForCall, struct {
298		arg1 atc.Worker
299		arg2 time.Duration
300	}{arg1, arg2})
301	fake.recordInvocation("HeartbeatWorker", []interface{}{arg1, arg2})
302	fake.heartbeatWorkerMutex.Unlock()
303	if fake.HeartbeatWorkerStub != nil {
304		return fake.HeartbeatWorkerStub(arg1, arg2)
305	}
306	if specificReturn {
307		return ret.result1, ret.result2
308	}
309	fakeReturns := fake.heartbeatWorkerReturns
310	return fakeReturns.result1, fakeReturns.result2
311}
312
313func (fake *FakeWorkerFactory) HeartbeatWorkerCallCount() int {
314	fake.heartbeatWorkerMutex.RLock()
315	defer fake.heartbeatWorkerMutex.RUnlock()
316	return len(fake.heartbeatWorkerArgsForCall)
317}
318
319func (fake *FakeWorkerFactory) HeartbeatWorkerCalls(stub func(atc.Worker, time.Duration) (db.Worker, error)) {
320	fake.heartbeatWorkerMutex.Lock()
321	defer fake.heartbeatWorkerMutex.Unlock()
322	fake.HeartbeatWorkerStub = stub
323}
324
325func (fake *FakeWorkerFactory) HeartbeatWorkerArgsForCall(i int) (atc.Worker, time.Duration) {
326	fake.heartbeatWorkerMutex.RLock()
327	defer fake.heartbeatWorkerMutex.RUnlock()
328	argsForCall := fake.heartbeatWorkerArgsForCall[i]
329	return argsForCall.arg1, argsForCall.arg2
330}
331
332func (fake *FakeWorkerFactory) HeartbeatWorkerReturns(result1 db.Worker, result2 error) {
333	fake.heartbeatWorkerMutex.Lock()
334	defer fake.heartbeatWorkerMutex.Unlock()
335	fake.HeartbeatWorkerStub = nil
336	fake.heartbeatWorkerReturns = struct {
337		result1 db.Worker
338		result2 error
339	}{result1, result2}
340}
341
342func (fake *FakeWorkerFactory) HeartbeatWorkerReturnsOnCall(i int, result1 db.Worker, result2 error) {
343	fake.heartbeatWorkerMutex.Lock()
344	defer fake.heartbeatWorkerMutex.Unlock()
345	fake.HeartbeatWorkerStub = nil
346	if fake.heartbeatWorkerReturnsOnCall == nil {
347		fake.heartbeatWorkerReturnsOnCall = make(map[int]struct {
348			result1 db.Worker
349			result2 error
350		})
351	}
352	fake.heartbeatWorkerReturnsOnCall[i] = struct {
353		result1 db.Worker
354		result2 error
355	}{result1, result2}
356}
357
358func (fake *FakeWorkerFactory) SaveWorker(arg1 atc.Worker, arg2 time.Duration) (db.Worker, error) {
359	fake.saveWorkerMutex.Lock()
360	ret, specificReturn := fake.saveWorkerReturnsOnCall[len(fake.saveWorkerArgsForCall)]
361	fake.saveWorkerArgsForCall = append(fake.saveWorkerArgsForCall, struct {
362		arg1 atc.Worker
363		arg2 time.Duration
364	}{arg1, arg2})
365	fake.recordInvocation("SaveWorker", []interface{}{arg1, arg2})
366	fake.saveWorkerMutex.Unlock()
367	if fake.SaveWorkerStub != nil {
368		return fake.SaveWorkerStub(arg1, arg2)
369	}
370	if specificReturn {
371		return ret.result1, ret.result2
372	}
373	fakeReturns := fake.saveWorkerReturns
374	return fakeReturns.result1, fakeReturns.result2
375}
376
377func (fake *FakeWorkerFactory) SaveWorkerCallCount() int {
378	fake.saveWorkerMutex.RLock()
379	defer fake.saveWorkerMutex.RUnlock()
380	return len(fake.saveWorkerArgsForCall)
381}
382
383func (fake *FakeWorkerFactory) SaveWorkerCalls(stub func(atc.Worker, time.Duration) (db.Worker, error)) {
384	fake.saveWorkerMutex.Lock()
385	defer fake.saveWorkerMutex.Unlock()
386	fake.SaveWorkerStub = stub
387}
388
389func (fake *FakeWorkerFactory) SaveWorkerArgsForCall(i int) (atc.Worker, time.Duration) {
390	fake.saveWorkerMutex.RLock()
391	defer fake.saveWorkerMutex.RUnlock()
392	argsForCall := fake.saveWorkerArgsForCall[i]
393	return argsForCall.arg1, argsForCall.arg2
394}
395
396func (fake *FakeWorkerFactory) SaveWorkerReturns(result1 db.Worker, result2 error) {
397	fake.saveWorkerMutex.Lock()
398	defer fake.saveWorkerMutex.Unlock()
399	fake.SaveWorkerStub = nil
400	fake.saveWorkerReturns = struct {
401		result1 db.Worker
402		result2 error
403	}{result1, result2}
404}
405
406func (fake *FakeWorkerFactory) SaveWorkerReturnsOnCall(i int, result1 db.Worker, result2 error) {
407	fake.saveWorkerMutex.Lock()
408	defer fake.saveWorkerMutex.Unlock()
409	fake.SaveWorkerStub = nil
410	if fake.saveWorkerReturnsOnCall == nil {
411		fake.saveWorkerReturnsOnCall = make(map[int]struct {
412			result1 db.Worker
413			result2 error
414		})
415	}
416	fake.saveWorkerReturnsOnCall[i] = struct {
417		result1 db.Worker
418		result2 error
419	}{result1, result2}
420}
421
422func (fake *FakeWorkerFactory) VisibleWorkers(arg1 []string) ([]db.Worker, error) {
423	var arg1Copy []string
424	if arg1 != nil {
425		arg1Copy = make([]string, len(arg1))
426		copy(arg1Copy, arg1)
427	}
428	fake.visibleWorkersMutex.Lock()
429	ret, specificReturn := fake.visibleWorkersReturnsOnCall[len(fake.visibleWorkersArgsForCall)]
430	fake.visibleWorkersArgsForCall = append(fake.visibleWorkersArgsForCall, struct {
431		arg1 []string
432	}{arg1Copy})
433	fake.recordInvocation("VisibleWorkers", []interface{}{arg1Copy})
434	fake.visibleWorkersMutex.Unlock()
435	if fake.VisibleWorkersStub != nil {
436		return fake.VisibleWorkersStub(arg1)
437	}
438	if specificReturn {
439		return ret.result1, ret.result2
440	}
441	fakeReturns := fake.visibleWorkersReturns
442	return fakeReturns.result1, fakeReturns.result2
443}
444
445func (fake *FakeWorkerFactory) VisibleWorkersCallCount() int {
446	fake.visibleWorkersMutex.RLock()
447	defer fake.visibleWorkersMutex.RUnlock()
448	return len(fake.visibleWorkersArgsForCall)
449}
450
451func (fake *FakeWorkerFactory) VisibleWorkersCalls(stub func([]string) ([]db.Worker, error)) {
452	fake.visibleWorkersMutex.Lock()
453	defer fake.visibleWorkersMutex.Unlock()
454	fake.VisibleWorkersStub = stub
455}
456
457func (fake *FakeWorkerFactory) VisibleWorkersArgsForCall(i int) []string {
458	fake.visibleWorkersMutex.RLock()
459	defer fake.visibleWorkersMutex.RUnlock()
460	argsForCall := fake.visibleWorkersArgsForCall[i]
461	return argsForCall.arg1
462}
463
464func (fake *FakeWorkerFactory) VisibleWorkersReturns(result1 []db.Worker, result2 error) {
465	fake.visibleWorkersMutex.Lock()
466	defer fake.visibleWorkersMutex.Unlock()
467	fake.VisibleWorkersStub = nil
468	fake.visibleWorkersReturns = struct {
469		result1 []db.Worker
470		result2 error
471	}{result1, result2}
472}
473
474func (fake *FakeWorkerFactory) VisibleWorkersReturnsOnCall(i int, result1 []db.Worker, result2 error) {
475	fake.visibleWorkersMutex.Lock()
476	defer fake.visibleWorkersMutex.Unlock()
477	fake.VisibleWorkersStub = nil
478	if fake.visibleWorkersReturnsOnCall == nil {
479		fake.visibleWorkersReturnsOnCall = make(map[int]struct {
480			result1 []db.Worker
481			result2 error
482		})
483	}
484	fake.visibleWorkersReturnsOnCall[i] = struct {
485		result1 []db.Worker
486		result2 error
487	}{result1, result2}
488}
489
490func (fake *FakeWorkerFactory) Workers() ([]db.Worker, error) {
491	fake.workersMutex.Lock()
492	ret, specificReturn := fake.workersReturnsOnCall[len(fake.workersArgsForCall)]
493	fake.workersArgsForCall = append(fake.workersArgsForCall, struct {
494	}{})
495	fake.recordInvocation("Workers", []interface{}{})
496	fake.workersMutex.Unlock()
497	if fake.WorkersStub != nil {
498		return fake.WorkersStub()
499	}
500	if specificReturn {
501		return ret.result1, ret.result2
502	}
503	fakeReturns := fake.workersReturns
504	return fakeReturns.result1, fakeReturns.result2
505}
506
507func (fake *FakeWorkerFactory) WorkersCallCount() int {
508	fake.workersMutex.RLock()
509	defer fake.workersMutex.RUnlock()
510	return len(fake.workersArgsForCall)
511}
512
513func (fake *FakeWorkerFactory) WorkersCalls(stub func() ([]db.Worker, error)) {
514	fake.workersMutex.Lock()
515	defer fake.workersMutex.Unlock()
516	fake.WorkersStub = stub
517}
518
519func (fake *FakeWorkerFactory) WorkersReturns(result1 []db.Worker, result2 error) {
520	fake.workersMutex.Lock()
521	defer fake.workersMutex.Unlock()
522	fake.WorkersStub = nil
523	fake.workersReturns = struct {
524		result1 []db.Worker
525		result2 error
526	}{result1, result2}
527}
528
529func (fake *FakeWorkerFactory) WorkersReturnsOnCall(i int, result1 []db.Worker, result2 error) {
530	fake.workersMutex.Lock()
531	defer fake.workersMutex.Unlock()
532	fake.WorkersStub = nil
533	if fake.workersReturnsOnCall == nil {
534		fake.workersReturnsOnCall = make(map[int]struct {
535			result1 []db.Worker
536			result2 error
537		})
538	}
539	fake.workersReturnsOnCall[i] = struct {
540		result1 []db.Worker
541		result2 error
542	}{result1, result2}
543}
544
545func (fake *FakeWorkerFactory) Invocations() map[string][][]interface{} {
546	fake.invocationsMutex.RLock()
547	defer fake.invocationsMutex.RUnlock()
548	fake.buildContainersCountPerWorkerMutex.RLock()
549	defer fake.buildContainersCountPerWorkerMutex.RUnlock()
550	fake.findWorkersForContainerByOwnerMutex.RLock()
551	defer fake.findWorkersForContainerByOwnerMutex.RUnlock()
552	fake.getWorkerMutex.RLock()
553	defer fake.getWorkerMutex.RUnlock()
554	fake.heartbeatWorkerMutex.RLock()
555	defer fake.heartbeatWorkerMutex.RUnlock()
556	fake.saveWorkerMutex.RLock()
557	defer fake.saveWorkerMutex.RUnlock()
558	fake.visibleWorkersMutex.RLock()
559	defer fake.visibleWorkersMutex.RUnlock()
560	fake.workersMutex.RLock()
561	defer fake.workersMutex.RUnlock()
562	copiedInvocations := map[string][][]interface{}{}
563	for key, value := range fake.invocations {
564		copiedInvocations[key] = value
565	}
566	return copiedInvocations
567}
568
569func (fake *FakeWorkerFactory) recordInvocation(key string, args []interface{}) {
570	fake.invocationsMutex.Lock()
571	defer fake.invocationsMutex.Unlock()
572	if fake.invocations == nil {
573		fake.invocations = map[string][][]interface{}{}
574	}
575	if fake.invocations[key] == nil {
576		fake.invocations[key] = [][]interface{}{}
577	}
578	fake.invocations[key] = append(fake.invocations[key], args)
579}
580
581var _ db.WorkerFactory = new(FakeWorkerFactory)
582