sd

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 16, 2018 License: BSD-3-Clause Imports: 7 Imported by: 3

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewConsul 

func NewConsul(client *consul.Client) *consulSD

Types

type AsyncResolver 

type AsyncResolver interface {
	Resolver
	Shutdown()
	IsResolving() bool
}

type FakeRegistrar 

type FakeRegistrar struct {
	RegisterHook     func(string, string) merry.Error
	DeregisterHook   func(string) merry.Error
	AddCheckHook     func(string, *url.URL) merry.Error
	RemoveChecksHook func(string) merry.Error

	RegisterCalls     []*RegistrarRegisterInvocation
	DeregisterCalls   []*RegistrarDeregisterInvocation
	AddCheckCalls     []*RegistrarAddCheckInvocation
	RemoveChecksCalls []*RegistrarRemoveChecksInvocation
}

FakeRegistrar is a mock implementation of Registrar for testing. Use it in your tests as in this example: 

package example

func TestWithRegistrar(t *testing.T) {
	f := &sd.FakeRegistrar{
		RegisterHook: func(serviceID string, addr string) (ident1 merry.Error) {
			// ensure parameters meet expections, signal errors using t, etc
			return
		},
	}

	// test code goes here ...

	// assert state of FakeRegister ...
	f.AssertRegisterCalledOnce(t)
}

Create anonymous function implementations for only those interface methods that should be called in the code under test. This will force a panic if any unexpected calls are made to FakeRegister.

func NewFakeRegistrarDefaultError 

func NewFakeRegistrarDefaultError(t RegistrarTestingT) *FakeRegistrar

NewFakeRegistrarDefaultError returns an instance of FakeRegistrar with all hooks configured to call t.Error

func NewFakeRegistrarDefaultFatal 

func NewFakeRegistrarDefaultFatal(t RegistrarTestingT) *FakeRegistrar

NewFakeRegistrarDefaultFatal returns an instance of FakeRegistrar with all hooks configured to call t.Fatal

func NewFakeRegistrarDefaultPanic 

func NewFakeRegistrarDefaultPanic() *FakeRegistrar

NewFakeRegistrarDefaultPanic returns an instance of FakeRegistrar with all hooks configured to panic

func (*FakeRegistrar) AddCheck 

func (_f13 *FakeRegistrar) AddCheck(service string, url *url.URL) (ident1 merry.Error)

func (*FakeRegistrar) AddCheckCalled 

func (f *FakeRegistrar) AddCheckCalled() bool

AddCheckCalled returns true if FakeRegistrar.AddCheck was called

func (*FakeRegistrar) AddCheckCalledN 

func (f *FakeRegistrar) AddCheckCalledN(n int) bool

AddCheckCalledN returns true if FakeRegistrar.AddCheck was called at least n times

func (*FakeRegistrar) AddCheckCalledOnce 

func (f *FakeRegistrar) AddCheckCalledOnce() bool

AddCheckCalledOnce returns true if FakeRegistrar.AddCheck was called exactly once

func (*FakeRegistrar) AddCheckCalledOnceWith 

func (_f16 *FakeRegistrar) AddCheckCalledOnceWith(service string, url *url.URL) bool

AddCheckCalledOnceWith returns true if FakeRegistrar.AddCheck was called exactly once with the given values

func (*FakeRegistrar) AddCheckCalledWith 

func (_f14 *FakeRegistrar) AddCheckCalledWith(service string, url *url.URL) (found bool)

AddCheckCalledWith returns true if FakeRegistrar.AddCheck was called with the given values

func (*FakeRegistrar) AddCheckNotCalled 

func (f *FakeRegistrar) AddCheckNotCalled() bool

AddCheckNotCalled returns true if FakeRegistrar.AddCheck was not called

func (*FakeRegistrar) AddCheckResultsForCall 

func (_f18 *FakeRegistrar) AddCheckResultsForCall(service string, url *url.URL) (ident1 merry.Error, found bool)

AddCheckResultsForCall returns the result values for the first call to FakeRegistrar.AddCheck with the given values

func (*FakeRegistrar) AssertAddCheckCalled 

func (f *FakeRegistrar) AssertAddCheckCalled(t RegistrarTestingT)

AssertAddCheckCalled calls t.Error if FakeRegistrar.AddCheck was not called

func (*FakeRegistrar) AssertAddCheckCalledN 

func (f *FakeRegistrar) AssertAddCheckCalledN(t RegistrarTestingT, n int)

AssertAddCheckCalledN calls t.Error if FakeRegistrar.AddCheck was called less than n times

func (*FakeRegistrar) AssertAddCheckCalledOnce 

func (f *FakeRegistrar) AssertAddCheckCalledOnce(t RegistrarTestingT)

AssertAddCheckCalledOnce calls t.Error if FakeRegistrar.AddCheck was not called exactly once

func (*FakeRegistrar) AssertAddCheckCalledOnceWith 

func (_f17 *FakeRegistrar) AssertAddCheckCalledOnceWith(t RegistrarTestingT, service string, url *url.URL)

AssertAddCheckCalledOnceWith calls t.Error if FakeRegistrar.AddCheck was not called exactly once with the given values

func (*FakeRegistrar) AssertAddCheckCalledWith 

func (_f15 *FakeRegistrar) AssertAddCheckCalledWith(t RegistrarTestingT, service string, url *url.URL)

AssertAddCheckCalledWith calls t.Error if FakeRegistrar.AddCheck was not called with the given values

func (*FakeRegistrar) AssertAddCheckNotCalled 

func (f *FakeRegistrar) AssertAddCheckNotCalled(t RegistrarTestingT)

AssertAddCheckNotCalled calls t.Error if FakeRegistrar.AddCheck was called

func (*FakeRegistrar) AssertDeregisterCalled 

func (f *FakeRegistrar) AssertDeregisterCalled(t RegistrarTestingT)

AssertDeregisterCalled calls t.Error if FakeRegistrar.Deregister was not called

