1// Code generated by counterfeiter. DO NOT EDIT.
2package dbfakes
3
4import (
5	"sync"
6
7	"github.com/Masterminds/squirrel"
8	"github.com/concourse/concourse/atc/db"
9)
10
11type FakeContainerOwner struct {
12	CreateStub        func(db.Tx, string) (map[string]interface{}, error)
13	createMutex       sync.RWMutex
14	createArgsForCall []struct {
15		arg1 db.Tx
16		arg2 string
17	}
18	createReturns struct {
19		result1 map[string]interface{}
20		result2 error
21	}
22	createReturnsOnCall map[int]struct {
23		result1 map[string]interface{}
24		result2 error
25	}
26	FindStub        func(db.Conn) (squirrel.Eq, bool, error)
27	findMutex       sync.RWMutex
28	findArgsForCall []struct {
29		arg1 db.Conn
30	}
31	findReturns struct {
32		result1 squirrel.Eq
33		result2 bool
34		result3 error
35	}
36	findReturnsOnCall map[int]struct {
37		result1 squirrel.Eq
38		result2 bool
39		result3 error
40	}
41	invocations      map[string][][]interface{}
42	invocationsMutex sync.RWMutex
43}
44
45func (fake *FakeContainerOwner) Create(arg1 db.Tx, arg2 string) (map[string]interface{}, error) {
46	fake.createMutex.Lock()
47	ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)]
48	fake.createArgsForCall = append(fake.createArgsForCall, struct {
49		arg1 db.Tx
50		arg2 string
51	}{arg1, arg2})
52	fake.recordInvocation("Create", []interface{}{arg1, arg2})
53	fake.createMutex.Unlock()
54	if fake.CreateStub != nil {
55		return fake.CreateStub(arg1, arg2)
56	}
57	if specificReturn {
58		return ret.result1, ret.result2
59	}
60	fakeReturns := fake.createReturns
61	return fakeReturns.result1, fakeReturns.result2
62}
63
64func (fake *FakeContainerOwner) CreateCallCount() int {
65	fake.createMutex.RLock()
66	defer fake.createMutex.RUnlock()
67	return len(fake.createArgsForCall)
68}
69
70func (fake *FakeContainerOwner) CreateCalls(stub func(db.Tx, string) (map[string]interface{}, error)) {
71	fake.createMutex.Lock()
72	defer fake.createMutex.Unlock()
73	fake.CreateStub = stub
74}
75
76func (fake *FakeContainerOwner) CreateArgsForCall(i int) (db.Tx, string) {
77	fake.createMutex.RLock()
78	defer fake.createMutex.RUnlock()
79	argsForCall := fake.createArgsForCall[i]
80	return argsForCall.arg1, argsForCall.arg2
81}
82
83func (fake *FakeContainerOwner) CreateReturns(result1 map[string]interface{}, result2 error) {
84	fake.createMutex.Lock()
85	defer fake.createMutex.Unlock()
86	fake.CreateStub = nil
87	fake.createReturns = struct {
88		result1 map[string]interface{}
89		result2 error
90	}{result1, result2}
91}
92
93func (fake *FakeContainerOwner) CreateReturnsOnCall(i int, result1 map[string]interface{}, result2 error) {
94	fake.createMutex.Lock()
95	defer fake.createMutex.Unlock()
96	fake.CreateStub = nil
97	if fake.createReturnsOnCall == nil {
98		fake.createReturnsOnCall = make(map[int]struct {
99			result1 map[string]interface{}
100			result2 error
101		})
102	}
103	fake.createReturnsOnCall[i] = struct {
104		result1 map[string]interface{}
105		result2 error
106	}{result1, result2}
107}
108
109func (fake *FakeContainerOwner) Find(arg1 db.Conn) (squirrel.Eq, bool, error) {
110	fake.findMutex.Lock()
111	ret, specificReturn := fake.findReturnsOnCall[len(fake.findArgsForCall)]
112	fake.findArgsForCall = append(fake.findArgsForCall, struct {
113		arg1 db.Conn
114	}{arg1})
115	fake.recordInvocation("Find", []interface{}{arg1})
116	fake.findMutex.Unlock()
117	if fake.FindStub != nil {
118		return fake.FindStub(arg1)
119	}
120	if specificReturn {
121		return ret.result1, ret.result2, ret.result3
122	}
123	fakeReturns := fake.findReturns
124	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
125}
126
127func (fake *FakeContainerOwner) FindCallCount() int {
128	fake.findMutex.RLock()
129	defer fake.findMutex.RUnlock()
130	return len(fake.findArgsForCall)
131}
132
133func (fake *FakeContainerOwner) FindCalls(stub func(db.Conn) (squirrel.Eq, bool, error)) {
134	fake.findMutex.Lock()
135	defer fake.findMutex.Unlock()
136	fake.FindStub = stub
137}
138
139func (fake *FakeContainerOwner) FindArgsForCall(i int) db.Conn {
140	fake.findMutex.RLock()
141	defer fake.findMutex.RUnlock()
142	argsForCall := fake.findArgsForCall[i]
143	return argsForCall.arg1
144}
145
146func (fake *FakeContainerOwner) FindReturns(result1 squirrel.Eq, result2 bool, result3 error) {
147	fake.findMutex.Lock()
148	defer fake.findMutex.Unlock()
149	fake.FindStub = nil
150	fake.findReturns = struct {
151		result1 squirrel.Eq
152		result2 bool
153		result3 error
154	}{result1, result2, result3}
155}
156
157func (fake *FakeContainerOwner) FindReturnsOnCall(i int, result1 squirrel.Eq, result2 bool, result3 error) {
158	fake.findMutex.Lock()
159	defer fake.findMutex.Unlock()
160	fake.FindStub = nil
161	if fake.findReturnsOnCall == nil {
162		fake.findReturnsOnCall = make(map[int]struct {
163			result1 squirrel.Eq
164			result2 bool
165			result3 error
166		})
167	}
168	fake.findReturnsOnCall[i] = struct {
169		result1 squirrel.Eq
170		result2 bool
171		result3 error
172	}{result1, result2, result3}
173}
174
175func (fake *FakeContainerOwner) Invocations() map[string][][]interface{} {
176	fake.invocationsMutex.RLock()
177	defer fake.invocationsMutex.RUnlock()
178	fake.createMutex.RLock()
179	defer fake.createMutex.RUnlock()
180	fake.findMutex.RLock()
181	defer fake.findMutex.RUnlock()
182	copiedInvocations := map[string][][]interface{}{}
183	for key, value := range fake.invocations {
184		copiedInvocations[key] = value
185	}
186	return copiedInvocations
187}
188
189func (fake *FakeContainerOwner) recordInvocation(key string, args []interface{}) {
190	fake.invocationsMutex.Lock()
191	defer fake.invocationsMutex.Unlock()
192	if fake.invocations == nil {
193		fake.invocations = map[string][][]interface{}{}
194	}
195	if fake.invocations[key] == nil {
196		fake.invocations[key] = [][]interface{}{}
197	}
198	fake.invocations[key] = append(fake.invocations[key], args)
199}
200
201var _ db.ContainerOwner = new(FakeContainerOwner)
202