1// Code generated by counterfeiter. DO NOT EDIT.
2package dbfakes
3
4import (
5	"sync"
6	"time"
7
8	"code.cloudfoundry.org/lager"
9	"github.com/concourse/concourse/atc"
10	"github.com/concourse/concourse/atc/creds"
11	"github.com/concourse/concourse/atc/db"
12	"github.com/concourse/concourse/vars"
13)
14
15type FakePipeline struct {
16	ArchiveStub        func() error
17	archiveMutex       sync.RWMutex
18	archiveArgsForCall []struct {
19	}
20	archiveReturns struct {
21		result1 error
22	}
23	archiveReturnsOnCall map[int]struct {
24		result1 error
25	}
26	ArchivedStub        func() bool
27	archivedMutex       sync.RWMutex
28	archivedArgsForCall []struct {
29	}
30	archivedReturns struct {
31		result1 bool
32	}
33	archivedReturnsOnCall map[int]struct {
34		result1 bool
35	}
36	BuildsStub        func(db.Page) ([]db.Build, db.Pagination, error)
37	buildsMutex       sync.RWMutex
38	buildsArgsForCall []struct {
39		arg1 db.Page
40	}
41	buildsReturns struct {
42		result1 []db.Build
43		result2 db.Pagination
44		result3 error
45	}
46	buildsReturnsOnCall map[int]struct {
47		result1 []db.Build
48		result2 db.Pagination
49		result3 error
50	}
51	BuildsWithTimeStub        func(db.Page) ([]db.Build, db.Pagination, error)
52	buildsWithTimeMutex       sync.RWMutex
53	buildsWithTimeArgsForCall []struct {
54		arg1 db.Page
55	}
56	buildsWithTimeReturns struct {
57		result1 []db.Build
58		result2 db.Pagination
59		result3 error
60	}
61	buildsWithTimeReturnsOnCall map[int]struct {
62		result1 []db.Build
63		result2 db.Pagination
64		result3 error
65	}
66	CausalityStub        func(int) ([]db.Cause, error)
67	causalityMutex       sync.RWMutex
68	causalityArgsForCall []struct {
69		arg1 int
70	}
71	causalityReturns struct {
72		result1 []db.Cause
73		result2 error
74	}
75	causalityReturnsOnCall map[int]struct {
76		result1 []db.Cause
77		result2 error
78	}
79	CheckPausedStub        func() (bool, error)
80	checkPausedMutex       sync.RWMutex
81	checkPausedArgsForCall []struct {
82	}
83	checkPausedReturns struct {
84		result1 bool
85		result2 error
86	}
87	checkPausedReturnsOnCall map[int]struct {
88		result1 bool
89		result2 error
90	}
91	ConfigStub        func() (atc.Config, error)
92	configMutex       sync.RWMutex
93	configArgsForCall []struct {
94	}
95	configReturns struct {
96		result1 atc.Config
97		result2 error
98	}
99	configReturnsOnCall map[int]struct {
100		result1 atc.Config
101		result2 error
102	}
103	ConfigVersionStub        func() db.ConfigVersion
104	configVersionMutex       sync.RWMutex
105	configVersionArgsForCall []struct {
106	}
107	configVersionReturns struct {
108		result1 db.ConfigVersion
109	}
110	configVersionReturnsOnCall map[int]struct {
111		result1 db.ConfigVersion
112	}
113	CreateOneOffBuildStub        func() (db.Build, error)
114	createOneOffBuildMutex       sync.RWMutex
115	createOneOffBuildArgsForCall []struct {
116	}
117	createOneOffBuildReturns struct {
118		result1 db.Build
119		result2 error
120	}
121	createOneOffBuildReturnsOnCall map[int]struct {
122		result1 db.Build
123		result2 error
124	}
125	CreateStartedBuildStub        func(atc.Plan) (db.Build, error)
126	createStartedBuildMutex       sync.RWMutex
127	createStartedBuildArgsForCall []struct {
128		arg1 atc.Plan
129	}
130	createStartedBuildReturns struct {
131		result1 db.Build
132		result2 error
133	}
134	createStartedBuildReturnsOnCall map[int]struct {
135		result1 db.Build
136		result2 error
137	}
138	DashboardStub        func() (atc.Dashboard, error)
139	dashboardMutex       sync.RWMutex
140	dashboardArgsForCall []struct {
141	}
142	dashboardReturns struct {
143		result1 atc.Dashboard
144		result2 error
145	}
146	dashboardReturnsOnCall map[int]struct {
147		result1 atc.Dashboard
148		result2 error
149	}
150	DeleteBuildEventsByBuildIDsStub        func([]int) error
151	deleteBuildEventsByBuildIDsMutex       sync.RWMutex
152	deleteBuildEventsByBuildIDsArgsForCall []struct {
153		arg1 []int
154	}
155	deleteBuildEventsByBuildIDsReturns struct {
156		result1 error
157	}
158	deleteBuildEventsByBuildIDsReturnsOnCall map[int]struct {
159		result1 error
160	}
161	DestroyStub        func() error
162	destroyMutex       sync.RWMutex
163	destroyArgsForCall []struct {
164	}
165	destroyReturns struct {
166		result1 error
167	}
168	destroyReturnsOnCall map[int]struct {
169		result1 error
170	}
171	DisplayStub        func() *atc.DisplayConfig
172	displayMutex       sync.RWMutex
173	displayArgsForCall []struct {
174	}
175	displayReturns struct {
176		result1 *atc.DisplayConfig
177	}
178	displayReturnsOnCall map[int]struct {
179		result1 *atc.DisplayConfig
180	}
181	ExposeStub        func() error
182	exposeMutex       sync.RWMutex
183	exposeArgsForCall []struct {
184	}
185	exposeReturns struct {
186		result1 error
187	}
188	exposeReturnsOnCall map[int]struct {
189		result1 error
190	}
191	GetBuildsWithVersionAsInputStub        func(int, int) ([]db.Build, error)
192	getBuildsWithVersionAsInputMutex       sync.RWMutex
193	getBuildsWithVersionAsInputArgsForCall []struct {
194		arg1 int
195		arg2 int
196	}
197	getBuildsWithVersionAsInputReturns struct {
198		result1 []db.Build
199		result2 error
200	}
201	getBuildsWithVersionAsInputReturnsOnCall map[int]struct {
202		result1 []db.Build
203		result2 error
204	}
205	GetBuildsWithVersionAsOutputStub        func(int, int) ([]db.Build, error)
206	getBuildsWithVersionAsOutputMutex       sync.RWMutex
207	getBuildsWithVersionAsOutputArgsForCall []struct {
208		arg1 int
209		arg2 int
210	}
211	getBuildsWithVersionAsOutputReturns struct {
212		result1 []db.Build
213		result2 error
214	}
215	getBuildsWithVersionAsOutputReturnsOnCall map[int]struct {
216		result1 []db.Build
217		result2 error
218	}
219	GroupsStub        func() atc.GroupConfigs
220	groupsMutex       sync.RWMutex
221	groupsArgsForCall []struct {
222	}
223	groupsReturns struct {
224		result1 atc.GroupConfigs
225	}
226	groupsReturnsOnCall map[int]struct {
227		result1 atc.GroupConfigs
228	}
229	HideStub        func() error
230	hideMutex       sync.RWMutex
231	hideArgsForCall []struct {
232	}
233	hideReturns struct {
234		result1 error
235	}
236	hideReturnsOnCall map[int]struct {
237		result1 error
238	}
239	IDStub        func() int
240	iDMutex       sync.RWMutex
241	iDArgsForCall []struct {
242	}
243	iDReturns struct {
244		result1 int
245	}
246	iDReturnsOnCall map[int]struct {
247		result1 int
248	}
249	JobStub        func(string) (db.Job, bool, error)
250	jobMutex       sync.RWMutex
251	jobArgsForCall []struct {
252		arg1 string
253	}
254	jobReturns struct {
255		result1 db.Job
256		result2 bool
257		result3 error
258	}
259	jobReturnsOnCall map[int]struct {
260		result1 db.Job
261		result2 bool
262		result3 error
263	}
264	JobsStub        func() (db.Jobs, error)
265	jobsMutex       sync.RWMutex
266	jobsArgsForCall []struct {
267	}
268	jobsReturns struct {
269		result1 db.Jobs
270		result2 error
271	}
272	jobsReturnsOnCall map[int]struct {
273		result1 db.Jobs
274		result2 error
275	}
276	LastUpdatedStub        func() time.Time
277	lastUpdatedMutex       sync.RWMutex
278	lastUpdatedArgsForCall []struct {
279	}
280	lastUpdatedReturns struct {
281		result1 time.Time
282	}
283	lastUpdatedReturnsOnCall map[int]struct {
284		result1 time.Time
285	}
286	LoadDebugVersionsDBStub        func() (*atc.DebugVersionsDB, error)
287	loadDebugVersionsDBMutex       sync.RWMutex
288	loadDebugVersionsDBArgsForCall []struct {
289	}
290	loadDebugVersionsDBReturns struct {
291		result1 *atc.DebugVersionsDB
292		result2 error
293	}
294	loadDebugVersionsDBReturnsOnCall map[int]struct {
295		result1 *atc.DebugVersionsDB
296		result2 error
297	}
298	NameStub        func() string
299	nameMutex       sync.RWMutex
300	nameArgsForCall []struct {
301	}
302	nameReturns struct {
303		result1 string
304	}
305	nameReturnsOnCall map[int]struct {
306		result1 string
307	}
308	ParentBuildIDStub        func() int
309	parentBuildIDMutex       sync.RWMutex
310	parentBuildIDArgsForCall []struct {
311	}
312	parentBuildIDReturns struct {
313		result1 int
314	}
315	parentBuildIDReturnsOnCall map[int]struct {
316		result1 int
317	}
318	ParentJobIDStub        func() int
319	parentJobIDMutex       sync.RWMutex
320	parentJobIDArgsForCall []struct {
321	}
322	parentJobIDReturns struct {
323		result1 int
324	}
325	parentJobIDReturnsOnCall map[int]struct {
326		result1 int
327	}
328	PauseStub        func() error
329	pauseMutex       sync.RWMutex
330	pauseArgsForCall []struct {
331	}
332	pauseReturns struct {
333		result1 error
334	}
335	pauseReturnsOnCall map[int]struct {
336		result1 error
337	}
338	PausedStub        func() bool
339	pausedMutex       sync.RWMutex
340	pausedArgsForCall []struct {
341	}
342	pausedReturns struct {
343		result1 bool
344	}
345	pausedReturnsOnCall map[int]struct {
346		result1 bool
347	}
348	PublicStub        func() bool
349	publicMutex       sync.RWMutex
350	publicArgsForCall []struct {
351	}
352	publicReturns struct {
353		result1 bool
354	}
355	publicReturnsOnCall map[int]struct {
356		result1 bool
357	}
358	ReloadStub        func() (bool, error)
359	reloadMutex       sync.RWMutex
360	reloadArgsForCall []struct {
361	}
362	reloadReturns struct {
363		result1 bool
364		result2 error
365	}
366	reloadReturnsOnCall map[int]struct {
367		result1 bool
368		result2 error
369	}
370	RenameStub        func(string) error
371	renameMutex       sync.RWMutex
372	renameArgsForCall []struct {
373		arg1 string
374	}
375	renameReturns struct {
376		result1 error
377	}
378	renameReturnsOnCall map[int]struct {
379		result1 error
380	}
381	ResourceStub        func(string) (db.Resource, bool, error)
382	resourceMutex       sync.RWMutex
383	resourceArgsForCall []struct {
384		arg1 string
385	}
386	resourceReturns struct {
387		result1 db.Resource
388		result2 bool
389		result3 error
390	}
391	resourceReturnsOnCall map[int]struct {
392		result1 db.Resource
393		result2 bool
394		result3 error
395	}
396	ResourceByIDStub        func(int) (db.Resource, bool, error)
397	resourceByIDMutex       sync.RWMutex
398	resourceByIDArgsForCall []struct {
399		arg1 int
400	}
401	resourceByIDReturns struct {
402		result1 db.Resource
403		result2 bool
404		result3 error
405	}
406	resourceByIDReturnsOnCall map[int]struct {
407		result1 db.Resource
408		result2 bool
409		result3 error
410	}
411	ResourceTypeStub        func(string) (db.ResourceType, bool, error)
412	resourceTypeMutex       sync.RWMutex
413	resourceTypeArgsForCall []struct {
414		arg1 string
415	}
416	resourceTypeReturns struct {
417		result1 db.ResourceType
418		result2 bool
419		result3 error
420	}
421	resourceTypeReturnsOnCall map[int]struct {
422		result1 db.ResourceType
423		result2 bool
424		result3 error
425	}
426	ResourceTypeByIDStub        func(int) (db.ResourceType, bool, error)
427	resourceTypeByIDMutex       sync.RWMutex
428	resourceTypeByIDArgsForCall []struct {
429		arg1 int
430	}
431	resourceTypeByIDReturns struct {
432		result1 db.ResourceType
433		result2 bool
434		result3 error
435	}
436	resourceTypeByIDReturnsOnCall map[int]struct {
437		result1 db.ResourceType
438		result2 bool
439		result3 error
440	}
441	ResourceTypesStub        func() (db.ResourceTypes, error)
442	resourceTypesMutex       sync.RWMutex
443	resourceTypesArgsForCall []struct {
444	}
445	resourceTypesReturns struct {
446		result1 db.ResourceTypes
447		result2 error
448	}
449	resourceTypesReturnsOnCall map[int]struct {
450		result1 db.ResourceTypes
451		result2 error
452	}
453	ResourceVersionStub        func(int) (atc.ResourceVersion, bool, error)
454	resourceVersionMutex       sync.RWMutex
455	resourceVersionArgsForCall []struct {
456		arg1 int
457	}
458	resourceVersionReturns struct {
459		result1 atc.ResourceVersion
460		result2 bool
461		result3 error
462	}
463	resourceVersionReturnsOnCall map[int]struct {
464		result1 atc.ResourceVersion
465		result2 bool
466		result3 error
467	}
468	ResourcesStub        func() (db.Resources, error)
469	resourcesMutex       sync.RWMutex
470	resourcesArgsForCall []struct {
471	}
472	resourcesReturns struct {
473		result1 db.Resources
474		result2 error
475	}
476	resourcesReturnsOnCall map[int]struct {
477		result1 db.Resources
478		result2 error
479	}
480	SetParentIDsStub        func(int, int) error
481	setParentIDsMutex       sync.RWMutex
482	setParentIDsArgsForCall []struct {
483		arg1 int
484		arg2 int
485	}
486	setParentIDsReturns struct {
487		result1 error
488	}
489	setParentIDsReturnsOnCall map[int]struct {
490		result1 error
491	}
492	TeamIDStub        func() int
493	teamIDMutex       sync.RWMutex
494	teamIDArgsForCall []struct {
495	}
496	teamIDReturns struct {
497		result1 int
498	}
499	teamIDReturnsOnCall map[int]struct {
500		result1 int
501	}
502	TeamNameStub        func() string
503	teamNameMutex       sync.RWMutex
504	teamNameArgsForCall []struct {
505	}
506	teamNameReturns struct {
507		result1 string
508	}
509	teamNameReturnsOnCall map[int]struct {
510		result1 string
511	}
512	UnpauseStub        func() error
513	unpauseMutex       sync.RWMutex
514	unpauseArgsForCall []struct {
515	}
516	unpauseReturns struct {
517		result1 error
518	}
519	unpauseReturnsOnCall map[int]struct {
520		result1 error
521	}
522	VarSourcesStub        func() atc.VarSourceConfigs
523	varSourcesMutex       sync.RWMutex
524	varSourcesArgsForCall []struct {
525	}
526	varSourcesReturns struct {
527		result1 atc.VarSourceConfigs
528	}
529	varSourcesReturnsOnCall map[int]struct {
530		result1 atc.VarSourceConfigs
531	}
532	VariablesStub        func(lager.Logger, creds.Secrets, creds.VarSourcePool) (vars.Variables, error)
533	variablesMutex       sync.RWMutex
534	variablesArgsForCall []struct {
535		arg1 lager.Logger
536		arg2 creds.Secrets
537		arg3 creds.VarSourcePool
538	}
539	variablesReturns struct {
540		result1 vars.Variables
541		result2 error
542	}
543	variablesReturnsOnCall map[int]struct {
544		result1 vars.Variables
545		result2 error
546	}
547	invocations      map[string][][]interface{}
548	invocationsMutex sync.RWMutex
549}
550
551func (fake *FakePipeline) Archive() error {
552	fake.archiveMutex.Lock()
553	ret, specificReturn := fake.archiveReturnsOnCall[len(fake.archiveArgsForCall)]
554	fake.archiveArgsForCall = append(fake.archiveArgsForCall, struct {
555	}{})
556	fake.recordInvocation("Archive", []interface{}{})
557	fake.archiveMutex.Unlock()
558	if fake.ArchiveStub != nil {
559		return fake.ArchiveStub()
560	}
561	if specificReturn {
562		return ret.result1
563	}
564	fakeReturns := fake.archiveReturns
565	return fakeReturns.result1
566}
567
568func (fake *FakePipeline) ArchiveCallCount() int {
569	fake.archiveMutex.RLock()
570	defer fake.archiveMutex.RUnlock()
571	return len(fake.archiveArgsForCall)
572}
573
574func (fake *FakePipeline) ArchiveCalls(stub func() error) {
575	fake.archiveMutex.Lock()
576	defer fake.archiveMutex.Unlock()
577	fake.ArchiveStub = stub
578}
579
580func (fake *FakePipeline) ArchiveReturns(result1 error) {
581	fake.archiveMutex.Lock()
582	defer fake.archiveMutex.Unlock()
583	fake.ArchiveStub = nil
584	fake.archiveReturns = struct {
585		result1 error
586	}{result1}
587}
588
589func (fake *FakePipeline) ArchiveReturnsOnCall(i int, result1 error) {
590	fake.archiveMutex.Lock()
591	defer fake.archiveMutex.Unlock()
592	fake.ArchiveStub = nil
593	if fake.archiveReturnsOnCall == nil {
594		fake.archiveReturnsOnCall = make(map[int]struct {
595			result1 error
596		})
597	}
598	fake.archiveReturnsOnCall[i] = struct {
599		result1 error
600	}{result1}
601}
602
603func (fake *FakePipeline) Archived() bool {
604	fake.archivedMutex.Lock()
605	ret, specificReturn := fake.archivedReturnsOnCall[len(fake.archivedArgsForCall)]
606	fake.archivedArgsForCall = append(fake.archivedArgsForCall, struct {
607	}{})
608	fake.recordInvocation("Archived", []interface{}{})
609	fake.archivedMutex.Unlock()
610	if fake.ArchivedStub != nil {
611		return fake.ArchivedStub()
612	}
613	if specificReturn {
614		return ret.result1
615	}
616	fakeReturns := fake.archivedReturns
617	return fakeReturns.result1
618}
619
620func (fake *FakePipeline) ArchivedCallCount() int {
621	fake.archivedMutex.RLock()
622	defer fake.archivedMutex.RUnlock()
623	return len(fake.archivedArgsForCall)
624}
625
626func (fake *FakePipeline) ArchivedCalls(stub func() bool) {
627	fake.archivedMutex.Lock()
628	defer fake.archivedMutex.Unlock()
629	fake.ArchivedStub = stub
630}
631
632func (fake *FakePipeline) ArchivedReturns(result1 bool) {
633	fake.archivedMutex.Lock()
634	defer fake.archivedMutex.Unlock()
635	fake.ArchivedStub = nil
636	fake.archivedReturns = struct {
637		result1 bool
638	}{result1}
639}
640
641func (fake *FakePipeline) ArchivedReturnsOnCall(i int, result1 bool) {
642	fake.archivedMutex.Lock()
643	defer fake.archivedMutex.Unlock()
644	fake.ArchivedStub = nil
645	if fake.archivedReturnsOnCall == nil {
646		fake.archivedReturnsOnCall = make(map[int]struct {
647			result1 bool
648		})
649	}
650	fake.archivedReturnsOnCall[i] = struct {
651		result1 bool
652	}{result1}
653}
654
655func (fake *FakePipeline) Builds(arg1 db.Page) ([]db.Build, db.Pagination, error) {
656	fake.buildsMutex.Lock()
657	ret, specificReturn := fake.buildsReturnsOnCall[len(fake.buildsArgsForCall)]
658	fake.buildsArgsForCall = append(fake.buildsArgsForCall, struct {
659		arg1 db.Page
660	}{arg1})
661	fake.recordInvocation("Builds", []interface{}{arg1})
662	fake.buildsMutex.Unlock()
663	if fake.BuildsStub != nil {
664		return fake.BuildsStub(arg1)
665	}
666	if specificReturn {
667		return ret.result1, ret.result2, ret.result3
668	}
669	fakeReturns := fake.buildsReturns
670	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
671}
672
673func (fake *FakePipeline) BuildsCallCount() int {
674	fake.buildsMutex.RLock()
675	defer fake.buildsMutex.RUnlock()
676	return len(fake.buildsArgsForCall)
677}
678
679func (fake *FakePipeline) BuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
680	fake.buildsMutex.Lock()
681	defer fake.buildsMutex.Unlock()
682	fake.BuildsStub = stub
683}
684
685func (fake *FakePipeline) BuildsArgsForCall(i int) db.Page {
686	fake.buildsMutex.RLock()
687	defer fake.buildsMutex.RUnlock()
688	argsForCall := fake.buildsArgsForCall[i]
689	return argsForCall.arg1
690}
691
692func (fake *FakePipeline) BuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
693	fake.buildsMutex.Lock()
694	defer fake.buildsMutex.Unlock()
695	fake.BuildsStub = nil
696	fake.buildsReturns = struct {
697		result1 []db.Build
698		result2 db.Pagination
699		result3 error
700	}{result1, result2, result3}
701}
702
703func (fake *FakePipeline) BuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
704	fake.buildsMutex.Lock()
705	defer fake.buildsMutex.Unlock()
706	fake.BuildsStub = nil
707	if fake.buildsReturnsOnCall == nil {
708		fake.buildsReturnsOnCall = make(map[int]struct {
709			result1 []db.Build
710			result2 db.Pagination
711			result3 error
712		})
713	}
714	fake.buildsReturnsOnCall[i] = struct {
715		result1 []db.Build
716		result2 db.Pagination
717		result3 error
718	}{result1, result2, result3}
719}
720
721func (fake *FakePipeline) BuildsWithTime(arg1 db.Page) ([]db.Build, db.Pagination, error) {
722	fake.buildsWithTimeMutex.Lock()
723	ret, specificReturn := fake.buildsWithTimeReturnsOnCall[len(fake.buildsWithTimeArgsForCall)]
724	fake.buildsWithTimeArgsForCall = append(fake.buildsWithTimeArgsForCall, struct {
725		arg1 db.Page
726	}{arg1})
727	fake.recordInvocation("BuildsWithTime", []interface{}{arg1})
728	fake.buildsWithTimeMutex.Unlock()
729	if fake.BuildsWithTimeStub != nil {
730		return fake.BuildsWithTimeStub(arg1)
731	}
732	if specificReturn {
733		return ret.result1, ret.result2, ret.result3
734	}
735	fakeReturns := fake.buildsWithTimeReturns
736	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
737}
738
739func (fake *FakePipeline) BuildsWithTimeCallCount() int {
740	fake.buildsWithTimeMutex.RLock()
741	defer fake.buildsWithTimeMutex.RUnlock()
742	return len(fake.buildsWithTimeArgsForCall)
743}
744
745func (fake *FakePipeline) BuildsWithTimeCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
746	fake.buildsWithTimeMutex.Lock()
747	defer fake.buildsWithTimeMutex.Unlock()
748	fake.BuildsWithTimeStub = stub
749}
750
751func (fake *FakePipeline) BuildsWithTimeArgsForCall(i int) db.Page {
752	fake.buildsWithTimeMutex.RLock()
753	defer fake.buildsWithTimeMutex.RUnlock()
754	argsForCall := fake.buildsWithTimeArgsForCall[i]
755	return argsForCall.arg1
756}
757
758func (fake *FakePipeline) BuildsWithTimeReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
759	fake.buildsWithTimeMutex.Lock()
760	defer fake.buildsWithTimeMutex.Unlock()
761	fake.BuildsWithTimeStub = nil
762	fake.buildsWithTimeReturns = struct {
763		result1 []db.Build
764		result2 db.Pagination
765		result3 error
766	}{result1, result2, result3}
767}
768
769func (fake *FakePipeline) BuildsWithTimeReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
770	fake.buildsWithTimeMutex.Lock()
771	defer fake.buildsWithTimeMutex.Unlock()
772	fake.BuildsWithTimeStub = nil
773	if fake.buildsWithTimeReturnsOnCall == nil {
774		fake.buildsWithTimeReturnsOnCall = make(map[int]struct {
775			result1 []db.Build
776			result2 db.Pagination
777			result3 error
778		})
779	}
780	fake.buildsWithTimeReturnsOnCall[i] = struct {
781		result1 []db.Build
782		result2 db.Pagination
783		result3 error
784	}{result1, result2, result3}
785}
786
787func (fake *FakePipeline) Causality(arg1 int) ([]db.Cause, error) {
788	fake.causalityMutex.Lock()
789	ret, specificReturn := fake.causalityReturnsOnCall[len(fake.causalityArgsForCall)]
790	fake.causalityArgsForCall = append(fake.causalityArgsForCall, struct {
791		arg1 int
792	}{arg1})
793	fake.recordInvocation("Causality", []interface{}{arg1})
794	fake.causalityMutex.Unlock()
795	if fake.CausalityStub != nil {
796		return fake.CausalityStub(arg1)
797	}
798	if specificReturn {
799		return ret.result1, ret.result2
800	}
801	fakeReturns := fake.causalityReturns
802	return fakeReturns.result1, fakeReturns.result2
803}
804
805func (fake *FakePipeline) CausalityCallCount() int {
806	fake.causalityMutex.RLock()
807	defer fake.causalityMutex.RUnlock()
808	return len(fake.causalityArgsForCall)
809}
810
811func (fake *FakePipeline) CausalityCalls(stub func(int) ([]db.Cause, error)) {
812	fake.causalityMutex.Lock()
813	defer fake.causalityMutex.Unlock()
814	fake.CausalityStub = stub
815}
816
817func (fake *FakePipeline) CausalityArgsForCall(i int) int {
818	fake.causalityMutex.RLock()
819	defer fake.causalityMutex.RUnlock()
820	argsForCall := fake.causalityArgsForCall[i]
821	return argsForCall.arg1
822}
823
824func (fake *FakePipeline) CausalityReturns(result1 []db.Cause, result2 error) {
825	fake.causalityMutex.Lock()
826	defer fake.causalityMutex.Unlock()
827	fake.CausalityStub = nil
828	fake.causalityReturns = struct {
829		result1 []db.Cause
830		result2 error
831	}{result1, result2}
832}
833
834func (fake *FakePipeline) CausalityReturnsOnCall(i int, result1 []db.Cause, result2 error) {
835	fake.causalityMutex.Lock()
836	defer fake.causalityMutex.Unlock()
837	fake.CausalityStub = nil
838	if fake.causalityReturnsOnCall == nil {
839		fake.causalityReturnsOnCall = make(map[int]struct {
840			result1 []db.Cause
841			result2 error
842		})
843	}
844	fake.causalityReturnsOnCall[i] = struct {
845		result1 []db.Cause
846		result2 error
847	}{result1, result2}
848}
849
850func (fake *FakePipeline) CheckPaused() (bool, error) {
851	fake.checkPausedMutex.Lock()
852	ret, specificReturn := fake.checkPausedReturnsOnCall[len(fake.checkPausedArgsForCall)]
853	fake.checkPausedArgsForCall = append(fake.checkPausedArgsForCall, struct {
854	}{})
855	fake.recordInvocation("CheckPaused", []interface{}{})
856	fake.checkPausedMutex.Unlock()
857	if fake.CheckPausedStub != nil {
858		return fake.CheckPausedStub()
859	}
860	if specificReturn {
861		return ret.result1, ret.result2
862	}
863	fakeReturns := fake.checkPausedReturns
864	return fakeReturns.result1, fakeReturns.result2
865}
866
867func (fake *FakePipeline) CheckPausedCallCount() int {
868	fake.checkPausedMutex.RLock()
869	defer fake.checkPausedMutex.RUnlock()
870	return len(fake.checkPausedArgsForCall)
871}
872
873func (fake *FakePipeline) CheckPausedCalls(stub func() (bool, error)) {
874	fake.checkPausedMutex.Lock()
875	defer fake.checkPausedMutex.Unlock()
876	fake.CheckPausedStub = stub
877}
878
879func (fake *FakePipeline) CheckPausedReturns(result1 bool, result2 error) {
880	fake.checkPausedMutex.Lock()
881	defer fake.checkPausedMutex.Unlock()
882	fake.CheckPausedStub = nil
883	fake.checkPausedReturns = struct {
884		result1 bool
885		result2 error
886	}{result1, result2}
887}
888
889func (fake *FakePipeline) CheckPausedReturnsOnCall(i int, result1 bool, result2 error) {
890	fake.checkPausedMutex.Lock()
891	defer fake.checkPausedMutex.Unlock()
892	fake.CheckPausedStub = nil
893	if fake.checkPausedReturnsOnCall == nil {
894		fake.checkPausedReturnsOnCall = make(map[int]struct {
895			result1 bool
896			result2 error
897		})
898	}
899	fake.checkPausedReturnsOnCall[i] = struct {
900		result1 bool
901		result2 error
902	}{result1, result2}
903}
904
905func (fake *FakePipeline) Config() (atc.Config, error) {
906	fake.configMutex.Lock()
907	ret, specificReturn := fake.configReturnsOnCall[len(fake.configArgsForCall)]
908	fake.configArgsForCall = append(fake.configArgsForCall, struct {
909	}{})
910	fake.recordInvocation("Config", []interface{}{})
911	fake.configMutex.Unlock()
912	if fake.ConfigStub != nil {
913		return fake.ConfigStub()
914	}
915	if specificReturn {
916		return ret.result1, ret.result2
917	}
918	fakeReturns := fake.configReturns
919	return fakeReturns.result1, fakeReturns.result2
920}
921
922func (fake *FakePipeline) ConfigCallCount() int {
923	fake.configMutex.RLock()
924	defer fake.configMutex.RUnlock()
925	return len(fake.configArgsForCall)
926}
927
928func (fake *FakePipeline) ConfigCalls(stub func() (atc.Config, error)) {
929	fake.configMutex.Lock()
930	defer fake.configMutex.Unlock()
931	fake.ConfigStub = stub
932}
933
934func (fake *FakePipeline) ConfigReturns(result1 atc.Config, result2 error) {
935	fake.configMutex.Lock()
936	defer fake.configMutex.Unlock()
937	fake.ConfigStub = nil
938	fake.configReturns = struct {
939		result1 atc.Config
940		result2 error
941	}{result1, result2}
942}
943
944func (fake *FakePipeline) ConfigReturnsOnCall(i int, result1 atc.Config, result2 error) {
945	fake.configMutex.Lock()
946	defer fake.configMutex.Unlock()
947	fake.ConfigStub = nil
948	if fake.configReturnsOnCall == nil {
949		fake.configReturnsOnCall = make(map[int]struct {
950			result1 atc.Config
951			result2 error
952		})
953	}
954	fake.configReturnsOnCall[i] = struct {
955		result1 atc.Config
956		result2 error
957	}{result1, result2}
958}
959
960func (fake *FakePipeline) ConfigVersion() db.ConfigVersion {
961	fake.configVersionMutex.Lock()
962	ret, specificReturn := fake.configVersionReturnsOnCall[len(fake.configVersionArgsForCall)]
963	fake.configVersionArgsForCall = append(fake.configVersionArgsForCall, struct {
964	}{})
965	fake.recordInvocation("ConfigVersion", []interface{}{})
966	fake.configVersionMutex.Unlock()
967	if fake.ConfigVersionStub != nil {
968		return fake.ConfigVersionStub()
969	}
970	if specificReturn {
971		return ret.result1
972	}
973	fakeReturns := fake.configVersionReturns
974	return fakeReturns.result1
975}
976
977func (fake *FakePipeline) ConfigVersionCallCount() int {
978	fake.configVersionMutex.RLock()
979	defer fake.configVersionMutex.RUnlock()
980	return len(fake.configVersionArgsForCall)
981}
982
983func (fake *FakePipeline) ConfigVersionCalls(stub func() db.ConfigVersion) {
984	fake.configVersionMutex.Lock()
985	defer fake.configVersionMutex.Unlock()
986	fake.ConfigVersionStub = stub
987}
988
989func (fake *FakePipeline) ConfigVersionReturns(result1 db.ConfigVersion) {
990	fake.configVersionMutex.Lock()
991	defer fake.configVersionMutex.Unlock()
992	fake.ConfigVersionStub = nil
993	fake.configVersionReturns = struct {
994		result1 db.ConfigVersion
995	}{result1}
996}
997
998func (fake *FakePipeline) ConfigVersionReturnsOnCall(i int, result1 db.ConfigVersion) {
999	fake.configVersionMutex.Lock()
1000	defer fake.configVersionMutex.Unlock()
1001	fake.ConfigVersionStub = nil
1002	if fake.configVersionReturnsOnCall == nil {
1003		fake.configVersionReturnsOnCall = make(map[int]struct {
1004			result1 db.ConfigVersion
1005		})
1006	}
1007	fake.configVersionReturnsOnCall[i] = struct {
1008		result1 db.ConfigVersion
1009	}{result1}
1010}
1011
1012func (fake *FakePipeline) CreateOneOffBuild() (db.Build, error) {
1013	fake.createOneOffBuildMutex.Lock()
1014	ret, specificReturn := fake.createOneOffBuildReturnsOnCall[len(fake.createOneOffBuildArgsForCall)]
1015	fake.createOneOffBuildArgsForCall = append(fake.createOneOffBuildArgsForCall, struct {
1016	}{})
1017	fake.recordInvocation("CreateOneOffBuild", []interface{}{})
1018	fake.createOneOffBuildMutex.Unlock()
1019	if fake.CreateOneOffBuildStub != nil {
1020		return fake.CreateOneOffBuildStub()
1021	}
1022	if specificReturn {
1023		return ret.result1, ret.result2
1024	}
1025	fakeReturns := fake.createOneOffBuildReturns
1026	return fakeReturns.result1, fakeReturns.result2
1027}
1028
1029func (fake *FakePipeline) CreateOneOffBuildCallCount() int {
1030	fake.createOneOffBuildMutex.RLock()
1031	defer fake.createOneOffBuildMutex.RUnlock()
1032	return len(fake.createOneOffBuildArgsForCall)
1033}
1034
1035func (fake *FakePipeline) CreateOneOffBuildCalls(stub func() (db.Build, error)) {
1036	fake.createOneOffBuildMutex.Lock()
1037	defer fake.createOneOffBuildMutex.Unlock()
1038	fake.CreateOneOffBuildStub = stub
1039}
1040
1041func (fake *FakePipeline) CreateOneOffBuildReturns(result1 db.Build, result2 error) {
1042	fake.createOneOffBuildMutex.Lock()
1043	defer fake.createOneOffBuildMutex.Unlock()
1044	fake.CreateOneOffBuildStub = nil
1045	fake.createOneOffBuildReturns = struct {
1046		result1 db.Build
1047		result2 error
1048	}{result1, result2}
1049}
1050
1051func (fake *FakePipeline) CreateOneOffBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
1052	fake.createOneOffBuildMutex.Lock()
1053	defer fake.createOneOffBuildMutex.Unlock()
1054	fake.CreateOneOffBuildStub = nil
1055	if fake.createOneOffBuildReturnsOnCall == nil {
1056		fake.createOneOffBuildReturnsOnCall = make(map[int]struct {
1057			result1 db.Build
1058			result2 error
1059		})
1060	}
1061	fake.createOneOffBuildReturnsOnCall[i] = struct {
1062		result1 db.Build
1063		result2 error
1064	}{result1, result2}
1065}
1066
1067func (fake *FakePipeline) CreateStartedBuild(arg1 atc.Plan) (db.Build, error) {
1068	fake.createStartedBuildMutex.Lock()
1069	ret, specificReturn := fake.createStartedBuildReturnsOnCall[len(fake.createStartedBuildArgsForCall)]
1070	fake.createStartedBuildArgsForCall = append(fake.createStartedBuildArgsForCall, struct {
1071		arg1 atc.Plan
1072	}{arg1})
1073	fake.recordInvocation("CreateStartedBuild", []interface{}{arg1})
1074	fake.createStartedBuildMutex.Unlock()
1075	if fake.CreateStartedBuildStub != nil {
1076		return fake.CreateStartedBuildStub(arg1)
1077	}
1078	if specificReturn {
1079		return ret.result1, ret.result2
1080	}
1081	fakeReturns := fake.createStartedBuildReturns
1082	return fakeReturns.result1, fakeReturns.result2
1083}
1084
1085func (fake *FakePipeline) CreateStartedBuildCallCount() int {
1086	fake.createStartedBuildMutex.RLock()
1087	defer fake.createStartedBuildMutex.RUnlock()
1088	return len(fake.createStartedBuildArgsForCall)
1089}
1090
1091func (fake *FakePipeline) CreateStartedBuildCalls(stub func(atc.Plan) (db.Build, error)) {
1092	fake.createStartedBuildMutex.Lock()
1093	defer fake.createStartedBuildMutex.Unlock()
1094	fake.CreateStartedBuildStub = stub
1095}
1096
1097func (fake *FakePipeline) CreateStartedBuildArgsForCall(i int) atc.Plan {
1098	fake.createStartedBuildMutex.RLock()
1099	defer fake.createStartedBuildMutex.RUnlock()
1100	argsForCall := fake.createStartedBuildArgsForCall[i]
1101	return argsForCall.arg1
1102}
1103
1104func (fake *FakePipeline) CreateStartedBuildReturns(result1 db.Build, result2 error) {
1105	fake.createStartedBuildMutex.Lock()
1106	defer fake.createStartedBuildMutex.Unlock()
1107	fake.CreateStartedBuildStub = nil
1108	fake.createStartedBuildReturns = struct {
1109		result1 db.Build
1110		result2 error
1111	}{result1, result2}
1112}
1113
1114func (fake *FakePipeline) CreateStartedBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
1115	fake.createStartedBuildMutex.Lock()
1116	defer fake.createStartedBuildMutex.Unlock()
1117	fake.CreateStartedBuildStub = nil
1118	if fake.createStartedBuildReturnsOnCall == nil {
1119		fake.createStartedBuildReturnsOnCall = make(map[int]struct {
1120			result1 db.Build
1121			result2 error
1122		})
1123	}
1124	fake.createStartedBuildReturnsOnCall[i] = struct {
1125		result1 db.Build
1126		result2 error
1127	}{result1, result2}
1128}
1129
1130func (fake *FakePipeline) Dashboard() (atc.Dashboard, error) {
1131	fake.dashboardMutex.Lock()
1132	ret, specificReturn := fake.dashboardReturnsOnCall[len(fake.dashboardArgsForCall)]
1133	fake.dashboardArgsForCall = append(fake.dashboardArgsForCall, struct {
1134	}{})
1135	fake.recordInvocation("Dashboard", []interface{}{})
1136	fake.dashboardMutex.Unlock()
1137	if fake.DashboardStub != nil {
1138		return fake.DashboardStub()
1139	}
1140	if specificReturn {
1141		return ret.result1, ret.result2
1142	}
1143	fakeReturns := fake.dashboardReturns
1144	return fakeReturns.result1, fakeReturns.result2
1145}
1146
1147func (fake *FakePipeline) DashboardCallCount() int {
1148	fake.dashboardMutex.RLock()
1149	defer fake.dashboardMutex.RUnlock()
1150	return len(fake.dashboardArgsForCall)
1151}
1152
1153func (fake *FakePipeline) DashboardCalls(stub func() (atc.Dashboard, error)) {
1154	fake.dashboardMutex.Lock()
1155	defer fake.dashboardMutex.Unlock()
1156	fake.DashboardStub = stub
1157}
1158
1159func (fake *FakePipeline) DashboardReturns(result1 atc.Dashboard, result2 error) {
1160	fake.dashboardMutex.Lock()
1161	defer fake.dashboardMutex.Unlock()
1162	fake.DashboardStub = nil
1163	fake.dashboardReturns = struct {
1164		result1 atc.Dashboard
1165		result2 error
1166	}{result1, result2}
1167}
1168
1169func (fake *FakePipeline) DashboardReturnsOnCall(i int, result1 atc.Dashboard, result2 error) {
1170	fake.dashboardMutex.Lock()
1171	defer fake.dashboardMutex.Unlock()
1172	fake.DashboardStub = nil
1173	if fake.dashboardReturnsOnCall == nil {
1174		fake.dashboardReturnsOnCall = make(map[int]struct {
1175			result1 atc.Dashboard
1176			result2 error
1177		})
1178	}
1179	fake.dashboardReturnsOnCall[i] = struct {
1180		result1 atc.Dashboard
1181		result2 error
1182	}{result1, result2}
1183}
1184
1185func (fake *FakePipeline) DeleteBuildEventsByBuildIDs(arg1 []int) error {
1186	var arg1Copy []int
1187	if arg1 != nil {
1188		arg1Copy = make([]int, len(arg1))
1189		copy(arg1Copy, arg1)
1190	}
1191	fake.deleteBuildEventsByBuildIDsMutex.Lock()
1192	ret, specificReturn := fake.deleteBuildEventsByBuildIDsReturnsOnCall[len(fake.deleteBuildEventsByBuildIDsArgsForCall)]
1193	fake.deleteBuildEventsByBuildIDsArgsForCall = append(fake.deleteBuildEventsByBuildIDsArgsForCall, struct {
1194		arg1 []int
1195	}{arg1Copy})
1196	fake.recordInvocation("DeleteBuildEventsByBuildIDs", []interface{}{arg1Copy})
1197	fake.deleteBuildEventsByBuildIDsMutex.Unlock()
1198	if fake.DeleteBuildEventsByBuildIDsStub != nil {
1199		return fake.DeleteBuildEventsByBuildIDsStub(arg1)
1200	}
1201	if specificReturn {
1202		return ret.result1
1203	}
1204	fakeReturns := fake.deleteBuildEventsByBuildIDsReturns
1205	return fakeReturns.result1
1206}
1207
1208func (fake *FakePipeline) DeleteBuildEventsByBuildIDsCallCount() int {
1209	fake.deleteBuildEventsByBuildIDsMutex.RLock()
1210	defer fake.deleteBuildEventsByBuildIDsMutex.RUnlock()
1211	return len(fake.deleteBuildEventsByBuildIDsArgsForCall)
1212}
1213
1214func (fake *FakePipeline) DeleteBuildEventsByBuildIDsCalls(stub func([]int) error) {
1215	fake.deleteBuildEventsByBuildIDsMutex.Lock()
1216	defer fake.deleteBuildEventsByBuildIDsMutex.Unlock()
1217	fake.DeleteBuildEventsByBuildIDsStub = stub
1218}
1219
1220func (fake *FakePipeline) DeleteBuildEventsByBuildIDsArgsForCall(i int) []int {
1221	fake.deleteBuildEventsByBuildIDsMutex.RLock()
1222	defer fake.deleteBuildEventsByBuildIDsMutex.RUnlock()
1223	argsForCall := fake.deleteBuildEventsByBuildIDsArgsForCall[i]
1224	return argsForCall.arg1
1225}
1226
1227func (fake *FakePipeline) DeleteBuildEventsByBuildIDsReturns(result1 error) {
1228	fake.deleteBuildEventsByBuildIDsMutex.Lock()
1229	defer fake.deleteBuildEventsByBuildIDsMutex.Unlock()
1230	fake.DeleteBuildEventsByBuildIDsStub = nil
1231	fake.deleteBuildEventsByBuildIDsReturns = struct {
1232		result1 error
1233	}{result1}
1234}
1235
1236func (fake *FakePipeline) DeleteBuildEventsByBuildIDsReturnsOnCall(i int, result1 error) {
1237	fake.deleteBuildEventsByBuildIDsMutex.Lock()
1238	defer fake.deleteBuildEventsByBuildIDsMutex.Unlock()
1239	fake.DeleteBuildEventsByBuildIDsStub = nil
1240	if fake.deleteBuildEventsByBuildIDsReturnsOnCall == nil {
1241		fake.deleteBuildEventsByBuildIDsReturnsOnCall = make(map[int]struct {
1242			result1 error
1243		})
1244	}
1245	fake.deleteBuildEventsByBuildIDsReturnsOnCall[i] = struct {
1246		result1 error
1247	}{result1}
1248}
1249
1250func (fake *FakePipeline) Destroy() error {
1251	fake.destroyMutex.Lock()
1252	ret, specificReturn := fake.destroyReturnsOnCall[len(fake.destroyArgsForCall)]
1253	fake.destroyArgsForCall = append(fake.destroyArgsForCall, struct {
1254	}{})
1255	fake.recordInvocation("Destroy", []interface{}{})
1256	fake.destroyMutex.Unlock()
1257	if fake.DestroyStub != nil {
1258		return fake.DestroyStub()
1259	}
1260	if specificReturn {
1261		return ret.result1
1262	}
1263	fakeReturns := fake.destroyReturns
1264	return fakeReturns.result1
1265}
1266
1267func (fake *FakePipeline) DestroyCallCount() int {
1268	fake.destroyMutex.RLock()
1269	defer fake.destroyMutex.RUnlock()
1270	return len(fake.destroyArgsForCall)
1271}
1272
1273func (fake *FakePipeline) DestroyCalls(stub func() error) {
1274	fake.destroyMutex.Lock()
1275	defer fake.destroyMutex.Unlock()
1276	fake.DestroyStub = stub
1277}
1278
1279func (fake *FakePipeline) DestroyReturns(result1 error) {
1280	fake.destroyMutex.Lock()
1281	defer fake.destroyMutex.Unlock()
1282	fake.DestroyStub = nil
1283	fake.destroyReturns = struct {
1284		result1 error
1285	}{result1}
1286}
1287
1288func (fake *FakePipeline) DestroyReturnsOnCall(i int, result1 error) {
1289	fake.destroyMutex.Lock()
1290	defer fake.destroyMutex.Unlock()
1291	fake.DestroyStub = nil
1292	if fake.destroyReturnsOnCall == nil {
1293		fake.destroyReturnsOnCall = make(map[int]struct {
1294			result1 error
1295		})
1296	}
1297	fake.destroyReturnsOnCall[i] = struct {
1298		result1 error
1299	}{result1}
1300}
1301
1302func (fake *FakePipeline) Display() *atc.DisplayConfig {
1303	fake.displayMutex.Lock()
1304	ret, specificReturn := fake.displayReturnsOnCall[len(fake.displayArgsForCall)]
1305	fake.displayArgsForCall = append(fake.displayArgsForCall, struct {
1306	}{})
1307	fake.recordInvocation("Display", []interface{}{})
1308	fake.displayMutex.Unlock()
1309	if fake.DisplayStub != nil {
1310		return fake.DisplayStub()
1311	}
1312	if specificReturn {
1313		return ret.result1
1314	}
1315	fakeReturns := fake.displayReturns
1316	return fakeReturns.result1
1317}
1318
1319func (fake *FakePipeline) DisplayCallCount() int {
1320	fake.displayMutex.RLock()
1321	defer fake.displayMutex.RUnlock()
1322	return len(fake.displayArgsForCall)
1323}
1324
1325func (fake *FakePipeline) DisplayCalls(stub func() *atc.DisplayConfig) {
1326	fake.displayMutex.Lock()
1327	defer fake.displayMutex.Unlock()
1328	fake.DisplayStub = stub
1329}
1330
1331func (fake *FakePipeline) DisplayReturns(result1 *atc.DisplayConfig) {
1332	fake.displayMutex.Lock()
1333	defer fake.displayMutex.Unlock()
1334	fake.DisplayStub = nil
1335	fake.displayReturns = struct {
1336		result1 *atc.DisplayConfig
1337	}{result1}
1338}
1339
1340func (fake *FakePipeline) DisplayReturnsOnCall(i int, result1 *atc.DisplayConfig) {
1341	fake.displayMutex.Lock()
1342	defer fake.displayMutex.Unlock()
1343	fake.DisplayStub = nil
1344	if fake.displayReturnsOnCall == nil {
1345		fake.displayReturnsOnCall = make(map[int]struct {
1346			result1 *atc.DisplayConfig
1347		})
1348	}
1349	fake.displayReturnsOnCall[i] = struct {
1350		result1 *atc.DisplayConfig
1351	}{result1}
1352}
1353
1354func (fake *FakePipeline) Expose() error {
1355	fake.exposeMutex.Lock()
1356	ret, specificReturn := fake.exposeReturnsOnCall[len(fake.exposeArgsForCall)]
1357	fake.exposeArgsForCall = append(fake.exposeArgsForCall, struct {
1358	}{})
1359	fake.recordInvocation("Expose", []interface{}{})
1360	fake.exposeMutex.Unlock()
1361	if fake.ExposeStub != nil {
1362		return fake.ExposeStub()
1363	}
1364	if specificReturn {
1365		return ret.result1
1366	}
1367	fakeReturns := fake.exposeReturns
1368	return fakeReturns.result1
1369}
1370
1371func (fake *FakePipeline) ExposeCallCount() int {
1372	fake.exposeMutex.RLock()
1373	defer fake.exposeMutex.RUnlock()
1374	return len(fake.exposeArgsForCall)
1375}
1376
1377func (fake *FakePipeline) ExposeCalls(stub func() error) {
1378	fake.exposeMutex.Lock()
1379	defer fake.exposeMutex.Unlock()
1380	fake.ExposeStub = stub
1381}
1382
1383func (fake *FakePipeline) ExposeReturns(result1 error) {
1384	fake.exposeMutex.Lock()
1385	defer fake.exposeMutex.Unlock()
1386	fake.ExposeStub = nil
1387	fake.exposeReturns = struct {
1388		result1 error
1389	}{result1}
1390}
1391
1392func (fake *FakePipeline) ExposeReturnsOnCall(i int, result1 error) {
1393	fake.exposeMutex.Lock()
1394	defer fake.exposeMutex.Unlock()
1395	fake.ExposeStub = nil
1396	if fake.exposeReturnsOnCall == nil {
1397		fake.exposeReturnsOnCall = make(map[int]struct {
1398			result1 error
1399		})
1400	}
1401	fake.exposeReturnsOnCall[i] = struct {
1402		result1 error
1403	}{result1}
1404}
1405
1406func (fake *FakePipeline) GetBuildsWithVersionAsInput(arg1 int, arg2 int) ([]db.Build, error) {
1407	fake.getBuildsWithVersionAsInputMutex.Lock()
1408	ret, specificReturn := fake.getBuildsWithVersionAsInputReturnsOnCall[len(fake.getBuildsWithVersionAsInputArgsForCall)]
1409	fake.getBuildsWithVersionAsInputArgsForCall = append(fake.getBuildsWithVersionAsInputArgsForCall, struct {
1410		arg1 int
1411		arg2 int
1412	}{arg1, arg2})
1413	fake.recordInvocation("GetBuildsWithVersionAsInput", []interface{}{arg1, arg2})
1414	fake.getBuildsWithVersionAsInputMutex.Unlock()
1415	if fake.GetBuildsWithVersionAsInputStub != nil {
1416		return fake.GetBuildsWithVersionAsInputStub(arg1, arg2)
1417	}
1418	if specificReturn {
1419		return ret.result1, ret.result2
1420	}
1421	fakeReturns := fake.getBuildsWithVersionAsInputReturns
1422	return fakeReturns.result1, fakeReturns.result2
1423}
1424
1425func (fake *FakePipeline) GetBuildsWithVersionAsInputCallCount() int {
1426	fake.getBuildsWithVersionAsInputMutex.RLock()
1427	defer fake.getBuildsWithVersionAsInputMutex.RUnlock()
1428	return len(fake.getBuildsWithVersionAsInputArgsForCall)
1429}
1430
1431func (fake *FakePipeline) GetBuildsWithVersionAsInputCalls(stub func(int, int) ([]db.Build, error)) {
1432	fake.getBuildsWithVersionAsInputMutex.Lock()
1433	defer fake.getBuildsWithVersionAsInputMutex.Unlock()
1434	fake.GetBuildsWithVersionAsInputStub = stub
1435}
1436
1437func (fake *FakePipeline) GetBuildsWithVersionAsInputArgsForCall(i int) (int, int) {
1438	fake.getBuildsWithVersionAsInputMutex.RLock()
1439	defer fake.getBuildsWithVersionAsInputMutex.RUnlock()
1440	argsForCall := fake.getBuildsWithVersionAsInputArgsForCall[i]
1441	return argsForCall.arg1, argsForCall.arg2
1442}
1443
1444func (fake *FakePipeline) GetBuildsWithVersionAsInputReturns(result1 []db.Build, result2 error) {
1445	fake.getBuildsWithVersionAsInputMutex.Lock()
1446	defer fake.getBuildsWithVersionAsInputMutex.Unlock()
1447	fake.GetBuildsWithVersionAsInputStub = nil
1448	fake.getBuildsWithVersionAsInputReturns = struct {
1449		result1 []db.Build
1450		result2 error
1451	}{result1, result2}
1452}
1453
1454func (fake *FakePipeline) GetBuildsWithVersionAsInputReturnsOnCall(i int, result1 []db.Build, result2 error) {
1455	fake.getBuildsWithVersionAsInputMutex.Lock()
1456	defer fake.getBuildsWithVersionAsInputMutex.Unlock()
1457	fake.GetBuildsWithVersionAsInputStub = nil
1458	if fake.getBuildsWithVersionAsInputReturnsOnCall == nil {
1459		fake.getBuildsWithVersionAsInputReturnsOnCall = make(map[int]struct {
1460			result1 []db.Build
1461			result2 error
1462		})
1463	}
1464	fake.getBuildsWithVersionAsInputReturnsOnCall[i] = struct {
1465		result1 []db.Build
1466		result2 error
1467	}{result1, result2}
1468}
1469
1470func (fake *FakePipeline) GetBuildsWithVersionAsOutput(arg1 int, arg2 int) ([]db.Build, error) {
1471	fake.getBuildsWithVersionAsOutputMutex.Lock()
1472	ret, specificReturn := fake.getBuildsWithVersionAsOutputReturnsOnCall[len(fake.getBuildsWithVersionAsOutputArgsForCall)]
1473	fake.getBuildsWithVersionAsOutputArgsForCall = append(fake.getBuildsWithVersionAsOutputArgsForCall, struct {
1474		arg1 int
1475		arg2 int
1476	}{arg1, arg2})
1477	fake.recordInvocation("GetBuildsWithVersionAsOutput", []interface{}{arg1, arg2})
1478	fake.getBuildsWithVersionAsOutputMutex.Unlock()
1479	if fake.GetBuildsWithVersionAsOutputStub != nil {
1480		return fake.GetBuildsWithVersionAsOutputStub(arg1, arg2)
1481	}
1482	if specificReturn {
1483		return ret.result1, ret.result2
1484	}
1485	fakeReturns := fake.getBuildsWithVersionAsOutputReturns
1486	return fakeReturns.result1, fakeReturns.result2
1487}
1488
1489func (fake *FakePipeline) GetBuildsWithVersionAsOutputCallCount() int {
1490	fake.getBuildsWithVersionAsOutputMutex.RLock()
1491	defer fake.getBuildsWithVersionAsOutputMutex.RUnlock()
1492	return len(fake.getBuildsWithVersionAsOutputArgsForCall)
1493}
1494
1495func (fake *FakePipeline) GetBuildsWithVersionAsOutputCalls(stub func(int, int) ([]db.Build, error)) {
1496	fake.getBuildsWithVersionAsOutputMutex.Lock()
1497	defer fake.getBuildsWithVersionAsOutputMutex.Unlock()
1498	fake.GetBuildsWithVersionAsOutputStub = stub
1499}
1500
1501func (fake *FakePipeline) GetBuildsWithVersionAsOutputArgsForCall(i int) (int, int) {
1502	fake.getBuildsWithVersionAsOutputMutex.RLock()
1503	defer fake.getBuildsWithVersionAsOutputMutex.RUnlock()
1504	argsForCall := fake.getBuildsWithVersionAsOutputArgsForCall[i]
1505	return argsForCall.arg1, argsForCall.arg2
1506}
1507
1508func (fake *FakePipeline) GetBuildsWithVersionAsOutputReturns(result1 []db.Build, result2 error) {
1509	fake.getBuildsWithVersionAsOutputMutex.Lock()
1510	defer fake.getBuildsWithVersionAsOutputMutex.Unlock()
1511	fake.GetBuildsWithVersionAsOutputStub = nil
1512	fake.getBuildsWithVersionAsOutputReturns = struct {
1513		result1 []db.Build
1514		result2 error
1515	}{result1, result2}
1516}
1517
1518func (fake *FakePipeline) GetBuildsWithVersionAsOutputReturnsOnCall(i int, result1 []db.Build, result2 error) {
1519	fake.getBuildsWithVersionAsOutputMutex.Lock()
1520	defer fake.getBuildsWithVersionAsOutputMutex.Unlock()
1521	fake.GetBuildsWithVersionAsOutputStub = nil
1522	if fake.getBuildsWithVersionAsOutputReturnsOnCall == nil {
1523		fake.getBuildsWithVersionAsOutputReturnsOnCall = make(map[int]struct {
1524			result1 []db.Build
1525			result2 error
1526		})
1527	}
1528	fake.getBuildsWithVersionAsOutputReturnsOnCall[i] = struct {
1529		result1 []db.Build
1530		result2 error
1531	}{result1, result2}
1532}
1533
1534func (fake *FakePipeline) Groups() atc.GroupConfigs {
1535	fake.groupsMutex.Lock()
1536	ret, specificReturn := fake.groupsReturnsOnCall[len(fake.groupsArgsForCall)]
1537	fake.groupsArgsForCall = append(fake.groupsArgsForCall, struct {
1538	}{})
1539	fake.recordInvocation("Groups", []interface{}{})
1540	fake.groupsMutex.Unlock()
1541	if fake.GroupsStub != nil {
1542		return fake.GroupsStub()
1543	}
1544	if specificReturn {
1545		return ret.result1
1546	}
1547	fakeReturns := fake.groupsReturns
1548	return fakeReturns.result1
1549}
1550
1551func (fake *FakePipeline) GroupsCallCount() int {
1552	fake.groupsMutex.RLock()
1553	defer fake.groupsMutex.RUnlock()
1554	return len(fake.groupsArgsForCall)
1555}
1556
1557func (fake *FakePipeline) GroupsCalls(stub func() atc.GroupConfigs) {
1558	fake.groupsMutex.Lock()
1559	defer fake.groupsMutex.Unlock()
1560	fake.GroupsStub = stub
1561}
1562
1563func (fake *FakePipeline) GroupsReturns(result1 atc.GroupConfigs) {
1564	fake.groupsMutex.Lock()
1565	defer fake.groupsMutex.Unlock()
1566	fake.GroupsStub = nil
1567	fake.groupsReturns = struct {
1568		result1 atc.GroupConfigs
1569	}{result1}
1570}
1571
1572func (fake *FakePipeline) GroupsReturnsOnCall(i int, result1 atc.GroupConfigs) {
1573	fake.groupsMutex.Lock()
1574	defer fake.groupsMutex.Unlock()
1575	fake.GroupsStub = nil
1576	if fake.groupsReturnsOnCall == nil {
1577		fake.groupsReturnsOnCall = make(map[int]struct {
1578			result1 atc.GroupConfigs
1579		})
1580	}
1581	fake.groupsReturnsOnCall[i] = struct {
1582		result1 atc.GroupConfigs
1583	}{result1}
1584}
1585
1586func (fake *FakePipeline) Hide() error {
1587	fake.hideMutex.Lock()
1588	ret, specificReturn := fake.hideReturnsOnCall[len(fake.hideArgsForCall)]
1589	fake.hideArgsForCall = append(fake.hideArgsForCall, struct {
1590	}{})
1591	fake.recordInvocation("Hide", []interface{}{})
1592	fake.hideMutex.Unlock()
1593	if fake.HideStub != nil {
1594		return fake.HideStub()
1595	}
1596	if specificReturn {
1597		return ret.result1
1598	}
1599	fakeReturns := fake.hideReturns
1600	return fakeReturns.result1
1601}
1602
1603func (fake *FakePipeline) HideCallCount() int {
1604	fake.hideMutex.RLock()
1605	defer fake.hideMutex.RUnlock()
1606	return len(fake.hideArgsForCall)
1607}
1608
1609func (fake *FakePipeline) HideCalls(stub func() error) {
1610	fake.hideMutex.Lock()
1611	defer fake.hideMutex.Unlock()
1612	fake.HideStub = stub
1613}
1614
1615func (fake *FakePipeline) HideReturns(result1 error) {
1616	fake.hideMutex.Lock()
1617	defer fake.hideMutex.Unlock()
1618	fake.HideStub = nil
1619	fake.hideReturns = struct {
1620		result1 error
1621	}{result1}
1622}
1623
1624func (fake *FakePipeline) HideReturnsOnCall(i int, result1 error) {
1625	fake.hideMutex.Lock()
1626	defer fake.hideMutex.Unlock()
1627	fake.HideStub = nil
1628	if fake.hideReturnsOnCall == nil {
1629		fake.hideReturnsOnCall = make(map[int]struct {
1630			result1 error
1631		})
1632	}
1633	fake.hideReturnsOnCall[i] = struct {
1634		result1 error
1635	}{result1}
1636}
1637
1638func (fake *FakePipeline) ID() int {
1639	fake.iDMutex.Lock()
1640	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
1641	fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
1642	}{})
1643	fake.recordInvocation("ID", []interface{}{})
1644	fake.iDMutex.Unlock()
1645	if fake.IDStub != nil {
1646		return fake.IDStub()
1647	}
1648	if specificReturn {
1649		return ret.result1
1650	}
1651	fakeReturns := fake.iDReturns
1652	return fakeReturns.result1
1653}
1654
1655func (fake *FakePipeline) IDCallCount() int {
1656	fake.iDMutex.RLock()
1657	defer fake.iDMutex.RUnlock()
1658	return len(fake.iDArgsForCall)
1659}
1660
1661func (fake *FakePipeline) IDCalls(stub func() int) {
1662	fake.iDMutex.Lock()
1663	defer fake.iDMutex.Unlock()
1664	fake.IDStub = stub
1665}
1666
1667func (fake *FakePipeline) IDReturns(result1 int) {
1668	fake.iDMutex.Lock()
1669	defer fake.iDMutex.Unlock()
1670	fake.IDStub = nil
1671	fake.iDReturns = struct {
1672		result1 int
1673	}{result1}
1674}
1675
1676func (fake *FakePipeline) IDReturnsOnCall(i int, result1 int) {
1677	fake.iDMutex.Lock()
1678	defer fake.iDMutex.Unlock()
1679	fake.IDStub = nil
1680	if fake.iDReturnsOnCall == nil {
1681		fake.iDReturnsOnCall = make(map[int]struct {
1682			result1 int
1683		})
1684	}
1685	fake.iDReturnsOnCall[i] = struct {
1686		result1 int
1687	}{result1}
1688}
1689
1690func (fake *FakePipeline) Job(arg1 string) (db.Job, bool, error) {
1691	fake.jobMutex.Lock()
1692	ret, specificReturn := fake.jobReturnsOnCall[len(fake.jobArgsForCall)]
1693	fake.jobArgsForCall = append(fake.jobArgsForCall, struct {
1694		arg1 string
1695	}{arg1})
1696	fake.recordInvocation("Job", []interface{}{arg1})
1697	fake.jobMutex.Unlock()
1698	if fake.JobStub != nil {
1699		return fake.JobStub(arg1)
1700	}
1701	if specificReturn {
1702		return ret.result1, ret.result2, ret.result3
1703	}
1704	fakeReturns := fake.jobReturns
1705	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
1706}
1707
1708func (fake *FakePipeline) JobCallCount() int {
1709	fake.jobMutex.RLock()
1710	defer fake.jobMutex.RUnlock()
1711	return len(fake.jobArgsForCall)
1712}
1713
1714func (fake *FakePipeline) JobCalls(stub func(string) (db.Job, bool, error)) {
1715	fake.jobMutex.Lock()
1716	defer fake.jobMutex.Unlock()
1717	fake.JobStub = stub
1718}
1719
1720func (fake *FakePipeline) JobArgsForCall(i int) string {
1721	fake.jobMutex.RLock()
1722	defer fake.jobMutex.RUnlock()
1723	argsForCall := fake.jobArgsForCall[i]
1724	return argsForCall.arg1
1725}
1726
1727func (fake *FakePipeline) JobReturns(result1 db.Job, result2 bool, result3 error) {
1728	fake.jobMutex.Lock()
1729	defer fake.jobMutex.Unlock()
1730	fake.JobStub = nil
1731	fake.jobReturns = struct {
1732		result1 db.Job
1733		result2 bool
1734		result3 error
1735	}{result1, result2, result3}
1736}
1737
1738func (fake *FakePipeline) JobReturnsOnCall(i int, result1 db.Job, result2 bool, result3 error) {
1739	fake.jobMutex.Lock()
1740	defer fake.jobMutex.Unlock()
1741	fake.JobStub = nil
1742	if fake.jobReturnsOnCall == nil {
1743		fake.jobReturnsOnCall = make(map[int]struct {
1744			result1 db.Job
1745			result2 bool
1746			result3 error
1747		})
1748	}
1749	fake.jobReturnsOnCall[i] = struct {
1750		result1 db.Job
1751		result2 bool
1752		result3 error
1753	}{result1, result2, result3}
1754}
1755
1756func (fake *FakePipeline) Jobs() (db.Jobs, error) {
1757	fake.jobsMutex.Lock()
1758	ret, specificReturn := fake.jobsReturnsOnCall[len(fake.jobsArgsForCall)]
1759	fake.jobsArgsForCall = append(fake.jobsArgsForCall, struct {
1760	}{})
1761	fake.recordInvocation("Jobs", []interface{}{})
1762	fake.jobsMutex.Unlock()
1763	if fake.JobsStub != nil {
1764		return fake.JobsStub()
1765	}
1766	if specificReturn {
1767		return ret.result1, ret.result2
1768	}
1769	fakeReturns := fake.jobsReturns
1770	return fakeReturns.result1, fakeReturns.result2
1771}
1772
1773func (fake *FakePipeline) JobsCallCount() int {
1774	fake.jobsMutex.RLock()
1775	defer fake.jobsMutex.RUnlock()
1776	return len(fake.jobsArgsForCall)
1777}
1778
1779func (fake *FakePipeline) JobsCalls(stub func() (db.Jobs, error)) {
1780	fake.jobsMutex.Lock()
1781	defer fake.jobsMutex.Unlock()
1782	fake.JobsStub = stub
1783}
1784
1785func (fake *FakePipeline) JobsReturns(result1 db.Jobs, result2 error) {
1786	fake.jobsMutex.Lock()
1787	defer fake.jobsMutex.Unlock()
1788	fake.JobsStub = nil
1789	fake.jobsReturns = struct {
1790		result1 db.Jobs
1791		result2 error
1792	}{result1, result2}
1793}
1794
1795func (fake *FakePipeline) JobsReturnsOnCall(i int, result1 db.Jobs, result2 error) {
1796	fake.jobsMutex.Lock()
1797	defer fake.jobsMutex.Unlock()
1798	fake.JobsStub = nil
1799	if fake.jobsReturnsOnCall == nil {
1800		fake.jobsReturnsOnCall = make(map[int]struct {
1801			result1 db.Jobs
1802			result2 error
1803		})
1804	}
1805	fake.jobsReturnsOnCall[i] = struct {
1806		result1 db.Jobs
1807		result2 error
1808	}{result1, result2}
1809}
1810
1811func (fake *FakePipeline) LastUpdated() time.Time {
1812	fake.lastUpdatedMutex.Lock()
1813	ret, specificReturn := fake.lastUpdatedReturnsOnCall[len(fake.lastUpdatedArgsForCall)]
1814	fake.lastUpdatedArgsForCall = append(fake.lastUpdatedArgsForCall, struct {
1815	}{})
1816	fake.recordInvocation("LastUpdated", []interface{}{})
1817	fake.lastUpdatedMutex.Unlock()
1818	if fake.LastUpdatedStub != nil {
1819		return fake.LastUpdatedStub()
1820	}
1821	if specificReturn {
1822		return ret.result1
1823	}
1824	fakeReturns := fake.lastUpdatedReturns
1825	return fakeReturns.result1
1826}
1827
1828func (fake *FakePipeline) LastUpdatedCallCount() int {
1829	fake.lastUpdatedMutex.RLock()
1830	defer fake.lastUpdatedMutex.RUnlock()
1831	return len(fake.lastUpdatedArgsForCall)
1832}
1833
1834func (fake *FakePipeline) LastUpdatedCalls(stub func() time.Time) {
1835	fake.lastUpdatedMutex.Lock()
1836	defer fake.lastUpdatedMutex.Unlock()
1837	fake.LastUpdatedStub = stub
1838}
1839
1840func (fake *FakePipeline) LastUpdatedReturns(result1 time.Time) {
1841	fake.lastUpdatedMutex.Lock()
1842	defer fake.lastUpdatedMutex.Unlock()
1843	fake.LastUpdatedStub = nil
1844	fake.lastUpdatedReturns = struct {
1845		result1 time.Time
1846	}{result1}
1847}
1848
1849func (fake *FakePipeline) LastUpdatedReturnsOnCall(i int, result1 time.Time) {
1850	fake.lastUpdatedMutex.Lock()
1851	defer fake.lastUpdatedMutex.Unlock()
1852	fake.LastUpdatedStub = nil
1853	if fake.lastUpdatedReturnsOnCall == nil {
1854		fake.lastUpdatedReturnsOnCall = make(map[int]struct {
1855			result1 time.Time
1856		})
1857	}
1858	fake.lastUpdatedReturnsOnCall[i] = struct {
1859		result1 time.Time
1860	}{result1}
1861}
1862
1863func (fake *FakePipeline) LoadDebugVersionsDB() (*atc.DebugVersionsDB, error) {
1864	fake.loadDebugVersionsDBMutex.Lock()
1865	ret, specificReturn := fake.loadDebugVersionsDBReturnsOnCall[len(fake.loadDebugVersionsDBArgsForCall)]
1866	fake.loadDebugVersionsDBArgsForCall = append(fake.loadDebugVersionsDBArgsForCall, struct {
1867	}{})
1868	fake.recordInvocation("LoadDebugVersionsDB", []interface{}{})
1869	fake.loadDebugVersionsDBMutex.Unlock()
1870	if fake.LoadDebugVersionsDBStub != nil {
1871		return fake.LoadDebugVersionsDBStub()
1872	}
1873	if specificReturn {
1874		return ret.result1, ret.result2
1875	}
1876	fakeReturns := fake.loadDebugVersionsDBReturns
1877	return fakeReturns.result1, fakeReturns.result2
1878}
1879
1880func (fake *FakePipeline) LoadDebugVersionsDBCallCount() int {
1881	fake.loadDebugVersionsDBMutex.RLock()
1882	defer fake.loadDebugVersionsDBMutex.RUnlock()
1883	return len(fake.loadDebugVersionsDBArgsForCall)
1884}
1885
1886func (fake *FakePipeline) LoadDebugVersionsDBCalls(stub func() (*atc.DebugVersionsDB, error)) {
1887	fake.loadDebugVersionsDBMutex.Lock()
1888	defer fake.loadDebugVersionsDBMutex.Unlock()
1889	fake.LoadDebugVersionsDBStub = stub
1890}
1891
1892func (fake *FakePipeline) LoadDebugVersionsDBReturns(result1 *atc.DebugVersionsDB, result2 error) {
1893	fake.loadDebugVersionsDBMutex.Lock()
1894	defer fake.loadDebugVersionsDBMutex.Unlock()
1895	fake.LoadDebugVersionsDBStub = nil
1896	fake.loadDebugVersionsDBReturns = struct {
1897		result1 *atc.DebugVersionsDB
1898		result2 error
1899	}{result1, result2}
1900}
1901
1902func (fake *FakePipeline) LoadDebugVersionsDBReturnsOnCall(i int, result1 *atc.DebugVersionsDB, result2 error) {
1903	fake.loadDebugVersionsDBMutex.Lock()
1904	defer fake.loadDebugVersionsDBMutex.Unlock()
1905	fake.LoadDebugVersionsDBStub = nil
1906	if fake.loadDebugVersionsDBReturnsOnCall == nil {
1907		fake.loadDebugVersionsDBReturnsOnCall = make(map[int]struct {
1908			result1 *atc.DebugVersionsDB
1909			result2 error
1910		})
1911	}
1912	fake.loadDebugVersionsDBReturnsOnCall[i] = struct {
1913		result1 *atc.DebugVersionsDB
1914		result2 error
1915	}{result1, result2}
1916}
1917
1918func (fake *FakePipeline) Name() string {
1919	fake.nameMutex.Lock()
1920	ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)]
1921	fake.nameArgsForCall = append(fake.nameArgsForCall, struct {
1922	}{})
1923	fake.recordInvocation("Name", []interface{}{})
1924	fake.nameMutex.Unlock()
1925	if fake.NameStub != nil {
1926		return fake.NameStub()
1927	}
1928	if specificReturn {
1929		return ret.result1
1930	}
1931	fakeReturns := fake.nameReturns
1932	return fakeReturns.result1
1933}
1934
1935func (fake *FakePipeline) NameCallCount() int {
1936	fake.nameMutex.RLock()
1937	defer fake.nameMutex.RUnlock()
1938	return len(fake.nameArgsForCall)
1939}
1940
1941func (fake *FakePipeline) NameCalls(stub func() string) {
1942	fake.nameMutex.Lock()
1943	defer fake.nameMutex.Unlock()
1944	fake.NameStub = stub
1945}
1946
1947func (fake *FakePipeline) NameReturns(result1 string) {
1948	fake.nameMutex.Lock()
1949	defer fake.nameMutex.Unlock()
1950	fake.NameStub = nil
1951	fake.nameReturns = struct {
1952		result1 string
1953	}{result1}
1954}
1955
1956func (fake *FakePipeline) NameReturnsOnCall(i int, result1 string) {
1957	fake.nameMutex.Lock()
1958	defer fake.nameMutex.Unlock()
1959	fake.NameStub = nil
1960	if fake.nameReturnsOnCall == nil {
1961		fake.nameReturnsOnCall = make(map[int]struct {
1962			result1 string
1963		})
1964	}
1965	fake.nameReturnsOnCall[i] = struct {
1966		result1 string
1967	}{result1}
1968}
1969
1970func (fake *FakePipeline) ParentBuildID() int {
1971	fake.parentBuildIDMutex.Lock()
1972	ret, specificReturn := fake.parentBuildIDReturnsOnCall[len(fake.parentBuildIDArgsForCall)]
1973	fake.parentBuildIDArgsForCall = append(fake.parentBuildIDArgsForCall, struct {
1974	}{})
1975	fake.recordInvocation("ParentBuildID", []interface{}{})
1976	fake.parentBuildIDMutex.Unlock()
1977	if fake.ParentBuildIDStub != nil {
1978		return fake.ParentBuildIDStub()
1979	}
1980	if specificReturn {
1981		return ret.result1
1982	}
1983	fakeReturns := fake.parentBuildIDReturns
1984	return fakeReturns.result1
1985}
1986
1987func (fake *FakePipeline) ParentBuildIDCallCount() int {
1988	fake.parentBuildIDMutex.RLock()
1989	defer fake.parentBuildIDMutex.RUnlock()
1990	return len(fake.parentBuildIDArgsForCall)
1991}
1992
1993func (fake *FakePipeline) ParentBuildIDCalls(stub func() int) {
1994	fake.parentBuildIDMutex.Lock()
1995	defer fake.parentBuildIDMutex.Unlock()
1996	fake.ParentBuildIDStub = stub
1997}
1998
1999func (fake *FakePipeline) ParentBuildIDReturns(result1 int) {
2000	fake.parentBuildIDMutex.Lock()
2001	defer fake.parentBuildIDMutex.Unlock()
2002	fake.ParentBuildIDStub = nil
2003	fake.parentBuildIDReturns = struct {
2004		result1 int
2005	}{result1}
2006}
2007
2008func (fake *FakePipeline) ParentBuildIDReturnsOnCall(i int, result1 int) {
2009	fake.parentBuildIDMutex.Lock()
2010	defer fake.parentBuildIDMutex.Unlock()
2011	fake.ParentBuildIDStub = nil
2012	if fake.parentBuildIDReturnsOnCall == nil {
2013		fake.parentBuildIDReturnsOnCall = make(map[int]struct {
2014			result1 int
2015		})
2016	}
2017	fake.parentBuildIDReturnsOnCall[i] = struct {
2018		result1 int
2019	}{result1}
2020}
2021
2022func (fake *FakePipeline) ParentJobID() int {
2023	fake.parentJobIDMutex.Lock()
2024	ret, specificReturn := fake.parentJobIDReturnsOnCall[len(fake.parentJobIDArgsForCall)]
2025	fake.parentJobIDArgsForCall = append(fake.parentJobIDArgsForCall, struct {
2026	}{})
2027	fake.recordInvocation("ParentJobID", []interface{}{})
2028	fake.parentJobIDMutex.Unlock()
2029	if fake.ParentJobIDStub != nil {
2030		return fake.ParentJobIDStub()
2031	}
2032	if specificReturn {
2033		return ret.result1
2034	}
2035	fakeReturns := fake.parentJobIDReturns
2036	return fakeReturns.result1
2037}
2038
2039func (fake *FakePipeline) ParentJobIDCallCount() int {
2040	fake.parentJobIDMutex.RLock()
2041	defer fake.parentJobIDMutex.RUnlock()
2042	return len(fake.parentJobIDArgsForCall)
2043}
2044
2045func (fake *FakePipeline) ParentJobIDCalls(stub func() int) {
2046	fake.parentJobIDMutex.Lock()
2047	defer fake.parentJobIDMutex.Unlock()
2048	fake.ParentJobIDStub = stub
2049}
2050
2051func (fake *FakePipeline) ParentJobIDReturns(result1 int) {
2052	fake.parentJobIDMutex.Lock()
2053	defer fake.parentJobIDMutex.Unlock()
2054	fake.ParentJobIDStub = nil
2055	fake.parentJobIDReturns = struct {
2056		result1 int
2057	}{result1}
2058}
2059
2060func (fake *FakePipeline) ParentJobIDReturnsOnCall(i int, result1 int) {
2061	fake.parentJobIDMutex.Lock()
2062	defer fake.parentJobIDMutex.Unlock()
2063	fake.ParentJobIDStub = nil
2064	if fake.parentJobIDReturnsOnCall == nil {
2065		fake.parentJobIDReturnsOnCall = make(map[int]struct {
2066			result1 int
2067		})
2068	}
2069	fake.parentJobIDReturnsOnCall[i] = struct {
2070		result1 int
2071	}{result1}
2072}
2073
2074func (fake *FakePipeline) Pause() error {
2075	fake.pauseMutex.Lock()
2076	ret, specificReturn := fake.pauseReturnsOnCall[len(fake.pauseArgsForCall)]
2077	fake.pauseArgsForCall = append(fake.pauseArgsForCall, struct {
2078	}{})
2079	fake.recordInvocation("Pause", []interface{}{})
2080	fake.pauseMutex.Unlock()
2081	if fake.PauseStub != nil {
2082		return fake.PauseStub()
2083	}
2084	if specificReturn {
2085		return ret.result1
2086	}
2087	fakeReturns := fake.pauseReturns
2088	return fakeReturns.result1
2089}
2090
2091func (fake *FakePipeline) PauseCallCount() int {
2092	fake.pauseMutex.RLock()
2093	defer fake.pauseMutex.RUnlock()
2094	return len(fake.pauseArgsForCall)
2095}
2096
2097func (fake *FakePipeline) PauseCalls(stub func() error) {
2098	fake.pauseMutex.Lock()
2099	defer fake.pauseMutex.Unlock()
2100	fake.PauseStub = stub
2101}
2102
2103func (fake *FakePipeline) PauseReturns(result1 error) {
2104	fake.pauseMutex.Lock()
2105	defer fake.pauseMutex.Unlock()
2106	fake.PauseStub = nil
2107	fake.pauseReturns = struct {
2108		result1 error
2109	}{result1}
2110}
2111
2112func (fake *FakePipeline) PauseReturnsOnCall(i int, result1 error) {
2113	fake.pauseMutex.Lock()
2114	defer fake.pauseMutex.Unlock()
2115	fake.PauseStub = nil
2116	if fake.pauseReturnsOnCall == nil {
2117		fake.pauseReturnsOnCall = make(map[int]struct {
2118			result1 error
2119		})
2120	}
2121	fake.pauseReturnsOnCall[i] = struct {
2122		result1 error
2123	}{result1}
2124}
2125
2126func (fake *FakePipeline) Paused() bool {
2127	fake.pausedMutex.Lock()
2128	ret, specificReturn := fake.pausedReturnsOnCall[len(fake.pausedArgsForCall)]
2129	fake.pausedArgsForCall = append(fake.pausedArgsForCall, struct {
2130	}{})
2131	fake.recordInvocation("Paused", []interface{}{})
2132	fake.pausedMutex.Unlock()
2133	if fake.PausedStub != nil {
2134		return fake.PausedStub()
2135	}
2136	if specificReturn {
2137		return ret.result1
2138	}
2139	fakeReturns := fake.pausedReturns
2140	return fakeReturns.result1
2141}
2142
2143func (fake *FakePipeline) PausedCallCount() int {
2144	fake.pausedMutex.RLock()
2145	defer fake.pausedMutex.RUnlock()
2146	return len(fake.pausedArgsForCall)
2147}
2148
2149func (fake *FakePipeline) PausedCalls(stub func() bool) {
2150	fake.pausedMutex.Lock()
2151	defer fake.pausedMutex.Unlock()
2152	fake.PausedStub = stub
2153}
2154
2155func (fake *FakePipeline) PausedReturns(result1 bool) {
2156	fake.pausedMutex.Lock()
2157	defer fake.pausedMutex.Unlock()
2158	fake.PausedStub = nil
2159	fake.pausedReturns = struct {
2160		result1 bool
2161	}{result1}
2162}
2163
2164func (fake *FakePipeline) PausedReturnsOnCall(i int, result1 bool) {
2165	fake.pausedMutex.Lock()
2166	defer fake.pausedMutex.Unlock()
2167	fake.PausedStub = nil
2168	if fake.pausedReturnsOnCall == nil {
2169		fake.pausedReturnsOnCall = make(map[int]struct {
2170			result1 bool
2171		})
2172	}
2173	fake.pausedReturnsOnCall[i] = struct {
2174		result1 bool
2175	}{result1}
2176}
2177
2178func (fake *FakePipeline) Public() bool {
2179	fake.publicMutex.Lock()
2180	ret, specificReturn := fake.publicReturnsOnCall[len(fake.publicArgsForCall)]
2181	fake.publicArgsForCall = append(fake.publicArgsForCall, struct {
2182	}{})
2183	fake.recordInvocation("Public", []interface{}{})
2184	fake.publicMutex.Unlock()
2185	if fake.PublicStub != nil {
2186		return fake.PublicStub()
2187	}
2188	if specificReturn {
2189		return ret.result1
2190	}
2191	fakeReturns := fake.publicReturns
2192	return fakeReturns.result1
2193}
2194
2195func (fake *FakePipeline) PublicCallCount() int {
2196	fake.publicMutex.RLock()
2197	defer fake.publicMutex.RUnlock()
2198	return len(fake.publicArgsForCall)
2199}
2200
2201func (fake *FakePipeline) PublicCalls(stub func() bool) {
2202	fake.publicMutex.Lock()
2203	defer fake.publicMutex.Unlock()
2204	fake.PublicStub = stub
2205}
2206
2207func (fake *FakePipeline) PublicReturns(result1 bool) {
2208	fake.publicMutex.Lock()
2209	defer fake.publicMutex.Unlock()
2210	fake.PublicStub = nil
2211	fake.publicReturns = struct {
2212		result1 bool
2213	}{result1}
2214}
2215
2216func (fake *FakePipeline) PublicReturnsOnCall(i int, result1 bool) {
2217	fake.publicMutex.Lock()
2218	defer fake.publicMutex.Unlock()
2219	fake.PublicStub = nil
2220	if fake.publicReturnsOnCall == nil {
2221		fake.publicReturnsOnCall = make(map[int]struct {
2222			result1 bool
2223		})
2224	}
2225	fake.publicReturnsOnCall[i] = struct {
2226		result1 bool
2227	}{result1}
2228}
2229
2230func (fake *FakePipeline) Reload() (bool, error) {
2231	fake.reloadMutex.Lock()
2232	ret, specificReturn := fake.reloadReturnsOnCall[len(fake.reloadArgsForCall)]
2233	fake.reloadArgsForCall = append(fake.reloadArgsForCall, struct {
2234	}{})
2235	fake.recordInvocation("Reload", []interface{}{})
2236	fake.reloadMutex.Unlock()
2237	if fake.ReloadStub != nil {
2238		return fake.ReloadStub()
2239	}
2240	if specificReturn {
2241		return ret.result1, ret.result2
2242	}
2243	fakeReturns := fake.reloadReturns
2244	return fakeReturns.result1, fakeReturns.result2
2245}
2246
2247func (fake *FakePipeline) ReloadCallCount() int {
2248	fake.reloadMutex.RLock()
2249	defer fake.reloadMutex.RUnlock()
2250	return len(fake.reloadArgsForCall)
2251}
2252
2253func (fake *FakePipeline) ReloadCalls(stub func() (bool, error)) {
2254	fake.reloadMutex.Lock()
2255	defer fake.reloadMutex.Unlock()
2256	fake.ReloadStub = stub
2257}
2258
2259func (fake *FakePipeline) ReloadReturns(result1 bool, result2 error) {
2260	fake.reloadMutex.Lock()
2261	defer fake.reloadMutex.Unlock()
2262	fake.ReloadStub = nil
2263	fake.reloadReturns = struct {
2264		result1 bool
2265		result2 error
2266	}{result1, result2}
2267}
2268
2269func (fake *FakePipeline) ReloadReturnsOnCall(i int, result1 bool, result2 error) {
2270	fake.reloadMutex.Lock()
2271	defer fake.reloadMutex.Unlock()
2272	fake.ReloadStub = nil
2273	if fake.reloadReturnsOnCall == nil {
2274		fake.reloadReturnsOnCall = make(map[int]struct {
2275			result1 bool
2276			result2 error
2277		})
2278	}
2279	fake.reloadReturnsOnCall[i] = struct {
2280		result1 bool
2281		result2 error
2282	}{result1, result2}
2283}
2284
2285func (fake *FakePipeline) Rename(arg1 string) error {
2286	fake.renameMutex.Lock()
2287	ret, specificReturn := fake.renameReturnsOnCall[len(fake.renameArgsForCall)]
2288	fake.renameArgsForCall = append(fake.renameArgsForCall, struct {
2289		arg1 string
2290	}{arg1})
2291	fake.recordInvocation("Rename", []interface{}{arg1})
2292	fake.renameMutex.Unlock()
2293	if fake.RenameStub != nil {
2294		return fake.RenameStub(arg1)
2295	}
2296	if specificReturn {
2297		return ret.result1
2298	}
2299	fakeReturns := fake.renameReturns
2300	return fakeReturns.result1
2301}
2302
2303func (fake *FakePipeline) RenameCallCount() int {
2304	fake.renameMutex.RLock()
2305	defer fake.renameMutex.RUnlock()
2306	return len(fake.renameArgsForCall)
2307}
2308
2309func (fake *FakePipeline) RenameCalls(stub func(string) error) {
2310	fake.renameMutex.Lock()
2311	defer fake.renameMutex.Unlock()
2312	fake.RenameStub = stub
2313}
2314
2315func (fake *FakePipeline) RenameArgsForCall(i int) string {
2316	fake.renameMutex.RLock()
2317	defer fake.renameMutex.RUnlock()
2318	argsForCall := fake.renameArgsForCall[i]
2319	return argsForCall.arg1
2320}
2321
2322func (fake *FakePipeline) RenameReturns(result1 error) {
2323	fake.renameMutex.Lock()
2324	defer fake.renameMutex.Unlock()
2325	fake.RenameStub = nil
2326	fake.renameReturns = struct {
2327		result1 error
2328	}{result1}
2329}
2330
2331func (fake *FakePipeline) RenameReturnsOnCall(i int, result1 error) {
2332	fake.renameMutex.Lock()
2333	defer fake.renameMutex.Unlock()
2334	fake.RenameStub = nil
2335	if fake.renameReturnsOnCall == nil {
2336		fake.renameReturnsOnCall = make(map[int]struct {
2337			result1 error
2338		})
2339	}
2340	fake.renameReturnsOnCall[i] = struct {
2341		result1 error
2342	}{result1}
2343}
2344
2345func (fake *FakePipeline) Resource(arg1 string) (db.Resource, bool, error) {
2346	fake.resourceMutex.Lock()
2347	ret, specificReturn := fake.resourceReturnsOnCall[len(fake.resourceArgsForCall)]
2348	fake.resourceArgsForCall = append(fake.resourceArgsForCall, struct {
2349		arg1 string
2350	}{arg1})
2351	fake.recordInvocation("Resource", []interface{}{arg1})
2352	fake.resourceMutex.Unlock()
2353	if fake.ResourceStub != nil {
2354		return fake.ResourceStub(arg1)
2355	}
2356	if specificReturn {
2357		return ret.result1, ret.result2, ret.result3
2358	}
2359	fakeReturns := fake.resourceReturns
2360	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
2361}
2362
2363func (fake *FakePipeline) ResourceCallCount() int {
2364	fake.resourceMutex.RLock()
2365	defer fake.resourceMutex.RUnlock()
2366	return len(fake.resourceArgsForCall)
2367}
2368
2369func (fake *FakePipeline) ResourceCalls(stub func(string) (db.Resource, bool, error)) {
2370	fake.resourceMutex.Lock()
2371	defer fake.resourceMutex.Unlock()
2372	fake.ResourceStub = stub
2373}
2374
2375func (fake *FakePipeline) ResourceArgsForCall(i int) string {
2376	fake.resourceMutex.RLock()
2377	defer fake.resourceMutex.RUnlock()
2378	argsForCall := fake.resourceArgsForCall[i]
2379	return argsForCall.arg1
2380}
2381
2382func (fake *FakePipeline) ResourceReturns(result1 db.Resource, result2 bool, result3 error) {
2383	fake.resourceMutex.Lock()
2384	defer fake.resourceMutex.Unlock()
2385	fake.ResourceStub = nil
2386	fake.resourceReturns = struct {
2387		result1 db.Resource
2388		result2 bool
2389		result3 error
2390	}{result1, result2, result3}
2391}
2392
2393func (fake *FakePipeline) ResourceReturnsOnCall(i int, result1 db.Resource, result2 bool, result3 error) {
2394	fake.resourceMutex.Lock()
2395	defer fake.resourceMutex.Unlock()
2396	fake.ResourceStub = nil
2397	if fake.resourceReturnsOnCall == nil {
2398		fake.resourceReturnsOnCall = make(map[int]struct {
2399			result1 db.Resource
2400			result2 bool
2401			result3 error
2402		})
2403	}
2404	fake.resourceReturnsOnCall[i] = struct {
2405		result1 db.Resource
2406		result2 bool
2407		result3 error
2408	}{result1, result2, result3}
2409}
2410
2411func (fake *FakePipeline) ResourceByID(arg1 int) (db.Resource, bool, error) {
2412	fake.resourceByIDMutex.Lock()
2413	ret, specificReturn := fake.resourceByIDReturnsOnCall[len(fake.resourceByIDArgsForCall)]
2414	fake.resourceByIDArgsForCall = append(fake.resourceByIDArgsForCall, struct {
2415		arg1 int
2416	}{arg1})
2417	fake.recordInvocation("ResourceByID", []interface{}{arg1})
2418	fake.resourceByIDMutex.Unlock()
2419	if fake.ResourceByIDStub != nil {
2420		return fake.ResourceByIDStub(arg1)
2421	}
2422	if specificReturn {
2423		return ret.result1, ret.result2, ret.result3
2424	}
2425	fakeReturns := fake.resourceByIDReturns
2426	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
2427}
2428
2429func (fake *FakePipeline) ResourceByIDCallCount() int {
2430	fake.resourceByIDMutex.RLock()
2431	defer fake.resourceByIDMutex.RUnlock()
2432	return len(fake.resourceByIDArgsForCall)
2433}
2434
2435func (fake *FakePipeline) ResourceByIDCalls(stub func(int) (db.Resource, bool, error)) {
2436	fake.resourceByIDMutex.Lock()
2437	defer fake.resourceByIDMutex.Unlock()
2438	fake.ResourceByIDStub = stub
2439}
2440
2441func (fake *FakePipeline) ResourceByIDArgsForCall(i int) int {
2442	fake.resourceByIDMutex.RLock()
2443	defer fake.resourceByIDMutex.RUnlock()
2444	argsForCall := fake.resourceByIDArgsForCall[i]
2445	return argsForCall.arg1
2446}
2447
2448func (fake *FakePipeline) ResourceByIDReturns(result1 db.Resource, result2 bool, result3 error) {
2449	fake.resourceByIDMutex.Lock()
2450	defer fake.resourceByIDMutex.Unlock()
2451	fake.ResourceByIDStub = nil
2452	fake.resourceByIDReturns = struct {
2453		result1 db.Resource
2454		result2 bool
2455		result3 error
2456	}{result1, result2, result3}
2457}
2458
2459func (fake *FakePipeline) ResourceByIDReturnsOnCall(i int, result1 db.Resource, result2 bool, result3 error) {
2460	fake.resourceByIDMutex.Lock()
2461	defer fake.resourceByIDMutex.Unlock()
2462	fake.ResourceByIDStub = nil
2463	if fake.resourceByIDReturnsOnCall == nil {
2464		fake.resourceByIDReturnsOnCall = make(map[int]struct {
2465			result1 db.Resource
2466			result2 bool
2467			result3 error
2468		})
2469	}
2470	fake.resourceByIDReturnsOnCall[i] = struct {
2471		result1 db.Resource
2472		result2 bool
2473		result3 error
2474	}{result1, result2, result3}
2475}
2476
2477func (fake *FakePipeline) ResourceType(arg1 string) (db.ResourceType, bool, error) {
2478	fake.resourceTypeMutex.Lock()
2479	ret, specificReturn := fake.resourceTypeReturnsOnCall[len(fake.resourceTypeArgsForCall)]
2480	fake.resourceTypeArgsForCall = append(fake.resourceTypeArgsForCall, struct {
2481		arg1 string
2482	}{arg1})
2483	fake.recordInvocation("ResourceType", []interface{}{arg1})
2484	fake.resourceTypeMutex.Unlock()
2485	if fake.ResourceTypeStub != nil {
2486		return fake.ResourceTypeStub(arg1)
2487	}
2488	if specificReturn {
2489		return ret.result1, ret.result2, ret.result3
2490	}
2491	fakeReturns := fake.resourceTypeReturns
2492	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
2493}
2494
2495func (fake *FakePipeline) ResourceTypeCallCount() int {
2496	fake.resourceTypeMutex.RLock()
2497	defer fake.resourceTypeMutex.RUnlock()
2498	return len(fake.resourceTypeArgsForCall)
2499}
2500
2501func (fake *FakePipeline) ResourceTypeCalls(stub func(string) (db.ResourceType, bool, error)) {
2502	fake.resourceTypeMutex.Lock()
2503	defer fake.resourceTypeMutex.Unlock()
2504	fake.ResourceTypeStub = stub
2505}
2506
2507func (fake *FakePipeline) ResourceTypeArgsForCall(i int) string {
2508	fake.resourceTypeMutex.RLock()
2509	defer fake.resourceTypeMutex.RUnlock()
2510	argsForCall := fake.resourceTypeArgsForCall[i]
2511	return argsForCall.arg1
2512}
2513
2514func (fake *FakePipeline) ResourceTypeReturns(result1 db.ResourceType, result2 bool, result3 error) {
2515	fake.resourceTypeMutex.Lock()
2516	defer fake.resourceTypeMutex.Unlock()
2517	fake.ResourceTypeStub = nil
2518	fake.resourceTypeReturns = struct {
2519		result1 db.ResourceType
2520		result2 bool
2521		result3 error
2522	}{result1, result2, result3}
2523}
2524
2525func (fake *FakePipeline) ResourceTypeReturnsOnCall(i int, result1 db.ResourceType, result2 bool, result3 error) {
2526	fake.resourceTypeMutex.Lock()
2527	defer fake.resourceTypeMutex.Unlock()
2528	fake.ResourceTypeStub = nil
2529	if fake.resourceTypeReturnsOnCall == nil {
2530		fake.resourceTypeReturnsOnCall = make(map[int]struct {
2531			result1 db.ResourceType
2532			result2 bool
2533			result3 error
2534		})
2535	}
2536	fake.resourceTypeReturnsOnCall[i] = struct {
2537		result1 db.ResourceType
2538		result2 bool
2539		result3 error
2540	}{result1, result2, result3}
2541}
2542
2543func (fake *FakePipeline) ResourceTypeByID(arg1 int) (db.ResourceType, bool, error) {
2544	fake.resourceTypeByIDMutex.Lock()
2545	ret, specificReturn := fake.resourceTypeByIDReturnsOnCall[len(fake.resourceTypeByIDArgsForCall)]
2546	fake.resourceTypeByIDArgsForCall = append(fake.resourceTypeByIDArgsForCall, struct {
2547		arg1 int
2548	}{arg1})
2549	fake.recordInvocation("ResourceTypeByID", []interface{}{arg1})
2550	fake.resourceTypeByIDMutex.Unlock()
2551	if fake.ResourceTypeByIDStub != nil {
2552		return fake.ResourceTypeByIDStub(arg1)
2553	}
2554	if specificReturn {
2555		return ret.result1, ret.result2, ret.result3
2556	}
2557	fakeReturns := fake.resourceTypeByIDReturns
2558	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
2559}
2560
2561func (fake *FakePipeline) ResourceTypeByIDCallCount() int {
2562	fake.resourceTypeByIDMutex.RLock()
2563	defer fake.resourceTypeByIDMutex.RUnlock()
2564	return len(fake.resourceTypeByIDArgsForCall)
2565}
2566
2567func (fake *FakePipeline) ResourceTypeByIDCalls(stub func(int) (db.ResourceType, bool, error)) {
2568	fake.resourceTypeByIDMutex.Lock()
2569	defer fake.resourceTypeByIDMutex.Unlock()
2570	fake.ResourceTypeByIDStub = stub
2571}
2572
2573func (fake *FakePipeline) ResourceTypeByIDArgsForCall(i int) int {
2574	fake.resourceTypeByIDMutex.RLock()
2575	defer fake.resourceTypeByIDMutex.RUnlock()
2576	argsForCall := fake.resourceTypeByIDArgsForCall[i]
2577	return argsForCall.arg1
2578}
2579
2580func (fake *FakePipeline) ResourceTypeByIDReturns(result1 db.ResourceType, result2 bool, result3 error) {
2581	fake.resourceTypeByIDMutex.Lock()
2582	defer fake.resourceTypeByIDMutex.Unlock()
2583	fake.ResourceTypeByIDStub = nil
2584	fake.resourceTypeByIDReturns = struct {
2585		result1 db.ResourceType
2586		result2 bool
2587		result3 error
2588	}{result1, result2, result3}
2589}
2590
2591func (fake *FakePipeline) ResourceTypeByIDReturnsOnCall(i int, result1 db.ResourceType, result2 bool, result3 error) {
2592	fake.resourceTypeByIDMutex.Lock()
2593	defer fake.resourceTypeByIDMutex.Unlock()
2594	fake.ResourceTypeByIDStub = nil
2595	if fake.resourceTypeByIDReturnsOnCall == nil {
2596		fake.resourceTypeByIDReturnsOnCall = make(map[int]struct {
2597			result1 db.ResourceType
2598			result2 bool
2599			result3 error
2600		})
2601	}
2602	fake.resourceTypeByIDReturnsOnCall[i] = struct {
2603		result1 db.ResourceType
2604		result2 bool
2605		result3 error
2606	}{result1, result2, result3}
2607}
2608
2609func (fake *FakePipeline) ResourceTypes() (db.ResourceTypes, error) {
2610	fake.resourceTypesMutex.Lock()
2611	ret, specificReturn := fake.resourceTypesReturnsOnCall[len(fake.resourceTypesArgsForCall)]
2612	fake.resourceTypesArgsForCall = append(fake.resourceTypesArgsForCall, struct {
2613	}{})
2614	fake.recordInvocation("ResourceTypes", []interface{}{})
2615	fake.resourceTypesMutex.Unlock()
2616	if fake.ResourceTypesStub != nil {
2617		return fake.ResourceTypesStub()
2618	}
2619	if specificReturn {
2620		return ret.result1, ret.result2
2621	}
2622	fakeReturns := fake.resourceTypesReturns
2623	return fakeReturns.result1, fakeReturns.result2
2624}
2625
2626func (fake *FakePipeline) ResourceTypesCallCount() int {
2627	fake.resourceTypesMutex.RLock()
2628	defer fake.resourceTypesMutex.RUnlock()
2629	return len(fake.resourceTypesArgsForCall)
2630}
2631
2632func (fake *FakePipeline) ResourceTypesCalls(stub func() (db.ResourceTypes, error)) {
2633	fake.resourceTypesMutex.Lock()
2634	defer fake.resourceTypesMutex.Unlock()
2635	fake.ResourceTypesStub = stub
2636}
2637
2638func (fake *FakePipeline) ResourceTypesReturns(result1 db.ResourceTypes, result2 error) {
2639	fake.resourceTypesMutex.Lock()
2640	defer fake.resourceTypesMutex.Unlock()
2641	fake.ResourceTypesStub = nil
2642	fake.resourceTypesReturns = struct {
2643		result1 db.ResourceTypes
2644		result2 error
2645	}{result1, result2}
2646}
2647
2648func (fake *FakePipeline) ResourceTypesReturnsOnCall(i int, result1 db.ResourceTypes, result2 error) {
2649	fake.resourceTypesMutex.Lock()
2650	defer fake.resourceTypesMutex.Unlock()
2651	fake.ResourceTypesStub = nil
2652	if fake.resourceTypesReturnsOnCall == nil {
2653		fake.resourceTypesReturnsOnCall = make(map[int]struct {
2654			result1 db.ResourceTypes
2655			result2 error
2656		})
2657	}
2658	fake.resourceTypesReturnsOnCall[i] = struct {
2659		result1 db.ResourceTypes
2660		result2 error
2661	}{result1, result2}
2662}
2663
2664func (fake *FakePipeline) ResourceVersion(arg1 int) (atc.ResourceVersion, bool, error) {
2665	fake.resourceVersionMutex.Lock()
2666	ret, specificReturn := fake.resourceVersionReturnsOnCall[len(fake.resourceVersionArgsForCall)]
2667	fake.resourceVersionArgsForCall = append(fake.resourceVersionArgsForCall, struct {
2668		arg1 int
2669	}{arg1})
2670	fake.recordInvocation("ResourceVersion", []interface{}{arg1})
2671	fake.resourceVersionMutex.Unlock()
2672	if fake.ResourceVersionStub != nil {
2673		return fake.ResourceVersionStub(arg1)
2674	}
2675	if specificReturn {
2676		return ret.result1, ret.result2, ret.result3
2677	}
2678	fakeReturns := fake.resourceVersionReturns
2679	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
2680}
2681
2682func (fake *FakePipeline) ResourceVersionCallCount() int {
2683	fake.resourceVersionMutex.RLock()
2684	defer fake.resourceVersionMutex.RUnlock()
2685	return len(fake.resourceVersionArgsForCall)
2686}
2687
2688func (fake *FakePipeline) ResourceVersionCalls(stub func(int) (atc.ResourceVersion, bool, error)) {
2689	fake.resourceVersionMutex.Lock()
2690	defer fake.resourceVersionMutex.Unlock()
2691	fake.ResourceVersionStub = stub
2692}
2693
2694func (fake *FakePipeline) ResourceVersionArgsForCall(i int) int {
2695	fake.resourceVersionMutex.RLock()
2696	defer fake.resourceVersionMutex.RUnlock()
2697	argsForCall := fake.resourceVersionArgsForCall[i]
2698	return argsForCall.arg1
2699}
2700
2701func (fake *FakePipeline) ResourceVersionReturns(result1 atc.ResourceVersion, result2 bool, result3 error) {
2702	fake.resourceVersionMutex.Lock()
2703	defer fake.resourceVersionMutex.Unlock()
2704	fake.ResourceVersionStub = nil
2705	fake.resourceVersionReturns = struct {
2706		result1 atc.ResourceVersion
2707		result2 bool
2708		result3 error
2709	}{result1, result2, result3}
2710}
2711
2712func (fake *FakePipeline) ResourceVersionReturnsOnCall(i int, result1 atc.ResourceVersion, result2 bool, result3 error) {
2713	fake.resourceVersionMutex.Lock()
2714	defer fake.resourceVersionMutex.Unlock()
2715	fake.ResourceVersionStub = nil
2716	if fake.resourceVersionReturnsOnCall == nil {
2717		fake.resourceVersionReturnsOnCall = make(map[int]struct {
2718			result1 atc.ResourceVersion
2719			result2 bool
2720			result3 error
2721		})
2722	}
2723	fake.resourceVersionReturnsOnCall[i] = struct {
2724		result1 atc.ResourceVersion
2725		result2 bool
2726		result3 error
2727	}{result1, result2, result3}
2728}
2729
2730func (fake *FakePipeline) Resources() (db.Resources, error) {
2731	fake.resourcesMutex.Lock()
2732	ret, specificReturn := fake.resourcesReturnsOnCall[len(fake.resourcesArgsForCall)]
2733	fake.resourcesArgsForCall = append(fake.resourcesArgsForCall, struct {
2734	}{})
2735	fake.recordInvocation("Resources", []interface{}{})
2736	fake.resourcesMutex.Unlock()
2737	if fake.ResourcesStub != nil {
2738		return fake.ResourcesStub()
2739	}
2740	if specificReturn {
2741		return ret.result1, ret.result2
2742	}
2743	fakeReturns := fake.resourcesReturns
2744	return fakeReturns.result1, fakeReturns.result2
2745}
2746
2747func (fake *FakePipeline) ResourcesCallCount() int {
2748	fake.resourcesMutex.RLock()
2749	defer fake.resourcesMutex.RUnlock()
2750	return len(fake.resourcesArgsForCall)
2751}
2752
2753func (fake *FakePipeline) ResourcesCalls(stub func() (db.Resources, error)) {
2754	fake.resourcesMutex.Lock()
2755	defer fake.resourcesMutex.Unlock()
2756	fake.ResourcesStub = stub
2757}
2758
2759func (fake *FakePipeline) ResourcesReturns(result1 db.Resources, result2 error) {
2760	fake.resourcesMutex.Lock()
2761	defer fake.resourcesMutex.Unlock()
2762	fake.ResourcesStub = nil
2763	fake.resourcesReturns = struct {
2764		result1 db.Resources
2765		result2 error
2766	}{result1, result2}
2767}
2768
2769func (fake *FakePipeline) ResourcesReturnsOnCall(i int, result1 db.Resources, result2 error) {
2770	fake.resourcesMutex.Lock()
2771	defer fake.resourcesMutex.Unlock()
2772	fake.ResourcesStub = nil
2773	if fake.resourcesReturnsOnCall == nil {
2774		fake.resourcesReturnsOnCall = make(map[int]struct {
2775			result1 db.Resources
2776			result2 error
2777		})
2778	}
2779	fake.resourcesReturnsOnCall[i] = struct {
2780		result1 db.Resources
2781		result2 error
2782	}{result1, result2}
2783}
2784
2785func (fake *FakePipeline) SetParentIDs(arg1 int, arg2 int) error {
2786	fake.setParentIDsMutex.Lock()
2787	ret, specificReturn := fake.setParentIDsReturnsOnCall[len(fake.setParentIDsArgsForCall)]
2788	fake.setParentIDsArgsForCall = append(fake.setParentIDsArgsForCall, struct {
2789		arg1 int
2790		arg2 int
2791	}{arg1, arg2})
2792	fake.recordInvocation("SetParentIDs", []interface{}{arg1, arg2})
2793	fake.setParentIDsMutex.Unlock()
2794	if fake.SetParentIDsStub != nil {
2795		return fake.SetParentIDsStub(arg1, arg2)
2796	}
2797	if specificReturn {
2798		return ret.result1
2799	}
2800	fakeReturns := fake.setParentIDsReturns
2801	return fakeReturns.result1
2802}
2803
2804func (fake *FakePipeline) SetParentIDsCallCount() int {
2805	fake.setParentIDsMutex.RLock()
2806	defer fake.setParentIDsMutex.RUnlock()
2807	return len(fake.setParentIDsArgsForCall)
2808}
2809
2810func (fake *FakePipeline) SetParentIDsCalls(stub func(int, int) error) {
2811	fake.setParentIDsMutex.Lock()
2812	defer fake.setParentIDsMutex.Unlock()
2813	fake.SetParentIDsStub = stub
2814}
2815
2816func (fake *FakePipeline) SetParentIDsArgsForCall(i int) (int, int) {
2817	fake.setParentIDsMutex.RLock()
2818	defer fake.setParentIDsMutex.RUnlock()
2819	argsForCall := fake.setParentIDsArgsForCall[i]
2820	return argsForCall.arg1, argsForCall.arg2
2821}
2822
2823func (fake *FakePipeline) SetParentIDsReturns(result1 error) {
2824	fake.setParentIDsMutex.Lock()
2825	defer fake.setParentIDsMutex.Unlock()
2826	fake.SetParentIDsStub = nil
2827	fake.setParentIDsReturns = struct {
2828		result1 error
2829	}{result1}
2830}
2831
2832func (fake *FakePipeline) SetParentIDsReturnsOnCall(i int, result1 error) {
2833	fake.setParentIDsMutex.Lock()
2834	defer fake.setParentIDsMutex.Unlock()
2835	fake.SetParentIDsStub = nil
2836	if fake.setParentIDsReturnsOnCall == nil {
2837		fake.setParentIDsReturnsOnCall = make(map[int]struct {
2838			result1 error
2839		})
2840	}
2841	fake.setParentIDsReturnsOnCall[i] = struct {
2842		result1 error
2843	}{result1}
2844}
2845
2846func (fake *FakePipeline) TeamID() int {
2847	fake.teamIDMutex.Lock()
2848	ret, specificReturn := fake.teamIDReturnsOnCall[len(fake.teamIDArgsForCall)]
2849	fake.teamIDArgsForCall = append(fake.teamIDArgsForCall, struct {
2850	}{})
2851	fake.recordInvocation("TeamID", []interface{}{})
2852	fake.teamIDMutex.Unlock()
2853	if fake.TeamIDStub != nil {
2854		return fake.TeamIDStub()
2855	}
2856	if specificReturn {
2857		return ret.result1
2858	}
2859	fakeReturns := fake.teamIDReturns
2860	return fakeReturns.result1
2861}
2862
2863func (fake *FakePipeline) TeamIDCallCount() int {
2864	fake.teamIDMutex.RLock()
2865	defer fake.teamIDMutex.RUnlock()
2866	return len(fake.teamIDArgsForCall)
2867}
2868
2869func (fake *FakePipeline) TeamIDCalls(stub func() int) {
2870	fake.teamIDMutex.Lock()
2871	defer fake.teamIDMutex.Unlock()
2872	fake.TeamIDStub = stub
2873}
2874
2875func (fake *FakePipeline) TeamIDReturns(result1 int) {
2876	fake.teamIDMutex.Lock()
2877	defer fake.teamIDMutex.Unlock()
2878	fake.TeamIDStub = nil
2879	fake.teamIDReturns = struct {
2880		result1 int
2881	}{result1}
2882}
2883
2884func (fake *FakePipeline) TeamIDReturnsOnCall(i int, result1 int) {
2885	fake.teamIDMutex.Lock()
2886	defer fake.teamIDMutex.Unlock()
2887	fake.TeamIDStub = nil
2888	if fake.teamIDReturnsOnCall == nil {
2889		fake.teamIDReturnsOnCall = make(map[int]struct {
2890			result1 int
2891		})
2892	}
2893	fake.teamIDReturnsOnCall[i] = struct {
2894		result1 int
2895	}{result1}
2896}
2897
2898func (fake *FakePipeline) TeamName() string {
2899	fake.teamNameMutex.Lock()
2900	ret, specificReturn := fake.teamNameReturnsOnCall[len(fake.teamNameArgsForCall)]
2901	fake.teamNameArgsForCall = append(fake.teamNameArgsForCall, struct {
2902	}{})
2903	fake.recordInvocation("TeamName", []interface{}{})
2904	fake.teamNameMutex.Unlock()
2905	if fake.TeamNameStub != nil {
2906		return fake.TeamNameStub()
2907	}
2908	if specificReturn {
2909		return ret.result1
2910	}
2911	fakeReturns := fake.teamNameReturns
2912	return fakeReturns.result1
2913}
2914
2915func (fake *FakePipeline) TeamNameCallCount() int {
2916	fake.teamNameMutex.RLock()
2917	defer fake.teamNameMutex.RUnlock()
2918	return len(fake.teamNameArgsForCall)
2919}
2920
2921func (fake *FakePipeline) TeamNameCalls(stub func() string) {
2922	fake.teamNameMutex.Lock()
2923	defer fake.teamNameMutex.Unlock()
2924	fake.TeamNameStub = stub
2925}
2926
2927func (fake *FakePipeline) TeamNameReturns(result1 string) {
2928	fake.teamNameMutex.Lock()
2929	defer fake.teamNameMutex.Unlock()
2930	fake.TeamNameStub = nil
2931	fake.teamNameReturns = struct {
2932		result1 string
2933	}{result1}
2934}
2935
2936func (fake *FakePipeline) TeamNameReturnsOnCall(i int, result1 string) {
2937	fake.teamNameMutex.Lock()
2938	defer fake.teamNameMutex.Unlock()
2939	fake.TeamNameStub = nil
2940	if fake.teamNameReturnsOnCall == nil {
2941		fake.teamNameReturnsOnCall = make(map[int]struct {
2942			result1 string
2943		})
2944	}
2945	fake.teamNameReturnsOnCall[i] = struct {
2946		result1 string
2947	}{result1}
2948}
2949
2950func (fake *FakePipeline) Unpause() error {
2951	fake.unpauseMutex.Lock()
2952	ret, specificReturn := fake.unpauseReturnsOnCall[len(fake.unpauseArgsForCall)]
2953	fake.unpauseArgsForCall = append(fake.unpauseArgsForCall, struct {
2954	}{})
2955	fake.recordInvocation("Unpause", []interface{}{})
2956	fake.unpauseMutex.Unlock()
2957	if fake.UnpauseStub != nil {
2958		return fake.UnpauseStub()
2959	}
2960	if specificReturn {
2961		return ret.result1
2962	}
2963	fakeReturns := fake.unpauseReturns
2964	return fakeReturns.result1
2965}
2966
2967func (fake *FakePipeline) UnpauseCallCount() int {
2968	fake.unpauseMutex.RLock()
2969	defer fake.unpauseMutex.RUnlock()
2970	return len(fake.unpauseArgsForCall)
2971}
2972
2973func (fake *FakePipeline) UnpauseCalls(stub func() error) {
2974	fake.unpauseMutex.Lock()
2975	defer fake.unpauseMutex.Unlock()
2976	fake.UnpauseStub = stub
2977}
2978
2979func (fake *FakePipeline) UnpauseReturns(result1 error) {
2980	fake.unpauseMutex.Lock()
2981	defer fake.unpauseMutex.Unlock()
2982	fake.UnpauseStub = nil
2983	fake.unpauseReturns = struct {
2984		result1 error
2985	}{result1}
2986}
2987
2988func (fake *FakePipeline) UnpauseReturnsOnCall(i int, result1 error) {
2989	fake.unpauseMutex.Lock()
2990	defer fake.unpauseMutex.Unlock()
2991	fake.UnpauseStub = nil
2992	if fake.unpauseReturnsOnCall == nil {
2993		fake.unpauseReturnsOnCall = make(map[int]struct {
2994			result1 error
2995		})
2996	}
2997	fake.unpauseReturnsOnCall[i] = struct {
2998		result1 error
2999	}{result1}
3000}
3001
3002func (fake *FakePipeline) VarSources() atc.VarSourceConfigs {
3003	fake.varSourcesMutex.Lock()
3004	ret, specificReturn := fake.varSourcesReturnsOnCall[len(fake.varSourcesArgsForCall)]
3005	fake.varSourcesArgsForCall = append(fake.varSourcesArgsForCall, struct {
3006	}{})
3007	fake.recordInvocation("VarSources", []interface{}{})
3008	fake.varSourcesMutex.Unlock()
3009	if fake.VarSourcesStub != nil {
3010		return fake.VarSourcesStub()
3011	}
3012	if specificReturn {
3013		return ret.result1
3014	}
3015	fakeReturns := fake.varSourcesReturns
3016	return fakeReturns.result1
3017}
3018
3019func (fake *FakePipeline) VarSourcesCallCount() int {
3020	fake.varSourcesMutex.RLock()
3021	defer fake.varSourcesMutex.RUnlock()
3022	return len(fake.varSourcesArgsForCall)
3023}
3024
3025func (fake *FakePipeline) VarSourcesCalls(stub func() atc.VarSourceConfigs) {
3026	fake.varSourcesMutex.Lock()
3027	defer fake.varSourcesMutex.Unlock()
3028	fake.VarSourcesStub = stub
3029}
3030
3031func (fake *FakePipeline) VarSourcesReturns(result1 atc.VarSourceConfigs) {
3032	fake.varSourcesMutex.Lock()
3033	defer fake.varSourcesMutex.Unlock()
3034	fake.VarSourcesStub = nil
3035	fake.varSourcesReturns = struct {
3036		result1 atc.VarSourceConfigs
3037	}{result1}
3038}
3039
3040func (fake *FakePipeline) VarSourcesReturnsOnCall(i int, result1 atc.VarSourceConfigs) {
3041	fake.varSourcesMutex.Lock()
3042	defer fake.varSourcesMutex.Unlock()
3043	fake.VarSourcesStub = nil
3044	if fake.varSourcesReturnsOnCall == nil {
3045		fake.varSourcesReturnsOnCall = make(map[int]struct {
3046			result1 atc.VarSourceConfigs
3047		})
3048	}
3049	fake.varSourcesReturnsOnCall[i] = struct {
3050		result1 atc.VarSourceConfigs
3051	}{result1}
3052}
3053
3054func (fake *FakePipeline) Variables(arg1 lager.Logger, arg2 creds.Secrets, arg3 creds.VarSourcePool) (vars.Variables, error) {
3055	fake.variablesMutex.Lock()
3056	ret, specificReturn := fake.variablesReturnsOnCall[len(fake.variablesArgsForCall)]
3057	fake.variablesArgsForCall = append(fake.variablesArgsForCall, struct {
3058		arg1 lager.Logger
3059		arg2 creds.Secrets
3060		arg3 creds.VarSourcePool
3061	}{arg1, arg2, arg3})
3062	fake.recordInvocation("Variables", []interface{}{arg1, arg2, arg3})
3063	fake.variablesMutex.Unlock()
3064	if fake.VariablesStub != nil {
3065		return fake.VariablesStub(arg1, arg2, arg3)
3066	}
3067	if specificReturn {
3068		return ret.result1, ret.result2
3069	}
3070	fakeReturns := fake.variablesReturns
3071	return fakeReturns.result1, fakeReturns.result2
3072}
3073
3074func (fake *FakePipeline) VariablesCallCount() int {
3075	fake.variablesMutex.RLock()
3076	defer fake.variablesMutex.RUnlock()
3077	return len(fake.variablesArgsForCall)
3078}
3079
3080func (fake *FakePipeline) VariablesCalls(stub func(lager.Logger, creds.Secrets, creds.VarSourcePool) (vars.Variables, error)) {
3081	fake.variablesMutex.Lock()
3082	defer fake.variablesMutex.Unlock()
3083	fake.VariablesStub = stub
3084}
3085
3086func (fake *FakePipeline) VariablesArgsForCall(i int) (lager.Logger, creds.Secrets, creds.VarSourcePool) {
3087	fake.variablesMutex.RLock()
3088	defer fake.variablesMutex.RUnlock()
3089	argsForCall := fake.variablesArgsForCall[i]
3090	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
3091}
3092
3093func (fake *FakePipeline) VariablesReturns(result1 vars.Variables, result2 error) {
3094	fake.variablesMutex.Lock()
3095	defer fake.variablesMutex.Unlock()
3096	fake.VariablesStub = nil
3097	fake.variablesReturns = struct {
3098		result1 vars.Variables
3099		result2 error
3100	}{result1, result2}
3101}
3102
3103func (fake *FakePipeline) VariablesReturnsOnCall(i int, result1 vars.Variables, result2 error) {
3104	fake.variablesMutex.Lock()
3105	defer fake.variablesMutex.Unlock()
3106	fake.VariablesStub = nil
3107	if fake.variablesReturnsOnCall == nil {
3108		fake.variablesReturnsOnCall = make(map[int]struct {
3109			result1 vars.Variables
3110			result2 error
3111		})
3112	}
3113	fake.variablesReturnsOnCall[i] = struct {
3114		result1 vars.Variables
3115		result2 error
3116	}{result1, result2}
3117}
3118
3119func (fake *FakePipeline) Invocations() map[string][][]interface{} {
3120	fake.invocationsMutex.RLock()
3121	defer fake.invocationsMutex.RUnlock()
3122	fake.archiveMutex.RLock()
3123	defer fake.archiveMutex.RUnlock()
3124	fake.archivedMutex.RLock()
3125	defer fake.archivedMutex.RUnlock()
3126	fake.buildsMutex.RLock()
3127	defer fake.buildsMutex.RUnlock()
3128	fake.buildsWithTimeMutex.RLock()
3129	defer fake.buildsWithTimeMutex.RUnlock()
3130	fake.causalityMutex.RLock()
3131	defer fake.causalityMutex.RUnlock()
3132	fake.checkPausedMutex.RLock()
3133	defer fake.checkPausedMutex.RUnlock()
3134	fake.configMutex.RLock()
3135	defer fake.configMutex.RUnlock()
3136	fake.configVersionMutex.RLock()
3137	defer fake.configVersionMutex.RUnlock()
3138	fake.createOneOffBuildMutex.RLock()
3139	defer fake.createOneOffBuildMutex.RUnlock()
3140	fake.createStartedBuildMutex.RLock()
3141	defer fake.createStartedBuildMutex.RUnlock()
3142	fake.dashboardMutex.RLock()
3143	defer fake.dashboardMutex.RUnlock()
3144	fake.deleteBuildEventsByBuildIDsMutex.RLock()
3145	defer fake.deleteBuildEventsByBuildIDsMutex.RUnlock()
3146	fake.destroyMutex.RLock()
3147	defer fake.destroyMutex.RUnlock()
3148	fake.displayMutex.RLock()
3149	defer fake.displayMutex.RUnlock()
3150	fake.exposeMutex.RLock()
3151	defer fake.exposeMutex.RUnlock()
3152	fake.getBuildsWithVersionAsInputMutex.RLock()
3153	defer fake.getBuildsWithVersionAsInputMutex.RUnlock()
3154	fake.getBuildsWithVersionAsOutputMutex.RLock()
3155	defer fake.getBuildsWithVersionAsOutputMutex.RUnlock()
3156	fake.groupsMutex.RLock()
3157	defer fake.groupsMutex.RUnlock()
3158	fake.hideMutex.RLock()
3159	defer fake.hideMutex.RUnlock()
3160	fake.iDMutex.RLock()
3161	defer fake.iDMutex.RUnlock()
3162	fake.jobMutex.RLock()
3163	defer fake.jobMutex.RUnlock()
3164	fake.jobsMutex.RLock()
3165	defer fake.jobsMutex.RUnlock()
3166	fake.lastUpdatedMutex.RLock()
3167	defer fake.lastUpdatedMutex.RUnlock()
3168	fake.loadDebugVersionsDBMutex.RLock()
3169	defer fake.loadDebugVersionsDBMutex.RUnlock()
3170	fake.nameMutex.RLock()
3171	defer fake.nameMutex.RUnlock()
3172	fake.parentBuildIDMutex.RLock()
3173	defer fake.parentBuildIDMutex.RUnlock()
3174	fake.parentJobIDMutex.RLock()
3175	defer fake.parentJobIDMutex.RUnlock()
3176	fake.pauseMutex.RLock()
3177	defer fake.pauseMutex.RUnlock()
3178	fake.pausedMutex.RLock()
3179	defer fake.pausedMutex.RUnlock()
3180	fake.publicMutex.RLock()
3181	defer fake.publicMutex.RUnlock()
3182	fake.reloadMutex.RLock()
3183	defer fake.reloadMutex.RUnlock()
3184	fake.renameMutex.RLock()
3185	defer fake.renameMutex.RUnlock()
3186	fake.resourceMutex.RLock()
3187	defer fake.resourceMutex.RUnlock()
3188	fake.resourceByIDMutex.RLock()
3189	defer fake.resourceByIDMutex.RUnlock()
3190	fake.resourceTypeMutex.RLock()
3191	defer fake.resourceTypeMutex.RUnlock()
3192	fake.resourceTypeByIDMutex.RLock()
3193	defer fake.resourceTypeByIDMutex.RUnlock()
3194	fake.resourceTypesMutex.RLock()
3195	defer fake.resourceTypesMutex.RUnlock()
3196	fake.resourceVersionMutex.RLock()
3197	defer fake.resourceVersionMutex.RUnlock()
3198	fake.resourcesMutex.RLock()
3199	defer fake.resourcesMutex.RUnlock()
3200	fake.setParentIDsMutex.RLock()
3201	defer fake.setParentIDsMutex.RUnlock()
3202	fake.teamIDMutex.RLock()
3203	defer fake.teamIDMutex.RUnlock()
3204	fake.teamNameMutex.RLock()
3205	defer fake.teamNameMutex.RUnlock()
3206	fake.unpauseMutex.RLock()
3207	defer fake.unpauseMutex.RUnlock()
3208	fake.varSourcesMutex.RLock()
3209	defer fake.varSourcesMutex.RUnlock()
3210	fake.variablesMutex.RLock()
3211	defer fake.variablesMutex.RUnlock()
3212	copiedInvocations := map[string][][]interface{}{}
3213	for key, value := range fake.invocations {
3214		copiedInvocations[key] = value
3215	}
3216	return copiedInvocations
3217}
3218
3219func (fake *FakePipeline) recordInvocation(key string, args []interface{}) {
3220	fake.invocationsMutex.Lock()
3221	defer fake.invocationsMutex.Unlock()
3222	if fake.invocations == nil {
3223		fake.invocations = map[string][][]interface{}{}
3224	}
3225	if fake.invocations[key] == nil {
3226		fake.invocations[key] = [][]interface{}{}
3227	}
3228	fake.invocations[key] = append(fake.invocations[key], args)
3229}
3230
3231var _ db.Pipeline = new(FakePipeline)
3232