func (*FakeRegistrar) AssertDeregisterCalledN 

func (f *FakeRegistrar) AssertDeregisterCalledN(t RegistrarTestingT, n int)

AssertDeregisterCalledN calls t.Error if FakeRegistrar.Deregister was called less than n times

func (*FakeRegistrar) AssertDeregisterCalledOnce 

func (f *FakeRegistrar) AssertDeregisterCalledOnce(t RegistrarTestingT)

AssertDeregisterCalledOnce calls t.Error if FakeRegistrar.Deregister was not called exactly once

func (*FakeRegistrar) AssertDeregisterCalledOnceWith 

func (_f11 *FakeRegistrar) AssertDeregisterCalledOnceWith(t RegistrarTestingT, serviceID string)

AssertDeregisterCalledOnceWith calls t.Error if FakeRegistrar.Deregister was not called exactly once with the given values

func (*FakeRegistrar) AssertDeregisterCalledWith 

func (_f9 *FakeRegistrar) AssertDeregisterCalledWith(t RegistrarTestingT, serviceID string)

AssertDeregisterCalledWith calls t.Error if FakeRegistrar.Deregister was not called with the given values

func (*FakeRegistrar) AssertDeregisterNotCalled 

func (f *FakeRegistrar) AssertDeregisterNotCalled(t RegistrarTestingT)

AssertDeregisterNotCalled calls t.Error if FakeRegistrar.Deregister was called

func (*FakeRegistrar) AssertRegisterCalled 

func (f *FakeRegistrar) AssertRegisterCalled(t RegistrarTestingT)

AssertRegisterCalled calls t.Error if FakeRegistrar.Register was not called

func (*FakeRegistrar) AssertRegisterCalledN 

func (f *FakeRegistrar) AssertRegisterCalledN(t RegistrarTestingT, n int)

AssertRegisterCalledN calls t.Error if FakeRegistrar.Register was called less than n times

func (*FakeRegistrar) AssertRegisterCalledOnce 

func (f *FakeRegistrar) AssertRegisterCalledOnce(t RegistrarTestingT)

AssertRegisterCalledOnce calls t.Error if FakeRegistrar.Register was not called exactly once

func (*FakeRegistrar) AssertRegisterCalledOnceWith 

func (_f5 *FakeRegistrar) AssertRegisterCalledOnceWith(t RegistrarTestingT, serviceID string, addr string)

AssertRegisterCalledOnceWith calls t.Error if FakeRegistrar.Register was not called exactly once with the given values

func (*FakeRegistrar) AssertRegisterCalledWith 

func (_f3 *FakeRegistrar) AssertRegisterCalledWith(t RegistrarTestingT, serviceID string, addr string)

AssertRegisterCalledWith calls t.Error if FakeRegistrar.Register was not called with the given values

func (*FakeRegistrar) AssertRegisterNotCalled 

func (f *FakeRegistrar) AssertRegisterNotCalled(t RegistrarTestingT)

AssertRegisterNotCalled calls t.Error if FakeRegistrar.Register was called

func (*FakeRegistrar) AssertRemoveChecksCalled 

func (f *FakeRegistrar) AssertRemoveChecksCalled(t RegistrarTestingT)

AssertRemoveChecksCalled calls t.Error if FakeRegistrar.RemoveChecks was not called

func (*FakeRegistrar) AssertRemoveChecksCalledN 

func (f *FakeRegistrar) AssertRemoveChecksCalledN(t RegistrarTestingT, n int)

AssertRemoveChecksCalledN calls t.Error if FakeRegistrar.RemoveChecks was called less than n times

func (*FakeRegistrar) AssertRemoveChecksCalledOnce 

func (f *FakeRegistrar) AssertRemoveChecksCalledOnce(t RegistrarTestingT)

AssertRemoveChecksCalledOnce calls t.Error if FakeRegistrar.RemoveChecks was not called exactly once

func (*FakeRegistrar) AssertRemoveChecksCalledOnceWith 

func (_f23 *FakeRegistrar) AssertRemoveChecksCalledOnceWith(t RegistrarTestingT, service string)

AssertRemoveChecksCalledOnceWith calls t.Error if FakeRegistrar.RemoveChecks was not called exactly once with the given values

func (*FakeRegistrar) AssertRemoveChecksCalledWith 

func (_f21 *FakeRegistrar) AssertRemoveChecksCalledWith(t RegistrarTestingT, service string)

AssertRemoveChecksCalledWith calls t.Error if FakeRegistrar.RemoveChecks was not called with the given values

func (*FakeRegistrar) AssertRemoveChecksNotCalled 

func (f *FakeRegistrar) AssertRemoveChecksNotCalled(t RegistrarTestingT)

AssertRemoveChecksNotCalled calls t.Error if FakeRegistrar.RemoveChecks was called

func (*FakeRegistrar) Deregister 

func (_f7 *FakeRegistrar) Deregister(serviceID string) (ident1 merry.Error)

func (*FakeRegistrar) DeregisterCalled 

func (f *FakeRegistrar) DeregisterCalled() bool

DeregisterCalled returns true if FakeRegistrar.Deregister was called

func (*FakeRegistrar) DeregisterCalledN 

func (f *FakeRegistrar) DeregisterCalledN(n int) bool

DeregisterCalledN returns true if FakeRegistrar.Deregister was called at least n times

func (*FakeRegistrar) DeregisterCalledOnce 

func (f *FakeRegistrar) DeregisterCalledOnce() bool

DeregisterCalledOnce returns true if FakeRegistrar.Deregister was called exactly once

func (*FakeRegistrar) DeregisterCalledOnceWith 

func (_f10 *FakeRegistrar) DeregisterCalledOnceWith(serviceID string) bool

DeregisterCalledOnceWith returns true if FakeRegistrar.Deregister was called exactly once with the given values

func (*FakeRegistrar) DeregisterCalledWith 

