fake_provider.go

// Code generated by counterfeiter. DO NOT EDIT.
package providerfakes

import (
	"net/http"
	"sync"

	"code.cloudfoundry.org/lager"
	"github.com/concourse/atc/auth/provider"
	"golang.org/x/net/context"
	"golang.org/x/oauth2"
)

type FakeProvider struct {
	PreTokenClientStub        func() (*http.Client, error)
	preTokenClientMutex       sync.RWMutex
	preTokenClientArgsForCall []struct{}
	preTokenClientReturns     struct {
		result1 *http.Client
		result2 error
	}
	preTokenClientReturnsOnCall map[int]struct {
		result1 *http.Client
		result2 error
	}
	AuthCodeURLStub        func(string, ...oauth2.AuthCodeOption) string
	authCodeURLMutex       sync.RWMutex
	authCodeURLArgsForCall []struct {
		arg1 string
		arg2 []oauth2.AuthCodeOption
	}
	authCodeURLReturns struct {
		result1 string
	}
	authCodeURLReturnsOnCall map[int]struct {
		result1 string
	}
	ExchangeStub        func(context.Context, string) (*oauth2.Token, error)
	exchangeMutex       sync.RWMutex
	exchangeArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	exchangeReturns struct {
		result1 *oauth2.Token
		result2 error
	}
	exchangeReturnsOnCall map[int]struct {
		result1 *oauth2.Token
		result2 error
	}
	ClientStub        func(context.Context, *oauth2.Token) *http.Client
	clientMutex       sync.RWMutex
	clientArgsForCall []struct {
		arg1 context.Context
		arg2 *oauth2.Token
	}
	clientReturns struct {
		result1 *http.Client
	}
	clientReturnsOnCall map[int]struct {
		result1 *http.Client
	}
	VerifyStub        func(lager.Logger, *http.Client) (bool, error)
	verifyMutex       sync.RWMutex
	verifyArgsForCall []struct {
		arg1 lager.Logger
		arg2 *http.Client
	}
	verifyReturns struct {
		result1 bool
		result2 error
	}
	verifyReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeProvider) PreTokenClient() (*http.Client, error) {
	fake.preTokenClientMutex.Lock()
	ret, specificReturn := fake.preTokenClientReturnsOnCall[len(fake.preTokenClientArgsForCall)]
	fake.preTokenClientArgsForCall = append(fake.preTokenClientArgsForCall, struct{}{})
	fake.recordInvocation("PreTokenClient", []interface{}{})
	fake.preTokenClientMutex.Unlock()
	if fake.PreTokenClientStub != nil {
		return fake.PreTokenClientStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.preTokenClientReturns.result1, fake.preTokenClientReturns.result2
}

func (fake *FakeProvider) PreTokenClientCallCount() int {
	fake.preTokenClientMutex.RLock()
	defer fake.preTokenClientMutex.RUnlock()
	return len(fake.preTokenClientArgsForCall)
}

func (fake *FakeProvider) PreTokenClientReturns(result1 *http.Client, result2 error) {
	fake.PreTokenClientStub = nil
	fake.preTokenClientReturns = struct {
		result1 *http.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeProvider) PreTokenClientReturnsOnCall(i int, result1 *http.Client, result2 error) {
	fake.PreTokenClientStub = nil
	if fake.preTokenClientReturnsOnCall == nil {
		fake.preTokenClientReturnsOnCall = make(map[int]struct {
			result1 *http.Client
			result2 error
		})
	}
	fake.preTokenClientReturnsOnCall[i] = struct {
		result1 *http.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeProvider) AuthCodeURL(arg1 string, arg2 ...oauth2.AuthCodeOption) string {
	fake.authCodeURLMutex.Lock()
	ret, specificReturn := fake.authCodeURLReturnsOnCall[len(fake.authCodeURLArgsForCall)]
	fake.authCodeURLArgsForCall = append(fake.authCodeURLArgsForCall, struct {
		arg1 string
		arg2 []oauth2.AuthCodeOption
	}{arg1, arg2})
	fake.recordInvocation("AuthCodeURL", []interface{}{arg1, arg2})
	fake.authCodeURLMutex.Unlock()
	if fake.AuthCodeURLStub != nil {
		return fake.AuthCodeURLStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.authCodeURLReturns.result1
}

func (fake *FakeProvider) AuthCodeURLCallCount() int {
	fake.authCodeURLMutex.RLock()
	defer fake.authCodeURLMutex.RUnlock()
	return len(fake.authCodeURLArgsForCall)
}

func (fake *FakeProvider) AuthCodeURLArgsForCall(i int) (string, []oauth2.AuthCodeOption) {
	fake.authCodeURLMutex.RLock()
	defer fake.authCodeURLMutex.RUnlock()
	return fake.authCodeURLArgsForCall[i].arg1, fake.authCodeURLArgsForCall[i].arg2
}

func (fake *FakeProvider) AuthCodeURLReturns(result1 string) {
	fake.AuthCodeURLStub = nil
	fake.authCodeURLReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProvider) AuthCodeURLReturnsOnCall(i int, result1 string) {
	fake.AuthCodeURLStub = nil
	if fake.authCodeURLReturnsOnCall == nil {
		fake.authCodeURLReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.authCodeURLReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProvider) Exchange(arg1 context.Context, arg2 string) (*oauth2.Token, error) {
	fake.exchangeMutex.Lock()
	ret, specificReturn := fake.exchangeReturnsOnCall[len(fake.exchangeArgsForCall)]
	fake.exchangeArgsForCall = append(fake.exchangeArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("Exchange", []interface{}{arg1, arg2})
	fake.exchangeMutex.Unlock()
	if fake.ExchangeStub != nil {
		return fake.ExchangeStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.exchangeReturns.result1, fake.exchangeReturns.result2
}

func (fake *FakeProvider) ExchangeCallCount() int {
	fake.exchangeMutex.RLock()
	defer fake.exchangeMutex.RUnlock()
	return len(fake.exchangeArgsForCall)
}

func (fake *FakeProvider) ExchangeArgsForCall(i int) (context.Context, string) {
	fake.exchangeMutex.RLock()
	defer fake.exchangeMutex.RUnlock()
	return fake.exchangeArgsForCall[i].arg1, fake.exchangeArgsForCall[i].arg2
}

func (fake *FakeProvider) ExchangeReturns(result1 *oauth2.Token, result2 error) {
	fake.ExchangeStub = nil
	fake.exchangeReturns = struct {
		result1 *oauth2.Token
		result2 error
	}{result1, result2}
}

func (fake *FakeProvider) ExchangeReturnsOnCall(i int, result1 *oauth2.Token, result2 error) {
	fake.ExchangeStub = nil
	if fake.exchangeReturnsOnCall == nil {
		fake.exchangeReturnsOnCall = make(map[int]struct {
			result1 *oauth2.Token
			result2 error
		})
	}
	fake.exchangeReturnsOnCall[i] = struct {
		result1 *oauth2.Token
		result2 error
	}{result1, result2}
}

func (fake *FakeProvider) Client(arg1 context.Context, arg2 *oauth2.Token) *http.Client {
	fake.clientMutex.Lock()
	ret, specificReturn := fake.clientReturnsOnCall[len(fake.clientArgsForCall)]
	fake.clientArgsForCall = append(fake.clientArgsForCall, struct {
		arg1 context.Context
		arg2 *oauth2.Token
	}{arg1, arg2})
	fake.recordInvocation("Client", []interface{}{arg1, arg2})
	fake.clientMutex.Unlock()
	if fake.ClientStub != nil {
		return fake.ClientStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.clientReturns.result1
}

func (fake *FakeProvider) ClientCallCount() int {
	fake.clientMutex.RLock()
	defer fake.clientMutex.RUnlock()
	return len(fake.clientArgsForCall)
}

func (fake *FakeProvider) ClientArgsForCall(i int) (context.Context, *oauth2.Token) {
	fake.clientMutex.RLock()
	defer fake.clientMutex.RUnlock()
	return fake.clientArgsForCall[i].arg1, fake.clientArgsForCall[i].arg2
}

func (fake *FakeProvider) ClientReturns(result1 *http.Client) {
	fake.ClientStub = nil
	fake.clientReturns = struct {
		result1 *http.Client
	}{result1}
}

func (fake *FakeProvider) ClientReturnsOnCall(i int, result1 *http.Client) {
	fake.ClientStub = nil
	if fake.clientReturnsOnCall == nil {
		fake.clientReturnsOnCall = make(map[int]struct {
			result1 *http.Client
		})
	}
	fake.clientReturnsOnCall[i] = struct {
		result1 *http.Client
	}{result1}
}

func (fake *FakeProvider) Verify(arg1 lager.Logger, arg2 *http.Client) (bool, error) {
	fake.verifyMutex.Lock()
	ret, specificReturn := fake.verifyReturnsOnCall[len(fake.verifyArgsForCall)]
	fake.verifyArgsForCall = append(fake.verifyArgsForCall, struct {
		arg1 lager.Logger
		arg2 *http.Client
	}{arg1, arg2})
	fake.recordInvocation("Verify", []interface{}{arg1, arg2})
	fake.verifyMutex.Unlock()
	if fake.VerifyStub != nil {
		return fake.VerifyStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.verifyReturns.result1, fake.verifyReturns.result2
}

func (fake *FakeProvider) VerifyCallCount() int {
	fake.verifyMutex.RLock()
	defer fake.verifyMutex.RUnlock()
	return len(fake.verifyArgsForCall)
}

func (fake *FakeProvider) VerifyArgsForCall(i int) (lager.Logger, *http.Client) {
	fake.verifyMutex.RLock()
	defer fake.verifyMutex.RUnlock()
	return fake.verifyArgsForCall[i].arg1, fake.verifyArgsForCall[i].arg2
}

func (fake *FakeProvider) VerifyReturns(result1 bool, result2 error) {
	fake.VerifyStub = nil
	fake.verifyReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeProvider) VerifyReturnsOnCall(i int, result1 bool, result2 error) {
	fake.VerifyStub = nil
	if fake.verifyReturnsOnCall == nil {
		fake.verifyReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.verifyReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeProvider) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.preTokenClientMutex.RLock()
	defer fake.preTokenClientMutex.RUnlock()
	fake.authCodeURLMutex.RLock()
	defer fake.authCodeURLMutex.RUnlock()
	fake.exchangeMutex.RLock()
	defer fake.exchangeMutex.RUnlock()
	fake.clientMutex.RLock()
	defer fake.clientMutex.RUnlock()
	fake.verifyMutex.RLock()
	defer fake.verifyMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeProvider) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ provider.Provider = new(FakeProvider)