fake_conn.go

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

import (
	"io"
	"sync"

	"code.cloudfoundry.org/garden-shed/distclient"
	"code.cloudfoundry.org/lager"
	"github.com/docker/distribution/digest"
)

type FakeConn struct {
	GetManifestStub        func(logger lager.Logger, tag string) (*distclient.Manifest, error)
	getManifestMutex       sync.RWMutex
	getManifestArgsForCall []struct {
		logger lager.Logger
		tag    string
	}
	getManifestReturns struct {
		result1 *distclient.Manifest
		result2 error
	}
	getManifestReturnsOnCall map[int]struct {
		result1 *distclient.Manifest
		result2 error
	}
	GetBlobReaderStub        func(logger lager.Logger, d digest.Digest) (io.ReadCloser, error)
	getBlobReaderMutex       sync.RWMutex
	getBlobReaderArgsForCall []struct {
		logger lager.Logger
		d      digest.Digest
	}
	getBlobReaderReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getBlobReaderReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeConn) GetManifest(logger lager.Logger, tag string) (*distclient.Manifest, error) {
	fake.getManifestMutex.Lock()
	ret, specificReturn := fake.getManifestReturnsOnCall[len(fake.getManifestArgsForCall)]
	fake.getManifestArgsForCall = append(fake.getManifestArgsForCall, struct {
		logger lager.Logger
		tag    string
	}{logger, tag})
	fake.recordInvocation("GetManifest", []interface{}{logger, tag})
	fake.getManifestMutex.Unlock()
	if fake.GetManifestStub != nil {
		return fake.GetManifestStub(logger, tag)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.getManifestReturns.result1, fake.getManifestReturns.result2
}

func (fake *FakeConn) GetManifestCallCount() int {
	fake.getManifestMutex.RLock()
	defer fake.getManifestMutex.RUnlock()
	return len(fake.getManifestArgsForCall)
}

func (fake *FakeConn) GetManifestArgsForCall(i int) (lager.Logger, string) {
	fake.getManifestMutex.RLock()
	defer fake.getManifestMutex.RUnlock()
	return fake.getManifestArgsForCall[i].logger, fake.getManifestArgsForCall[i].tag
}

func (fake *FakeConn) GetManifestReturns(result1 *distclient.Manifest, result2 error) {
	fake.GetManifestStub = nil
	fake.getManifestReturns = struct {
		result1 *distclient.Manifest
		result2 error
	}{result1, result2}
}

func (fake *FakeConn) GetManifestReturnsOnCall(i int, result1 *distclient.Manifest, result2 error) {
	fake.GetManifestStub = nil
	if fake.getManifestReturnsOnCall == nil {
		fake.getManifestReturnsOnCall = make(map[int]struct {
			result1 *distclient.Manifest
			result2 error
		})
	}
	fake.getManifestReturnsOnCall[i] = struct {
		result1 *distclient.Manifest
		result2 error
	}{result1, result2}
}

func (fake *FakeConn) GetBlobReader(logger lager.Logger, d digest.Digest) (io.ReadCloser, error) {
	fake.getBlobReaderMutex.Lock()
	ret, specificReturn := fake.getBlobReaderReturnsOnCall[len(fake.getBlobReaderArgsForCall)]
	fake.getBlobReaderArgsForCall = append(fake.getBlobReaderArgsForCall, struct {
		logger lager.Logger
		d      digest.Digest
	}{logger, d})
	fake.recordInvocation("GetBlobReader", []interface{}{logger, d})
	fake.getBlobReaderMutex.Unlock()
	if fake.GetBlobReaderStub != nil {
		return fake.GetBlobReaderStub(logger, d)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.getBlobReaderReturns.result1, fake.getBlobReaderReturns.result2
}

func (fake *FakeConn) GetBlobReaderCallCount() int {
	fake.getBlobReaderMutex.RLock()
	defer fake.getBlobReaderMutex.RUnlock()
	return len(fake.getBlobReaderArgsForCall)
}

func (fake *FakeConn) GetBlobReaderArgsForCall(i int) (lager.Logger, digest.Digest) {
	fake.getBlobReaderMutex.RLock()
	defer fake.getBlobReaderMutex.RUnlock()
	return fake.getBlobReaderArgsForCall[i].logger, fake.getBlobReaderArgsForCall[i].d
}

func (fake *FakeConn) GetBlobReaderReturns(result1 io.ReadCloser, result2 error) {
	fake.GetBlobReaderStub = nil
	fake.getBlobReaderReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeConn) GetBlobReaderReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.GetBlobReaderStub = nil
	if fake.getBlobReaderReturnsOnCall == nil {
		fake.getBlobReaderReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getBlobReaderReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeConn) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.getManifestMutex.RLock()
	defer fake.getManifestMutex.RUnlock()
	fake.getBlobReaderMutex.RLock()
	defer fake.getBlobReaderMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeConn) 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 _ distclient.Conn = new(FakeConn)