func (_f8 *FakeRegistrar) DeregisterCalledWith(serviceID string) (found bool)

DeregisterCalledWith returns true if FakeRegistrar.Deregister was called with the given values

func (*FakeRegistrar) DeregisterNotCalled 

func (f *FakeRegistrar) DeregisterNotCalled() bool

DeregisterNotCalled returns true if FakeRegistrar.Deregister was not called

func (*FakeRegistrar) DeregisterResultsForCall 

func (_f12 *FakeRegistrar) DeregisterResultsForCall(serviceID string) (ident1 merry.Error, found bool)

DeregisterResultsForCall returns the result values for the first call to FakeRegistrar.Deregister with the given values

func (*FakeRegistrar) Register 

func (_f1 *FakeRegistrar) Register(serviceID string, addr string) (ident1 merry.Error)

func (*FakeRegistrar) RegisterCalled 

func (f *FakeRegistrar) RegisterCalled() bool

RegisterCalled returns true if FakeRegistrar.Register was called

func (*FakeRegistrar) RegisterCalledN 

func (f *FakeRegistrar) RegisterCalledN(n int) bool

RegisterCalledN returns true if FakeRegistrar.Register was called at least n times

func (*FakeRegistrar) RegisterCalledOnce 

func (f *FakeRegistrar) RegisterCalledOnce() bool

RegisterCalledOnce returns true if FakeRegistrar.Register was called exactly once

func (*FakeRegistrar) RegisterCalledOnceWith 

func (_f4 *FakeRegistrar) RegisterCalledOnceWith(serviceID string, addr string) bool

RegisterCalledOnceWith returns true if FakeRegistrar.Register was called exactly once with the given values

func (*FakeRegistrar) RegisterCalledWith 

func (_f2 *FakeRegistrar) RegisterCalledWith(serviceID string, addr string) (found bool)

RegisterCalledWith returns true if FakeRegistrar.Register was called with the given values

func (*FakeRegistrar) RegisterNotCalled 

func (f *FakeRegistrar) RegisterNotCalled() bool

RegisterNotCalled returns true if FakeRegistrar.Register was not called

func (*FakeRegistrar) RegisterResultsForCall 

func (_f6 *FakeRegistrar) RegisterResultsForCall(serviceID string, addr string) (ident1 merry.Error, found bool)

RegisterResultsForCall returns the result values for the first call to FakeRegistrar.Register with the given values

func (*FakeRegistrar) RemoveChecks 

func (_f19 *FakeRegistrar) RemoveChecks(service string) (ident1 merry.Error)

func (*FakeRegistrar) RemoveChecksCalled 

func (f *FakeRegistrar) RemoveChecksCalled() bool

RemoveChecksCalled returns true if FakeRegistrar.RemoveChecks was called

func (*FakeRegistrar) RemoveChecksCalledN 

func (f *FakeRegistrar) RemoveChecksCalledN(n int) bool

RemoveChecksCalledN returns true if FakeRegistrar.RemoveChecks was called at least n times

func (*FakeRegistrar) RemoveChecksCalledOnce 

func (f *FakeRegistrar) RemoveChecksCalledOnce() bool

RemoveChecksCalledOnce returns true if FakeRegistrar.RemoveChecks was called exactly once

func (*FakeRegistrar) RemoveChecksCalledOnceWith 

func (_f22 *FakeRegistrar) RemoveChecksCalledOnceWith(service string) bool

RemoveChecksCalledOnceWith returns true if FakeRegistrar.RemoveChecks was called exactly once with the given values

func (*FakeRegistrar) RemoveChecksCalledWith 

func (_f20 *FakeRegistrar) RemoveChecksCalledWith(service string) (found bool)

RemoveChecksCalledWith returns true if FakeRegistrar.RemoveChecks was called with the given values

func (*FakeRegistrar) RemoveChecksNotCalled 

func (f *FakeRegistrar) RemoveChecksNotCalled() bool

RemoveChecksNotCalled returns true if FakeRegistrar.RemoveChecks was not called

func (*FakeRegistrar) RemoveChecksResultsForCall 

func (_f24 *FakeRegistrar) RemoveChecksResultsForCall(service string) (ident1 merry.Error, found bool)

RemoveChecksResultsForCall returns the result values for the first call to FakeRegistrar.RemoveChecks with the given values

func (*FakeRegistrar) Reset 

func (f *FakeRegistrar) Reset()

type FakeResolver 

type FakeResolver struct {
	ResolveHook func(string) ([]string, merry.Error)

	ResolveCalls []*ResolverResolveInvocation
}

FakeResolver is a mock implementation of Resolver for testing. Use it in your tests as in this example: 

package example

func TestWithResolver(t *testing.T) {
	f := &sd.FakeResolver{
		ResolveHook: func(name string) (ident1 []string, ident2 merry.Error) {
			// ensure parameters meet expections, signal errors using t, etc
			return
		},
	}

	// test code goes here ...

	// assert state of FakeResolve ...
	f.AssertResolveCalledOnce(t)
}

Create anonymous function implementations for only those interface methods that should be called in the code under test. This will force a panic if any unexpected calls are made to FakeResolve.

func NewFakeResolverDefaultError 

func NewFakeResolverDefaultError(t ResolverTestingT) *FakeResolver

NewFakeResolverDefaultError returns an instance of FakeResolver with all hooks configured to call t.Error

func NewFakeResolverDefaultFatal 

func NewFakeResolverDefaultFatal(t ResolverTestingT) *FakeResolver

NewFakeResolverDefaultFatal returns an instance of FakeResolver with all hooks configured to call t.Fatal

func NewFakeResolverDefaultPanic 

func NewFakeResolverDefaultPanic() *FakeResolver

NewFakeResolverDefaultPanic returns an instance of FakeResolver with all hooks configured to panic

func (*FakeResolver) AssertResolveCalled 

func (f *FakeResolver) AssertResolveCalled(t ResolverTestingT)

