Introducing Counterfeiter

Author: dark5un

src/component_tests/doc.go

@@ -2,7 +2,7 @@ package component_tests
 
 import "code.cloudfoundry.org/go-loggregator/v9/rpc/loggregator_v2"
 
-//go:generate go run git.sr.ht/~nelsam/hel/v3 -t MetronIngressServer -o helheim_fixed_test.go
+//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o fakes/fake_doc.go . MetronIngressServer
 type MetronIngressServer interface {
 	loggregator_v2.IngressServer
 }

src/component_tests/fakes/fake_doc.go

@@ -0,0 +1,292 @@
+// This Code was generated by counterfeiter, but we had to edit it - see below.
+// This is a result of gRPC breaking change referenced here: https://github.com/cloudfoundry/go-loggregator/issues/146
+// The command to generate this file is: `go generate ./...`
+// After generating the file, loggregator_v2.UnimplementedIngressServer will need to be embedded in the FakeMetronIngressServer struct.
+// If this file needs to be generated again, the above changes will need to be reapplied.
+// In order to pass the linter checks the function `(fake *FakeMetronIngressServer) mustEmbedUnimplementedIngressServer()` should be removed.
+package fakes
+
+import (
+	"context"
+	"sync"
+
+	"code.cloudfoundry.org/go-loggregator/v9/rpc/loggregator_v2"
+	"github.com/cloudfoundry/statsd-injector/component_tests"
+)
+
+type FakeMetronIngressServer struct {
+	loggregator_v2.UnimplementedIngressServer
+	BatchSenderStub        func(loggregator_v2.Ingress_BatchSenderServer) error
+	batchSenderMutex       sync.RWMutex
+	batchSenderArgsForCall []struct {
+		arg1 loggregator_v2.Ingress_BatchSenderServer
+	}
+	batchSenderReturns struct {
+		result1 error
+	}
+	batchSenderReturnsOnCall map[int]struct {
+		result1 error
+	}
+	SendStub        func(context.Context, *loggregator_v2.EnvelopeBatch) (*loggregator_v2.SendResponse, error)
+	sendMutex       sync.RWMutex
+	sendArgsForCall []struct {
+		arg1 context.Context
+		arg2 *loggregator_v2.EnvelopeBatch
+	}
+	sendReturns struct {
+		result1 *loggregator_v2.SendResponse
+		result2 error
+	}
+	sendReturnsOnCall map[int]struct {
+		result1 *loggregator_v2.SendResponse
+		result2 error
+	}
+	SenderStub        func(loggregator_v2.Ingress_SenderServer) error
+	senderMutex       sync.RWMutex
+	senderArgsForCall []struct {
+		arg1 loggregator_v2.Ingress_SenderServer
+	}
+	senderReturns struct {
+		result1 error
+	}
+	senderReturnsOnCall map[int]struct {
+		result1 error
+	}
+	mustEmbedUnimplementedIngressServerStub        func()
+	mustEmbedUnimplementedIngressServerMutex       sync.RWMutex
+	mustEmbedUnimplementedIngressServerArgsForCall []struct {
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeMetronIngressServer) BatchSender(arg1 loggregator_v2.Ingress_BatchSenderServer) error {
+	fake.batchSenderMutex.Lock()
+	ret, specificReturn := fake.batchSenderReturnsOnCall[len(fake.batchSenderArgsForCall)]
+	fake.batchSenderArgsForCall = append(fake.batchSenderArgsForCall, struct {
+		arg1 loggregator_v2.Ingress_BatchSenderServer
+	}{arg1})
+	stub := fake.BatchSenderStub
+	fakeReturns := fake.batchSenderReturns
+	fake.recordInvocation("BatchSender", []interface{}{arg1})
+	fake.batchSenderMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMetronIngressServer) BatchSenderCallCount() int {
+	fake.batchSenderMutex.RLock()
+	defer fake.batchSenderMutex.RUnlock()
+	return len(fake.batchSenderArgsForCall)
+}
+
+func (fake *FakeMetronIngressServer) BatchSenderCalls(stub func(loggregator_v2.Ingress_BatchSenderServer) error) {
+	fake.batchSenderMutex.Lock()
+	defer fake.batchSenderMutex.Unlock()
+	fake.BatchSenderStub = stub
+}
+
+func (fake *FakeMetronIngressServer) BatchSenderArgsForCall(i int) loggregator_v2.Ingress_BatchSenderServer {
+	fake.batchSenderMutex.RLock()
+	defer fake.batchSenderMutex.RUnlock()
+	argsForCall := fake.batchSenderArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeMetronIngressServer) BatchSenderReturns(result1 error) {
+	fake.batchSenderMutex.Lock()
+	defer fake.batchSenderMutex.Unlock()
+	fake.BatchSenderStub = nil
+	fake.batchSenderReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeMetronIngressServer) BatchSenderReturnsOnCall(i int, result1 error) {
+	fake.batchSenderMutex.Lock()
+	defer fake.batchSenderMutex.Unlock()
+	fake.BatchSenderStub = nil
+	if fake.batchSenderReturnsOnCall == nil {
+		fake.batchSenderReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.batchSenderReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeMetronIngressServer) Send(arg1 context.Context, arg2 *loggregator_v2.EnvelopeBatch) (*loggregator_v2.SendResponse, error) {
+	fake.sendMutex.Lock()
+	ret, specificReturn := fake.sendReturnsOnCall[len(fake.sendArgsForCall)]
+	fake.sendArgsForCall = append(fake.sendArgsForCall, struct {
+		arg1 context.Context
+		arg2 *loggregator_v2.EnvelopeBatch
+	}{arg1, arg2})
+	stub := fake.SendStub
+	fakeReturns := fake.sendReturns
+	fake.recordInvocation("Send", []interface{}{arg1, arg2})
+	fake.sendMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeMetronIngressServer) SendCallCount() int {
+	fake.sendMutex.RLock()
+	defer fake.sendMutex.RUnlock()
+	return len(fake.sendArgsForCall)
+}
+
+func (fake *FakeMetronIngressServer) SendCalls(stub func(context.Context, *loggregator_v2.EnvelopeBatch) (*loggregator_v2.SendResponse, error)) {
+	fake.sendMutex.Lock()
+	defer fake.sendMutex.Unlock()
+	fake.SendStub = stub
+}
+
+func (fake *FakeMetronIngressServer) SendArgsForCall(i int) (context.Context, *loggregator_v2.EnvelopeBatch) {
+	fake.sendMutex.RLock()
+	defer fake.sendMutex.RUnlock()
+	argsForCall := fake.sendArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeMetronIngressServer) SendReturns(result1 *loggregator_v2.SendResponse, result2 error) {
+	fake.sendMutex.Lock()
+	defer fake.sendMutex.Unlock()
+	fake.SendStub = nil
+	fake.sendReturns = struct {
+		result1 *loggregator_v2.SendResponse
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeMetronIngressServer) SendReturnsOnCall(i int, result1 *loggregator_v2.SendResponse, result2 error) {
+	fake.sendMutex.Lock()
+	defer fake.sendMutex.Unlock()
+	fake.SendStub = nil
+	if fake.sendReturnsOnCall == nil {
+		fake.sendReturnsOnCall = make(map[int]struct {
+			result1 *loggregator_v2.SendResponse
+			result2 error
+		})
+	}
+	fake.sendReturnsOnCall[i] = struct {
+		result1 *loggregator_v2.SendResponse
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeMetronIngressServer) Sender(arg1 loggregator_v2.Ingress_SenderServer) error {
+	fake.senderMutex.Lock()
+	ret, specificReturn := fake.senderReturnsOnCall[len(fake.senderArgsForCall)]
+	fake.senderArgsForCall = append(fake.senderArgsForCall, struct {
+		arg1 loggregator_v2.Ingress_SenderServer
+	}{arg1})
+	stub := fake.SenderStub
+	fakeReturns := fake.senderReturns
+	fake.recordInvocation("Sender", []interface{}{arg1})
+	fake.senderMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeMetronIngressServer) SenderCallCount() int {
+	fake.senderMutex.RLock()
+	defer fake.senderMutex.RUnlock()
+	return len(fake.senderArgsForCall)
+}
+
+func (fake *FakeMetronIngressServer) SenderCalls(stub func(loggregator_v2.Ingress_SenderServer) error) {
+	fake.senderMutex.Lock()
+	defer fake.senderMutex.Unlock()
+	fake.SenderStub = stub
+}
+
+func (fake *FakeMetronIngressServer) SenderArgsForCall(i int) loggregator_v2.Ingress_SenderServer {
+	fake.senderMutex.RLock()
+	defer fake.senderMutex.RUnlock()
+	argsForCall := fake.senderArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeMetronIngressServer) SenderReturns(result1 error) {
+	fake.senderMutex.Lock()
+	defer fake.senderMutex.Unlock()
+	fake.SenderStub = nil
+	fake.senderReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeMetronIngressServer) SenderReturnsOnCall(i int, result1 error) {
+	fake.senderMutex.Lock()
+	defer fake.senderMutex.Unlock()
+	fake.SenderStub = nil
+	if fake.senderReturnsOnCall == nil {
+		fake.senderReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.senderReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeMetronIngressServer) MustEmbedUnimplementedIngressServerCallCount() int {
+	fake.mustEmbedUnimplementedIngressServerMutex.RLock()
+	defer fake.mustEmbedUnimplementedIngressServerMutex.RUnlock()
+	return len(fake.mustEmbedUnimplementedIngressServerArgsForCall)
+}
+
+func (fake *FakeMetronIngressServer) MustEmbedUnimplementedIngressServerCalls(stub func()) {
+	fake.mustEmbedUnimplementedIngressServerMutex.Lock()
+	defer fake.mustEmbedUnimplementedIngressServerMutex.Unlock()
+	fake.mustEmbedUnimplementedIngressServerStub = stub
+}
+
+func (fake *FakeMetronIngressServer) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.batchSenderMutex.RLock()
+	defer fake.batchSenderMutex.RUnlock()
+	fake.sendMutex.RLock()
+	defer fake.sendMutex.RUnlock()
+	fake.senderMutex.RLock()
+	defer fake.senderMutex.RUnlock()
+	fake.mustEmbedUnimplementedIngressServerMutex.RLock()
+	defer fake.mustEmbedUnimplementedIngressServerMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeMetronIngressServer) 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 _ component_tests.MetronIngressServer = new(FakeMetronIngressServer)