AssertResolveCalled calls t.Error if FakeResolver.Resolve was not called

func (*FakeResolver) AssertResolveCalledN 

func (f *FakeResolver) AssertResolveCalledN(t ResolverTestingT, n int)

AssertResolveCalledN calls t.Error if FakeResolver.Resolve was called less than n times

func (*FakeResolver) AssertResolveCalledOnce 

func (f *FakeResolver) AssertResolveCalledOnce(t ResolverTestingT)

AssertResolveCalledOnce calls t.Error if FakeResolver.Resolve was not called exactly once

func (*FakeResolver) AssertResolveCalledOnceWith 

func (_f5 *FakeResolver) AssertResolveCalledOnceWith(t ResolverTestingT, name string)

AssertResolveCalledOnceWith calls t.Error if FakeResolver.Resolve was not called exactly once with the given values

func (*FakeResolver) AssertResolveCalledWith 

func (_f3 *FakeResolver) AssertResolveCalledWith(t ResolverTestingT, name string)

AssertResolveCalledWith calls t.Error if FakeResolver.Resolve was not called with the given values

func (*FakeResolver) AssertResolveNotCalled 

func (f *FakeResolver) AssertResolveNotCalled(t ResolverTestingT)

AssertResolveNotCalled calls t.Error if FakeResolver.Resolve was called

func (*FakeResolver) Reset 

func (f *FakeResolver) Reset()

func (*FakeResolver) Resolve 

func (_f1 *FakeResolver) Resolve(name string) (ident1 []string, ident2 merry.Error)

func (*FakeResolver) ResolveCalled 

func (f *FakeResolver) ResolveCalled() bool

ResolveCalled returns true if FakeResolver.Resolve was called

func (*FakeResolver) ResolveCalledN 

func (f *FakeResolver) ResolveCalledN(n int) bool

ResolveCalledN returns true if FakeResolver.Resolve was called at least n times

func (*FakeResolver) ResolveCalledOnce 

func (f *FakeResolver) ResolveCalledOnce() bool

ResolveCalledOnce returns true if FakeResolver.Resolve was called exactly once

func (*FakeResolver) ResolveCalledOnceWith 

func (_f4 *FakeResolver) ResolveCalledOnceWith(name string) bool

ResolveCalledOnceWith returns true if FakeResolver.Resolve was called exactly once with the given values

func (*FakeResolver) ResolveCalledWith 

func (_f2 *FakeResolver) ResolveCalledWith(name string) (found bool)

ResolveCalledWith returns true if FakeResolver.Resolve was called with the given values

func (*FakeResolver) ResolveNotCalled 

func (f *FakeResolver) ResolveNotCalled() bool

ResolveNotCalled returns true if FakeResolver.Resolve was not called

func (*FakeResolver) ResolveResultsForCall 

func (_f6 *FakeResolver) ResolveResultsForCall(name string) (ident1 []string, ident2 merry.Error, found bool)

ResolveResultsForCall returns the result values for the first call to FakeResolver.Resolve with the given values

type FakeconsulRegistry 

type FakeconsulRegistry struct {
	ServiceRegisterHook   func(*consul.AgentServiceRegistration) error
	ServiceDeregisterHook func(string) error
	CheckRegisterHook     func(*consul.AgentCheckRegistration) error
	CheckDeregisterHook   func(string) error

	ServiceRegisterCalls   []*consulRegistryServiceRegisterInvocation
	ServiceDeregisterCalls []*consulRegistryServiceDeregisterInvocation
	CheckRegisterCalls     []*consulRegistryCheckRegisterInvocation
	CheckDeregisterCalls   []*consulRegistryCheckDeregisterInvocation
}

FakeconsulRegistry is a mock implementation of consulRegistry for testing. Use it in your tests as in this example: 

package example

func TestWithconsulRegistry(t *testing.T) {
	f := &sd.FakeconsulRegistry{
		ServiceRegisterHook: func(ident1 *consul.AgentServiceRegistration) (ident2 error) {
			// ensure parameters meet expections, signal errors using t, etc
			return
		},
	}

	// test code goes here ...

	// assert state of FakeServiceRegister ...
	f.AssertServiceRegisterCalledOnce(t)
}

Create anonymous function implementations for only those interface methods that should be called in the code under test. This will force a panic if any unexpected calls are made to FakeServiceRegister.

func NewFakeconsulRegistryDefaultError 

func NewFakeconsulRegistryDefaultError(t consulRegistryTestingT) *FakeconsulRegistry

NewFakeconsulRegistryDefaultError returns an instance of FakeconsulRegistry with all hooks configured to call t.Error

func NewFakeconsulRegistryDefaultFatal 

func NewFakeconsulRegistryDefaultFatal(t consulRegistryTestingT) *FakeconsulRegistry

NewFakeconsulRegistryDefaultFatal returns an instance of FakeconsulRegistry with all hooks configured to call t.Fatal

func NewFakeconsulRegistryDefaultPanic 

func NewFakeconsulRegistryDefaultPanic() *FakeconsulRegistry

NewFakeconsulRegistryDefaultPanic returns an instance of FakeconsulRegistry with all hooks configured to panic

func (*FakeconsulRegistry) AssertCheckDeregisterCalled 

func (f *FakeconsulRegistry) AssertCheckDeregisterCalled(t consulRegistryTestingT)

AssertCheckDeregisterCalled calls t.Error if FakeconsulRegistry.CheckDeregister was not called

func (*FakeconsulRegistry) AssertCheckDeregisterCalledN 

func (f *FakeconsulRegistry) AssertCheckDeregisterCalledN(t consulRegistryTestingT, n int)

AssertCheckDeregisterCalledN calls t.Error if FakeconsulRegistry.CheckDeregister was called less than n times

func (*FakeconsulRegistry) AssertCheckDeregisterCalledOnce 

func (f *FakeconsulRegistry) AssertCheckDeregisterCalledOnce(t consulRegistryTestingT)

AssertCheckDeregisterCalledOnce calls t.Error if FakeconsulRegistry.CheckDeregister was not called exactly once

func (*FakeconsulRegistry) AssertCheckDeregisterCalledOnceWith 

func (_f23 *FakeconsulRegistry) AssertCheckDeregisterCalledOnceWith(t consulRegistryTestingT, ident1 string)

AssertCheckDeregisterCalledOnceWith calls t.Error if FakeconsulRegistry.CheckDeregister was not called exactly once with the given values

func (*FakeconsulRegistry) AssertCheckDeregisterCalledWith 

func (_f21 *FakeconsulRegistry) AssertCheckDeregisterCalledWith(t consulRegistryTestingT, ident1 string)

AssertCheckDeregisterCalledWith calls t.Error if FakeconsulRegistry.CheckDeregister was not called with the given values

func (*FakeconsulRegistry) AssertCheckDeregisterNotCalled 

func (f *FakeconsulRegistry) AssertCheckDeregisterNotCalled(t consulRegistryTestingT)

AssertCheckDeregisterNotCalled calls t.Error if FakeconsulRegistry.CheckDeregister was called

func (*FakeconsulRegistry) AssertCheckRegisterCalled 

func (f *FakeconsulRegistry) AssertCheckRegisterCalled(t consulRegistryTestingT)

AssertCheckRegisterCalled calls t.Error if FakeconsulRegistry.CheckRegister was not called

func (*FakeconsulRegistry) AssertCheckRegisterCalledN 

func (f *FakeconsulRegistry) AssertCheckRegisterCalledN(t consulRegistryTestingT, n int)

AssertCheckRegisterCalledN calls t.Error if FakeconsulRegistry.CheckRegister was called less than n times

func (*FakeconsulRegistry) AssertCheckRegisterCalledOnce 

func (f *FakeconsulRegistry) AssertCheckRegisterCalledOnce(t consulRegistryTestingT)

AssertCheckRegisterCalledOnce calls t.Error if FakeconsulRegistry.CheckRegister was not called exactly once

func (*FakeconsulRegistry) AssertCheckRegisterCalledOnceWith 

func (_f17 *FakeconsulRegistry) AssertCheckRegisterCalledOnceWith(t consulRegistryTestingT, ident1 *consul.AgentCheckRegistration)

AssertCheckRegisterCalledOnceWith calls t.Error if FakeconsulRegistry.CheckRegister was not called exactly once with the given values

func (*FakeconsulRegistry) AssertCheckRegisterCalledWith 

func (_f15 *FakeconsulRegistry) AssertCheckRegisterCalledWith(t consulRegistryTestingT, ident1 *consul.AgentCheckRegistration)

AssertCheckRegisterCalledWith calls t.Error if FakeconsulRegistry.CheckRegister was not called with the given values

func (*FakeconsulRegistry) AssertCheckRegisterNotCalled 

func (f *FakeconsulRegistry) AssertCheckRegisterNotCalled(t consulRegistryTestingT)

AssertCheckRegisterNotCalled calls t.Error if FakeconsulRegistry.CheckRegister was called

func (*FakeconsulRegistry) AssertServiceDeregisterCalled 

func (f *FakeconsulRegistry) AssertServiceDeregisterCalled(t consulRegistryTestingT)

AssertServiceDeregisterCalled calls t.Error if FakeconsulRegistry.ServiceDeregister was not called

func (*FakeconsulRegistry) AssertServiceDeregisterCalledN 

func (f *FakeconsulRegistry) AssertServiceDeregisterCalledN(t consulRegistryTestingT, n int)

AssertServiceDeregisterCalledN calls t.Error if FakeconsulRegistry.ServiceDeregister was called less than n times

func (*FakeconsulRegistry) AssertServiceDeregisterCalledOnce 

func (f *FakeconsulRegistry) AssertServiceDeregisterCalledOnce(t consulRegistryTestingT)

AssertServiceDeregisterCalledOnce calls t.Error if FakeconsulRegistry.ServiceDeregister was not called exactly once

func (*FakeconsulRegistry) AssertServiceDeregisterCalledOnceWith 

func (_f11 *FakeconsulRegistry) AssertServiceDeregisterCalledOnceWith(t consulRegistryTestingT, ident1 string)

AssertServiceDeregisterCalledOnceWith calls t.Error if FakeconsulRegistry.ServiceDeregister was not called exactly once with the given values

func (*FakeconsulRegistry) AssertServiceDeregisterCalledWith 

func (_f9 *FakeconsulRegistry) AssertServiceDeregisterCalledWith(t consulRegistryTestingT, ident1 string)

AssertServiceDeregisterCalledWith calls t.Error if FakeconsulRegistry.ServiceDeregister was not called with the given values

func (*FakeconsulRegistry) AssertServiceDeregisterNotCalled 

func (f *FakeconsulRegistry) AssertServiceDeregisterNotCalled(t consulRegistryTestingT)

AssertServiceDeregisterNotCalled calls t.Error if FakeconsulRegistry.ServiceDeregister was called

func (*FakeconsulRegistry) AssertServiceRegisterCalled 

func (f *FakeconsulRegistry) AssertServiceRegisterCalled(t consulRegistryTestingT)

AssertServiceRegisterCalled calls t.Error if FakeconsulRegistry.ServiceRegister was not called

func (*FakeconsulRegistry) AssertServiceRegisterCalledN 

func (f *FakeconsulRegistry) AssertServiceRegisterCalledN(t consulRegistryTestingT, n int)

AssertServiceRegisterCalledN calls t.Error if FakeconsulRegistry.ServiceRegister was called less than n times

func (*FakeconsulRegistry) AssertServiceRegisterCalledOnce 

func (f *FakeconsulRegistry) AssertServiceRegisterCalledOnce(t consulRegistryTestingT)

AssertServiceRegisterCalledOnce calls t.Error if FakeconsulRegistry.ServiceRegister was not called exactly once

func (*FakeconsulRegistry) AssertServiceRegisterCalledOnceWith 

func (_f5 *FakeconsulRegistry) AssertServiceRegisterCalledOnceWith(t consulRegistryTestingT, ident1 *consul.AgentServiceRegistration)

AssertServiceRegisterCalledOnceWith calls t.Error if FakeconsulRegistry.ServiceRegister was not called exactly once with the given values

func (*FakeconsulRegistry) AssertServiceRegisterCalledWith 

func (_f3 *FakeconsulRegistry) AssertServiceRegisterCalledWith(t consulRegistryTestingT, ident1 *consul.AgentServiceRegistration)

AssertServiceRegisterCalledWith calls t.Error if FakeconsulRegistry.ServiceRegister was not called with the given values

func (*FakeconsulRegistry) AssertServiceRegisterNotCalled 

func (f *FakeconsulRegistry) AssertServiceRegisterNotCalled(t consulRegistryTestingT)

AssertServiceRegisterNotCalled calls t.Error if FakeconsulRegistry.ServiceRegister was called

func (*FakeconsulRegistry) CheckDeregister 

func (_f19 *FakeconsulRegistry) CheckDeregister(ident1 string) (ident2 error)

func (*FakeconsulRegistry) CheckDeregisterCalled 

func (f *FakeconsulRegistry) CheckDeregisterCalled() bool

CheckDeregisterCalled returns true if FakeconsulRegistry.CheckDeregister was called

func (*FakeconsulRegistry) CheckDeregisterCalledN 

func (f *FakeconsulRegistry) CheckDeregisterCalledN(n int) bool

CheckDeregisterCalledN returns true if FakeconsulRegistry.CheckDeregister was called at least n times

func (*FakeconsulRegistry) CheckDeregisterCalledOnce 

func (f *FakeconsulRegistry) CheckDeregisterCalledOnce() bool

CheckDeregisterCalledOnce returns true if FakeconsulRegistry.CheckDeregister was called exactly once

func (*FakeconsulRegistry) CheckDeregisterCalledOnceWith 

func (_f22 *FakeconsulRegistry) CheckDeregisterCalledOnceWith(ident1 string) bool

CheckDeregisterCalledOnceWith returns true if FakeconsulRegistry.CheckDeregister was called exactly once with the given values

func (*FakeconsulRegistry) CheckDeregisterCalledWith 

func (_f20 *FakeconsulRegistry) CheckDeregisterCalledWith(ident1 string) (found bool)

CheckDeregisterCalledWith returns true if FakeconsulRegistry.CheckDeregister was called with the given values

func (*FakeconsulRegistry) CheckDeregisterNotCalled 

func (f *FakeconsulRegistry) CheckDeregisterNotCalled() bool

CheckDeregisterNotCalled returns true if FakeconsulRegistry.CheckDeregister was not called

func (*FakeconsulRegistry) CheckDeregisterResultsForCall 

func (_f24 *FakeconsulRegistry) CheckDeregisterResultsForCall(ident1 string) (ident2 error, found bool)

CheckDeregisterResultsForCall returns the result values for the first call to FakeconsulRegistry.CheckDeregister with the given values

func (*FakeconsulRegistry) CheckRegister 

func (_f13 *FakeconsulRegistry) CheckRegister(ident1 *consul.AgentCheckRegistration) (ident2 error)

func (*FakeconsulRegistry) CheckRegisterCalled 

func (f *FakeconsulRegistry) CheckRegisterCalled() bool

CheckRegisterCalled returns true if FakeconsulRegistry.CheckRegister was called

func (*FakeconsulRegistry) CheckRegisterCalledN 

func (f *FakeconsulRegistry) CheckRegisterCalledN(n int) bool

CheckRegisterCalledN returns true if FakeconsulRegistry.CheckRegister was called at least n times

func (*FakeconsulRegistry) CheckRegisterCalledOnce 

func (f *FakeconsulRegistry) CheckRegisterCalledOnce() bool

CheckRegisterCalledOnce returns true if FakeconsulRegistry.CheckRegister was called exactly once

func (*FakeconsulRegistry) CheckRegisterCalledOnceWith 

func (_f16 *FakeconsulRegistry) CheckRegisterCalledOnceWith(ident1 *consul.AgentCheckRegistration) bool

CheckRegisterCalledOnceWith returns true if FakeconsulRegistry.CheckRegister was called exactly once with the given values

func (*FakeconsulRegistry) CheckRegisterCalledWith 

func (_f14 *FakeconsulRegistry) CheckRegisterCalledWith(ident1 *consul.AgentCheckRegistration) (found bool)

CheckRegisterCalledWith returns true if FakeconsulRegistry.CheckRegister was called with the given values

func (*FakeconsulRegistry) CheckRegisterNotCalled 

func (f *FakeconsulRegistry) CheckRegisterNotCalled() bool

CheckRegisterNotCalled returns true if FakeconsulRegistry.CheckRegister was not called

func (*FakeconsulRegistry) CheckRegisterResultsForCall 

func (_f18 *FakeconsulRegistry) CheckRegisterResultsForCall(ident1 *consul.AgentCheckRegistration) (ident2 error, found bool)

CheckRegisterResultsForCall returns the result values for the first call to FakeconsulRegistry.CheckRegister with the given values

func (*FakeconsulRegistry) Reset 

func (f *FakeconsulRegistry) Reset()

func (*FakeconsulRegistry) ServiceDeregister 

func (_f7 *FakeconsulRegistry) ServiceDeregister(ident1 string) (ident2 error)

func (*FakeconsulRegistry) ServiceDeregisterCalled 

func (f *FakeconsulRegistry) ServiceDeregisterCalled() bool

ServiceDeregisterCalled returns true if FakeconsulRegistry.ServiceDeregister was called

func (*FakeconsulRegistry) ServiceDeregisterCalledN 

func (f *FakeconsulRegistry) ServiceDeregisterCalledN(n int) bool

ServiceDeregisterCalledN returns true if FakeconsulRegistry.ServiceDeregister was called at least n times

func (*FakeconsulRegistry) ServiceDeregisterCalledOnce 

func (f *FakeconsulRegistry) ServiceDeregisterCalledOnce() bool

ServiceDeregisterCalledOnce returns true if FakeconsulRegistry.ServiceDeregister was called exactly once

func (*FakeconsulRegistry) ServiceDeregisterCalledOnceWith 

func (_f10 *FakeconsulRegistry) ServiceDeregisterCalledOnceWith(ident1 string) bool

ServiceDeregisterCalledOnceWith returns true if FakeconsulRegistry.ServiceDeregister was called exactly once with the given values

func (*FakeconsulRegistry) ServiceDeregisterCalledWith 

func (_f8 *FakeconsulRegistry) ServiceDeregisterCalledWith(ident1 string) (found bool)

ServiceDeregisterCalledWith returns true if FakeconsulRegistry.ServiceDeregister was called with the given values

func (*FakeconsulRegistry) ServiceDeregisterNotCalled 

func (f *FakeconsulRegistry) ServiceDeregisterNotCalled() bool

ServiceDeregisterNotCalled returns true if FakeconsulRegistry.ServiceDeregister was not called

func (*FakeconsulRegistry) ServiceDeregisterResultsForCall 

func (_f12 *FakeconsulRegistry) ServiceDeregisterResultsForCall(ident1 string) (ident2 error, found bool)

ServiceDeregisterResultsForCall returns the result values for the first call to FakeconsulRegistry.ServiceDeregister with the given values

func (*FakeconsulRegistry) ServiceRegister 

func (_f1 *FakeconsulRegistry) ServiceRegister(ident1 *consul.AgentServiceRegistration) (ident2 error)

func (*FakeconsulRegistry) ServiceRegisterCalled 

func (f *FakeconsulRegistry) ServiceRegisterCalled() bool

ServiceRegisterCalled returns true if FakeconsulRegistry.ServiceRegister was called

func (*FakeconsulRegistry) ServiceRegisterCalledN 

func (f *FakeconsulRegistry) ServiceRegisterCalledN(n int) bool

ServiceRegisterCalledN returns true if FakeconsulRegistry.ServiceRegister was called at least n times

func (*FakeconsulRegistry) ServiceRegisterCalledOnce 

func (f *FakeconsulRegistry) ServiceRegisterCalledOnce() bool

ServiceRegisterCalledOnce returns true if FakeconsulRegistry.ServiceRegister was called exactly once

func (*FakeconsulRegistry) ServiceRegisterCalledOnceWith 

func (_f4 *FakeconsulRegistry) ServiceRegisterCalledOnceWith(ident1 *consul.AgentServiceRegistration) bool

ServiceRegisterCalledOnceWith returns true if FakeconsulRegistry.ServiceRegister was called exactly once with the given values

func (*FakeconsulRegistry) ServiceRegisterCalledWith 

func (_f2 *FakeconsulRegistry) ServiceRegisterCalledWith(ident1 *consul.AgentServiceRegistration) (found bool)

ServiceRegisterCalledWith returns true if FakeconsulRegistry.ServiceRegister was called with the given values

func (*FakeconsulRegistry) ServiceRegisterNotCalled 

func (f *FakeconsulRegistry) ServiceRegisterNotCalled() bool

ServiceRegisterNotCalled returns true if FakeconsulRegistry.ServiceRegister was not called

func (*FakeconsulRegistry) ServiceRegisterResultsForCall 

func (_f6 *FakeconsulRegistry) ServiceRegisterResultsForCall(ident1 *consul.AgentServiceRegistration) (ident2 error, found bool)

ServiceRegisterResultsForCall returns the result values for the first call to FakeconsulRegistry.ServiceRegister with the given values

type FakeconsulResolver 

type FakeconsulResolver struct {
	ServiceHook func(string, string, bool, *consul.QueryOptions) ([]*consul.ServiceEntry, *consul.QueryMeta, error)

	ServiceCalls []*consulResolverServiceInvocation
}

FakeconsulResolver is a mock implementation of consulResolver for testing. Use it in your tests as in this example: 

package example

func TestWithconsulResolver(t *testing.T) {
	f := &sd.FakeconsulResolver{
		ServiceHook: func(service string, tag string, passingOnly bool, q *consul.QueryOptions) (ident1 []*consul.ServiceEntry, ident2 *consul.QueryMeta, ident3 error) {
			// ensure parameters meet expections, signal errors using t, etc
			return
		},
	}

	// test code goes here ...

	// assert state of FakeService ...
	f.AssertServiceCalledOnce(t)
}

Create anonymous function implementations for only those interface methods that should be called in the code under test. This will force a panic if any unexpected calls are made to FakeService.

func NewFakeconsulResolverDefaultError 

func NewFakeconsulResolverDefaultError(t consulResolverTestingT) *FakeconsulResolver

NewFakeconsulResolverDefaultError returns an instance of FakeconsulResolver with all hooks configured to call t.Error

func NewFakeconsulResolverDefaultFatal 

func NewFakeconsulResolverDefaultFatal(t consulResolverTestingT) *FakeconsulResolver

NewFakeconsulResolverDefaultFatal returns an instance of FakeconsulResolver with all hooks configured to call t.Fatal

func NewFakeconsulResolverDefaultPanic 

func NewFakeconsulResolverDefaultPanic() *FakeconsulResolver

NewFakeconsulResolverDefaultPanic returns an instance of FakeconsulResolver with all hooks configured to panic

func (*FakeconsulResolver) AssertServiceCalled 

func (f *FakeconsulResolver) AssertServiceCalled(t consulResolverTestingT)

AssertServiceCalled calls t.Error if FakeconsulResolver.Service was not called

func (*FakeconsulResolver) AssertServiceCalledN 

func (f *FakeconsulResolver) AssertServiceCalledN(t consulResolverTestingT, n int)

AssertServiceCalledN calls t.Error if FakeconsulResolver.Service was called less than n times

func (*FakeconsulResolver) AssertServiceCalledOnce 

func (f *FakeconsulResolver) AssertServiceCalledOnce(t consulResolverTestingT)

AssertServiceCalledOnce calls t.Error if FakeconsulResolver.Service was not called exactly once

func (*FakeconsulResolver) AssertServiceCalledOnceWith 

func (_f5 *FakeconsulResolver) AssertServiceCalledOnceWith(t consulResolverTestingT, service string, tag string, passingOnly bool, q *consul.QueryOptions)

AssertServiceCalledOnceWith calls t.Error if FakeconsulResolver.Service was not called exactly once with the given values

func (*FakeconsulResolver) AssertServiceCalledWith 

func (_f3 *FakeconsulResolver) AssertServiceCalledWith(t consulResolverTestingT, service string, tag string, passingOnly bool, q *consul.QueryOptions)

AssertServiceCalledWith calls t.Error if FakeconsulResolver.Service was not called with the given values

func (*FakeconsulResolver) AssertServiceNotCalled 

func (f *FakeconsulResolver) AssertServiceNotCalled(t consulResolverTestingT)

AssertServiceNotCalled calls t.Error if FakeconsulResolver.Service was called

func (*FakeconsulResolver) Reset 

func (f *FakeconsulResolver) Reset()

func (*FakeconsulResolver) Service 

func (_f1 *FakeconsulResolver) Service(service string, tag string, passingOnly bool, q *consul.QueryOptions) (ident1 []*consul.ServiceEntry, ident2 *consul.QueryMeta, ident3 error)

func (*FakeconsulResolver) ServiceCalled 

func (f *FakeconsulResolver) ServiceCalled() bool

ServiceCalled returns true if FakeconsulResolver.Service was called

func (*FakeconsulResolver) ServiceCalledN 

func (f *FakeconsulResolver) ServiceCalledN(n int) bool

ServiceCalledN returns true if FakeconsulResolver.Service was called at least n times

func (*FakeconsulResolver) ServiceCalledOnce 

func (f *FakeconsulResolver) ServiceCalledOnce() bool

ServiceCalledOnce returns true if FakeconsulResolver.Service was called exactly once

func (*FakeconsulResolver) ServiceCalledOnceWith 

func (_f4 *FakeconsulResolver) ServiceCalledOnceWith(service string, tag string, passingOnly bool, q *consul.QueryOptions) bool

ServiceCalledOnceWith returns true if FakeconsulResolver.Service was called exactly once with the given values

func (*FakeconsulResolver) ServiceCalledWith 

func (_f2 *FakeconsulResolver) ServiceCalledWith(service string, tag string, passingOnly bool, q *consul.QueryOptions) (found bool)

ServiceCalledWith returns true if FakeconsulResolver.Service was called with the given values

func (*FakeconsulResolver) ServiceNotCalled 

func (f *FakeconsulResolver) ServiceNotCalled() bool

ServiceNotCalled returns true if FakeconsulResolver.Service was not called

func (*FakeconsulResolver) ServiceResultsForCall 

func (_f6 *FakeconsulResolver) ServiceResultsForCall(service string, tag string, passingOnly bool, q *consul.QueryOptions) (ident1 []*consul.ServiceEntry, ident2 *consul.QueryMeta, ident3 error, found bool)

ServiceResultsForCall returns the result values for the first call to FakeconsulResolver.Service with the given values

type Registrar 

type Registrar interface {
	Register(serviceID, addr string) merry.Error
	Deregister(serviceID string) merry.Error
	AddCheck(service string, url *url.URL) merry.Error
	RemoveChecks(service string) merry.Error
}

type RegistrarAddCheckInvocation 

type RegistrarAddCheckInvocation struct {
	Parameters struct {
		Service string
		Url     *url.URL
	}
	Results struct {
		Ident1 merry.Error
	}
}

RegistrarAddCheckInvocation represents a single call of FakeRegistrar.AddCheck

type RegistrarDeregisterInvocation 

type RegistrarDeregisterInvocation struct {
	Parameters struct {
		ServiceID string
	}
	Results struct {
		Ident1 merry.Error
	}
}

RegistrarDeregisterInvocation represents a single call of FakeRegistrar.Deregister

type RegistrarRegisterInvocation 

type RegistrarRegisterInvocation struct {
	Parameters struct {
		ServiceID string
		Addr      string
	}
	Results struct {
		Ident1 merry.Error
	}
}

RegistrarRegisterInvocation represents a single call of FakeRegistrar.Register

type RegistrarRemoveChecksInvocation 

type RegistrarRemoveChecksInvocation struct {
	Parameters struct {
		Service string
	}
	Results struct {
		Ident1 merry.Error
	}
}

RegistrarRemoveChecksInvocation represents a single call of FakeRegistrar.RemoveChecks

type RegistrarTestingT 

type RegistrarTestingT interface {
	Error(...interface{})
	Errorf(string, ...interface{})
	Fatal(...interface{})
	Helper()
}

RegistrarTestingT represents the methods of "testing".T used by charlatan Fakes. It avoids importing the testing package.

type Resolver 

type Resolver interface {
	Resolve(name string) ([]string, merry.Error)
}

type ResolverResolveInvocation 

type ResolverResolveInvocation struct {
	Parameters struct {
		Name string
	}
	Results struct {
		Ident1 []string
		Ident2 merry.Error
	}
}

ResolverResolveInvocation represents a single call of FakeResolver.Resolve

type ResolverTestingT 

type ResolverTestingT interface {
	Error(...interface{})
	Errorf(string, ...interface{})
	Fatal(...interface{})
	Helper()
}

ResolverTestingT represents the methods of "testing".T used by charlatan Fakes. It avoids importing the testing package.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.