context

package
v0.6.0 Latest Latest
Warning

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

 Go to latest Published: Sep 10, 2018 License: BSD-3-Clause Imports: 6 Imported by: 7

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	IDKey    = new(idKey)
	ActorKey = new(actorKey)
	SpanKey  = new(spanKey)
)

Functions

func Put added in v0.3.0 

func Put(ctx Context)

Put returns the given Context back to the shared pool.

Types

type Context 

type Context interface {
	context.Context
	// RequestID returns the configured request id or an empty string
	RequestID() string
	// Actor returns the configured actor or nil
	Actor() models.User
	// Span returns the configured OpenTracing span or nil
	Span() opentracing.Span
	// StartSpan creates a new span with the given operation name and options.  The new span is not added to the current instance.
	// If the context instance contains a span it will be the parent of the new span and it's tracer will be used to create the span.  If no span is configured the global tracer will be used to create a new span.
	StartSpan(string, ...opentracing.StartSpanOption) opentracing.Span
	// WithSpan returns a copy of the current instance configured with the given parent
	WithParent(context.Context) Context
	// WithActor returns a copy of the current instance configured with the given actor
	WithActor(models.User) Context
	/// WithRequestID returns an copy of the current instance configured with the given request id
	WithRequestID(string) Context
	// WithSpan returns a copy of the current instance configured with the given span
	WithSpan(opentracing.Span) Context
	// WithValue returns a copy of the current instance configured with the given value
	WithValue(key, value interface{}) Context
	// WithCancel returns a copy of current instance with a new Done channel.
	WithCancel() (Context, context.CancelFunc)
	// WithDeadline returns a copy of the current instance with the deadline adjusted to be no later than the give time
	WithDeadline(time.Time) (Context, context.CancelFunc)
	// WithTimeout returns a copy of the current instance with the deadline adjusted to time.Now().Add(timeout)
	WithTimeout(time.Duration) (Context, context.CancelFunc)
}

func Get added in v0.3.0 

func Get(parent context.Context) Context

Get returns a Context instance from the shared pool, ready for (re)use.

func New 

func New(parent context.Context) Context

New returns a new instance with the given parent

func StartSpan added in v0.3.1 

func StartSpan(parent Context, operationName string, opts ...opentracing.StartSpanOption) (opentracing.Span, Context)

StartSpan returns a new instance with the given parent and a span created using the given operation name and options

func WithActor added in v0.3.0 

func WithActor(parent context.Context, value models.User) Context

WithActor returns a new instance with the given parent and actor

func WithCancel added in v0.3.0 

func WithCancel(grandParent context.Context) (Context, context.CancelFunc)

WithCancel returns a new instance and its cancel function with the given parent

func WithDeadline added in v0.3.0 

func WithDeadline(grandParent context.Context, deadline time.Time) (Context, context.CancelFunc)

WithDeadline returns a new instance with the given deadline

func WithRequestID added in v0.3.0 

func WithRequestID(parent context.Context, value string) Context

WithRequestID returns a new instance with the given parent and request id

func WithSpan added in v0.3.1 

func WithSpan(parent context.Context, value opentracing.Span) Context

WithSpan returns a new instance with the given parent and span

func WithTimeout added in v0.3.0 

func WithTimeout(grandParent context.Context, timeout time.Duration) (Context, context.CancelFunc)

WithTimeout returns a new instance with the given timeout

func WithValue added in v0.3.0 

func WithValue(parent context.Context, key, value interface{}) Context

WithValue returns a new instance with the given parent and value

type ContextActorInvocation added in v0.3.0 

type ContextActorInvocation struct {
	Results struct {
		Ident1 models.User
	}
}

ContextActorInvocation represents a single call of FakeContext.Actor

type ContextDeadlineInvocation added in v0.3.0 

type ContextDeadlineInvocation struct {
	Results struct {
		Deadline time.Time
		Ok       bool
	}
}

ContextDeadlineInvocation represents a single call of FakeContext.Deadline

type ContextDoneInvocation added in v0.3.0 

type ContextDoneInvocation struct {
	Results struct {
		Ident1 <-chan struct{}
	}
}

ContextDoneInvocation represents a single call of FakeContext.Done

type ContextErrInvocation added in v0.3.0 

type ContextErrInvocation struct {
	Results struct {
		Ident2 error
	}
}

ContextErrInvocation represents a single call of FakeContext.Err

type ContextRequestIDInvocation added in v0.3.0 

type ContextRequestIDInvocation struct {
	Results struct {
		Ident1 string
	}
}

ContextRequestIDInvocation represents a single call of FakeContext.RequestID

type ContextSpanInvocation added in v0.3.1 

type ContextSpanInvocation struct {
	Results struct {
		Ident1 opentracing.Span
	}
}

ContextSpanInvocation represents a single call of FakeContext.Span

type ContextStartSpanInvocation added in v0.3.1 

type ContextStartSpanInvocation struct {
	Parameters struct {
		Ident1 string
		Ident2 []opentracing.StartSpanOption
	}
	Results struct {
		Ident3 opentracing.Span
	}
}

ContextStartSpanInvocation represents a single call of FakeContext.StartSpan

func NewContextStartSpanInvocation added in v0.3.1 

func NewContextStartSpanInvocation(ident1 string, ident2 []opentracing.StartSpanOption, ident3 opentracing.Span) *ContextStartSpanInvocation

NewContextStartSpanInvocation creates a new instance of ContextStartSpanInvocation

type ContextTestingT added in v0.3.0 

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

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

type ContextValueInvocation added in v0.3.0 

type ContextValueInvocation struct {
	Parameters struct {
		Key interface{}
	}
	Results struct {
		Ident3 interface{}
	}
}

ContextValueInvocation represents a single call of FakeContext.Value

func NewContextValueInvocation added in v0.3.1 

func NewContextValueInvocation(key interface{}, ident3 interface{}) *ContextValueInvocation

NewContextValueInvocation creates a new instance of ContextValueInvocation

type ContextWithActorInvocation added in v0.3.0 

type ContextWithActorInvocation struct {
	Parameters struct {
		Ident1 models.User
	}
	Results struct {
		Ident2 Context
	}
}

ContextWithActorInvocation represents a single call of FakeContext.WithActor

func NewContextWithActorInvocation added in v0.3.1 

func NewContextWithActorInvocation(ident1 models.User, ident2 Context) *ContextWithActorInvocation

NewContextWithActorInvocation creates a new instance of ContextWithActorInvocation

type ContextWithCancelInvocation added in v0.3.0 

type ContextWithCancelInvocation struct {
	Results struct {
		Ident1 Context
		Ident2 context.CancelFunc
	}
}

ContextWithCancelInvocation represents a single call of FakeContext.WithCancel

type ContextWithDeadlineInvocation added in v0.3.0 

type ContextWithDeadlineInvocation struct {
	Parameters struct {
		Ident1 time.Time
	}
	Results struct {
		Ident2 Context
		Ident3 context.CancelFunc
	}
}

ContextWithDeadlineInvocation represents a single call of FakeContext.WithDeadline

func NewContextWithDeadlineInvocation added in v0.3.1 

func NewContextWithDeadlineInvocation(ident1 time.Time, ident2 Context, ident3 context.CancelFunc) *ContextWithDeadlineInvocation

NewContextWithDeadlineInvocation creates a new instance of ContextWithDeadlineInvocation

type ContextWithParentInvocation added in v0.3.0 

type ContextWithParentInvocation struct {
	Parameters struct {
		Ident1 context.Context
	}
	Results struct {
		Ident2 Context
	}
}

ContextWithParentInvocation represents a single call of FakeContext.WithParent

func NewContextWithParentInvocation added in v0.3.1 

func NewContextWithParentInvocation(ident1 context.Context, ident2 Context) *ContextWithParentInvocation

NewContextWithParentInvocation creates a new instance of ContextWithParentInvocation

type ContextWithRequestIDInvocation added in v0.3.0 

type ContextWithRequestIDInvocation struct {
	Parameters struct {
		Ident1 string
	}
	Results struct {
		Ident2 Context
	}
}

ContextWithRequestIDInvocation represents a single call of FakeContext.WithRequestID

func NewContextWithRequestIDInvocation added in v0.3.1 

func NewContextWithRequestIDInvocation(ident1 string, ident2 Context) *ContextWithRequestIDInvocation

NewContextWithRequestIDInvocation creates a new instance of ContextWithRequestIDInvocation

type ContextWithSpanInvocation added in v0.3.1 

type ContextWithSpanInvocation struct {
	Parameters struct {
		Ident1 opentracing.Span
	}
	Results struct {
		Ident2 Context
	}
}

ContextWithSpanInvocation represents a single call of FakeContext.WithSpan

func NewContextWithSpanInvocation added in v0.3.1 

func NewContextWithSpanInvocation(ident1 opentracing.Span, ident2 Context) *ContextWithSpanInvocation

NewContextWithSpanInvocation creates a new instance of ContextWithSpanInvocation

type ContextWithTimeoutInvocation added in v0.3.0 

type ContextWithTimeoutInvocation struct {
	Parameters struct {
		Ident1 time.Duration
	}
	Results struct {
		Ident2 Context
		Ident3 context.CancelFunc
	}
}

ContextWithTimeoutInvocation represents a single call of FakeContext.WithTimeout

func NewContextWithTimeoutInvocation added in v0.3.1 

func NewContextWithTimeoutInvocation(ident1 time.Duration, ident2 Context, ident3 context.CancelFunc) *ContextWithTimeoutInvocation

NewContextWithTimeoutInvocation creates a new instance of ContextWithTimeoutInvocation

type ContextWithValueInvocation added in v0.3.0 

type ContextWithValueInvocation struct {
	Parameters struct {
		Key   interface{}
		Value interface{}
	}
	Results struct {
		Ident1 Context
	}
}

ContextWithValueInvocation represents a single call of FakeContext.WithValue

func NewContextWithValueInvocation added in v0.3.1 

func NewContextWithValueInvocation(key interface{}, value interface{}, ident1 Context) *ContextWithValueInvocation

NewContextWithValueInvocation creates a new instance of ContextWithValueInvocation

type FakeContext 

type FakeContext struct {
	DeadlineHook      func() (time.Time, bool)
	DoneHook          func() <-chan struct{}
	ErrHook           func() error
	ValueHook         func(interface{}) interface{}
	RequestIDHook     func() string
	ActorHook         func() models.User
	SpanHook          func() opentracing.Span
	StartSpanHook     func(string, ...opentracing.StartSpanOption) opentracing.Span
	WithParentHook    func(context.Context) Context
	WithActorHook     func(models.User) Context
	WithRequestIDHook func(string) Context
	WithSpanHook      func(opentracing.Span) Context
	WithValueHook     func(interface{}, interface{}) Context
	WithCancelHook    func() (Context, context.CancelFunc)
	WithDeadlineHook  func(time.Time) (Context, context.CancelFunc)
	WithTimeoutHook   func(time.Duration) (Context, context.CancelFunc)

	DeadlineCalls      []*ContextDeadlineInvocation
	DoneCalls          []*ContextDoneInvocation
	ErrCalls           []*ContextErrInvocation
	ValueCalls         []*ContextValueInvocation
	RequestIDCalls     []*ContextRequestIDInvocation
	ActorCalls         []*ContextActorInvocation
	SpanCalls          []*ContextSpanInvocation
	StartSpanCalls     []*ContextStartSpanInvocation
	WithParentCalls    []*ContextWithParentInvocation
	WithActorCalls     []*ContextWithActorInvocation
	WithRequestIDCalls []*ContextWithRequestIDInvocation
	WithSpanCalls      []*ContextWithSpanInvocation
	WithValueCalls     []*ContextWithValueInvocation
	WithCancelCalls    []*ContextWithCancelInvocation
	WithDeadlineCalls  []*ContextWithDeadlineInvocation
	WithTimeoutCalls   []*ContextWithTimeoutInvocation
}

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

package example

func TestWithContext(t *testing.T) {
	f := &context.FakeContext{
		DeadlineHook: func() (deadline time.Time, ok bool) {
			// ensure parameters meet expections, signal errors using t, etc
			return
		},
	}

	// test code goes here ...

	// assert state of FakeDeadline ...
	f.AssertDeadlineCalledOnce(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 FakeDeadline.

func NewFakeContextDefaultError 

func NewFakeContextDefaultError(t ContextTestingT) *FakeContext

NewFakeContextDefaultError returns an instance of FakeContext with all hooks configured to call t.Error

func NewFakeContextDefaultFatal 

func NewFakeContextDefaultFatal(t ContextTestingT) *FakeContext

NewFakeContextDefaultFatal returns an instance of FakeContext with all hooks configured to call t.Fatal

func NewFakeContextDefaultPanic 

func NewFakeContextDefaultPanic() *FakeContext

NewFakeContextDefaultPanic returns an instance of FakeContext with all hooks configured to panic

func (*FakeContext) Actor 

func (_f19 *FakeContext) Actor() (ident1 models.User)

func (*FakeContext) ActorCalled 

func (f *FakeContext) ActorCalled() bool

ActorCalled returns true if FakeContext.Actor was called

func (*FakeContext) ActorCalledN 

func (f *FakeContext) ActorCalledN(n int) bool

ActorCalledN returns true if FakeContext.Actor was called at least n times

func (*FakeContext) ActorCalledOnce 

func (f *FakeContext) ActorCalledOnce() bool

ActorCalledOnce returns true if FakeContext.Actor was called exactly once

func (*FakeContext) ActorNotCalled 

func (f *FakeContext) ActorNotCalled() bool

ActorNotCalled returns true if FakeContext.Actor was not called

func (*FakeContext) AssertActorCalled 

func (f *FakeContext) AssertActorCalled(t ContextTestingT)

AssertActorCalled calls t.Error if FakeContext.Actor was not called

func (*FakeContext) AssertActorCalledN 

func (f *FakeContext) AssertActorCalledN(t ContextTestingT, n int)

AssertActorCalledN calls t.Error if FakeContext.Actor was called less than n times

func (*FakeContext) AssertActorCalledOnce 

func (f *FakeContext) AssertActorCalledOnce(t ContextTestingT)

AssertActorCalledOnce calls t.Error if FakeContext.Actor was not called exactly once

func (*FakeContext) AssertActorNotCalled 

func (f *FakeContext) AssertActorNotCalled(t ContextTestingT)

AssertActorNotCalled calls t.Error if FakeContext.Actor was called

func (*FakeContext) AssertDeadlineCalled 

func (f *FakeContext) AssertDeadlineCalled(t ContextTestingT)

AssertDeadlineCalled calls t.Error if FakeContext.Deadline was not called

func (*FakeContext) AssertDeadlineCalledN 

func (f *FakeContext) AssertDeadlineCalledN(t ContextTestingT, n int)

AssertDeadlineCalledN calls t.Error if FakeContext.Deadline was called less than n times

func (*FakeContext) AssertDeadlineCalledOnce 

func (f *FakeContext) AssertDeadlineCalledOnce(t ContextTestingT)

AssertDeadlineCalledOnce calls t.Error if FakeContext.Deadline was not called exactly once

func (*FakeContext) AssertDeadlineNotCalled 

func (f *FakeContext) AssertDeadlineNotCalled(t ContextTestingT)

AssertDeadlineNotCalled calls t.Error if FakeContext.Deadline was called

func (*FakeContext) AssertDoneCalled 

func (f *FakeContext) AssertDoneCalled(t ContextTestingT)

AssertDoneCalled calls t.Error if FakeContext.Done was not called

func (*FakeContext) AssertDoneCalledN 

func (f *FakeContext) AssertDoneCalledN(t ContextTestingT, n int)

AssertDoneCalledN calls t.Error if FakeContext.Done was called less than n times

func (*FakeContext) AssertDoneCalledOnce 

func (f *FakeContext) AssertDoneCalledOnce(t ContextTestingT)

AssertDoneCalledOnce calls t.Error if FakeContext.Done was not called exactly once

func (*FakeContext) AssertDoneNotCalled 

func (f *FakeContext) AssertDoneNotCalled(t ContextTestingT)

AssertDoneNotCalled calls t.Error if FakeContext.Done was called

func (*FakeContext) AssertErrCalled 

func (f *FakeContext) AssertErrCalled(t ContextTestingT)

AssertErrCalled calls t.Error if FakeContext.Err was not called

func (*FakeContext) AssertErrCalledN 

func (f *FakeContext) AssertErrCalledN(t ContextTestingT, n int)

AssertErrCalledN calls t.Error if FakeContext.Err was called less than n times

func (*FakeContext) AssertErrCalledOnce 

func (f *FakeContext) AssertErrCalledOnce(t ContextTestingT)

AssertErrCalledOnce calls t.Error if FakeContext.Err was not called exactly once

func (*FakeContext) AssertErrNotCalled 

func (f *FakeContext) AssertErrNotCalled(t ContextTestingT)

AssertErrNotCalled calls t.Error if FakeContext.Err was called

func (*FakeContext) AssertRequestIDCalled 

func (f *FakeContext) AssertRequestIDCalled(t ContextTestingT)

AssertRequestIDCalled calls t.Error if FakeContext.RequestID was not called

func (*FakeContext) AssertRequestIDCalledN 

func (f *FakeContext) AssertRequestIDCalledN(t ContextTestingT, n int)

AssertRequestIDCalledN calls t.Error if FakeContext.RequestID was called less than n times

func (*FakeContext) AssertRequestIDCalledOnce 

func (f *FakeContext) AssertRequestIDCalledOnce(t ContextTestingT)

AssertRequestIDCalledOnce calls t.Error if FakeContext.RequestID was not called exactly once

func (*FakeContext) AssertRequestIDNotCalled 

func (f *FakeContext) AssertRequestIDNotCalled(t ContextTestingT)

AssertRequestIDNotCalled calls t.Error if FakeContext.RequestID was called

func (*FakeContext) AssertSpanCalled added in v0.3.1 

func (f *FakeContext) AssertSpanCalled(t ContextTestingT)

AssertSpanCalled calls t.Error if FakeContext.Span was not called

func (*FakeContext) AssertSpanCalledN added in v0.3.1 

func (f *FakeContext) AssertSpanCalledN(t ContextTestingT, n int)

AssertSpanCalledN calls t.Error if FakeContext.Span was called less than n times

func (*FakeContext) AssertSpanCalledOnce added in v0.3.1 

func (f *FakeContext) AssertSpanCalledOnce(t ContextTestingT)

AssertSpanCalledOnce calls t.Error if FakeContext.Span was not called exactly once

func (*FakeContext) AssertSpanNotCalled added in v0.3.1 

func (f *FakeContext) AssertSpanNotCalled(t ContextTestingT)

AssertSpanNotCalled calls t.Error if FakeContext.Span was called

func (*FakeContext) AssertStartSpanCalled added in v0.3.1 

func (f *FakeContext) AssertStartSpanCalled(t ContextTestingT)

AssertStartSpanCalled calls t.Error if FakeContext.StartSpan was not called

func (*FakeContext) AssertStartSpanCalledN added in v0.3.1 

func (f *FakeContext) AssertStartSpanCalledN(t ContextTestingT, n int)

AssertStartSpanCalledN calls t.Error if FakeContext.StartSpan was called less than n times

func (*FakeContext) AssertStartSpanCalledOnce added in v0.3.1 

func (f *FakeContext) AssertStartSpanCalledOnce(t ContextTestingT)

AssertStartSpanCalledOnce calls t.Error if FakeContext.StartSpan was not called exactly once

func (*FakeContext) AssertStartSpanCalledOnceWith added in v0.3.1 

func (_f31 *FakeContext) AssertStartSpanCalledOnceWith(t ContextTestingT, ident1 string, ident2 ...opentracing.StartSpanOption)

AssertStartSpanCalledOnceWith calls t.Error if FakeContext.StartSpan was not called exactly once with the given values

func (*FakeContext) AssertStartSpanCalledWith added in v0.3.1 

func (_f29 *FakeContext) AssertStartSpanCalledWith(t ContextTestingT, ident1 string, ident2 ...opentracing.StartSpanOption)

AssertStartSpanCalledWith calls t.Error if FakeContext.StartSpan was not called with the given values

func (*FakeContext) AssertStartSpanNotCalled added in v0.3.1 

func (f *FakeContext) AssertStartSpanNotCalled(t ContextTestingT)

AssertStartSpanNotCalled calls t.Error if FakeContext.StartSpan was called

func (*FakeContext) AssertValueCalled 

func (f *FakeContext) AssertValueCalled(t ContextTestingT)

AssertValueCalled calls t.Error if FakeContext.Value was not called

func (*FakeContext) AssertValueCalledN 

func (f *FakeContext) AssertValueCalledN(t ContextTestingT, n int)

AssertValueCalledN calls t.Error if FakeContext.Value was called less than n times

func (*FakeContext) AssertValueCalledOnce 

func (f *FakeContext) AssertValueCalledOnce(t ContextTestingT)

AssertValueCalledOnce calls t.Error if FakeContext.Value was not called exactly once

func (*FakeContext) AssertValueCalledOnceWith 

func (_f15 *FakeContext) AssertValueCalledOnceWith(t ContextTestingT, key interface{})

AssertValueCalledOnceWith calls t.Error if FakeContext.Value was not called exactly once with the given values

func (*FakeContext) AssertValueCalledWith 

func (_f13 *FakeContext) AssertValueCalledWith(t ContextTestingT, key interface{})

AssertValueCalledWith calls t.Error if FakeContext.Value was not called with the given values

func (*FakeContext) AssertValueNotCalled 

func (f *FakeContext) AssertValueNotCalled(t ContextTestingT)

AssertValueNotCalled calls t.Error if FakeContext.Value was called

func (*FakeContext) AssertWithActorCalled added in v0.3.0 

func (f *FakeContext) AssertWithActorCalled(t ContextTestingT)

AssertWithActorCalled calls t.Error if FakeContext.WithActor was not called

func (*FakeContext) AssertWithActorCalledN added in v0.3.0 

func (f *FakeContext) AssertWithActorCalledN(t ContextTestingT, n int)

AssertWithActorCalledN calls t.Error if FakeContext.WithActor was called less than n times

func (*FakeContext) AssertWithActorCalledOnce added in v0.3.0 

func (f *FakeContext) AssertWithActorCalledOnce(t ContextTestingT)

AssertWithActorCalledOnce calls t.Error if FakeContext.WithActor was not called exactly once

func (*FakeContext) AssertWithActorCalledOnceWith added in v0.3.0 

func (_f51 *FakeContext) AssertWithActorCalledOnceWith(t ContextTestingT, ident1 models.User)

AssertWithActorCalledOnceWith calls t.Error if FakeContext.WithActor was not called exactly once with the given values

func (*FakeContext) AssertWithActorCalledWith added in v0.3.0 

func (_f49 *FakeContext) AssertWithActorCalledWith(t ContextTestingT, ident1 models.User)

AssertWithActorCalledWith calls t.Error if FakeContext.WithActor was not called with the given values

func (*FakeContext) AssertWithActorNotCalled added in v0.3.0 

func (f *FakeContext) AssertWithActorNotCalled(t ContextTestingT)

AssertWithActorNotCalled calls t.Error if FakeContext.WithActor was called

func (*FakeContext) AssertWithCancelCalled added in v0.3.0 

func (f *FakeContext) AssertWithCancelCalled(t ContextTestingT)

AssertWithCancelCalled calls t.Error if FakeContext.WithCancel was not called

func (*FakeContext) AssertWithCancelCalledN added in v0.3.0 

func (f *FakeContext) AssertWithCancelCalledN(t ContextTestingT, n int)

AssertWithCancelCalledN calls t.Error if FakeContext.WithCancel was called less than n times

func (*FakeContext) AssertWithCancelCalledOnce added in v0.3.0 

func (f *FakeContext) AssertWithCancelCalledOnce(t ContextTestingT)

AssertWithCancelCalledOnce calls t.Error if FakeContext.WithCancel was not called exactly once

func (*FakeContext) AssertWithCancelNotCalled added in v0.3.0 

func (f *FakeContext) AssertWithCancelNotCalled(t ContextTestingT)

AssertWithCancelNotCalled calls t.Error if FakeContext.WithCancel was called

func (*FakeContext) AssertWithDeadlineCalled added in v0.3.0 

func (f *FakeContext) AssertWithDeadlineCalled(t ContextTestingT)

AssertWithDeadlineCalled calls t.Error if FakeContext.WithDeadline was not called

func (*FakeContext) AssertWithDeadlineCalledN added in v0.3.0 

func (f *FakeContext) AssertWithDeadlineCalledN(t ContextTestingT, n int)

AssertWithDeadlineCalledN calls t.Error if FakeContext.WithDeadline was called less than n times

func (*FakeContext) AssertWithDeadlineCalledOnce added in v0.3.0 

func (f *FakeContext) AssertWithDeadlineCalledOnce(t ContextTestingT)

AssertWithDeadlineCalledOnce calls t.Error if FakeContext.WithDeadline was not called exactly once

func (*FakeContext) AssertWithDeadlineCalledOnceWith added in v0.3.0 

func (_f93 *FakeContext) AssertWithDeadlineCalledOnceWith(t ContextTestingT, ident1 time.Time)

AssertWithDeadlineCalledOnceWith calls t.Error if FakeContext.WithDeadline was not called exactly once with the given values

func (*FakeContext) AssertWithDeadlineCalledWith added in v0.3.0 

func (_f91 *FakeContext) AssertWithDeadlineCalledWith(t ContextTestingT, ident1 time.Time)

AssertWithDeadlineCalledWith calls t.Error if FakeContext.WithDeadline was not called with the given values

func (*FakeContext) AssertWithDeadlineNotCalled added in v0.3.0 

func (f *FakeContext) AssertWithDeadlineNotCalled(t ContextTestingT)

AssertWithDeadlineNotCalled calls t.Error if FakeContext.WithDeadline was called

func (*FakeContext) AssertWithParentCalled added in v0.3.0 

func (f *FakeContext) AssertWithParentCalled(t ContextTestingT)

AssertWithParentCalled calls t.Error if FakeContext.WithParent was not called

func (*FakeContext) AssertWithParentCalledN added in v0.3.0 

func (f *FakeContext) AssertWithParentCalledN(t ContextTestingT, n int)

AssertWithParentCalledN calls t.Error if FakeContext.WithParent was called less than n times

func (*FakeContext) AssertWithParentCalledOnce added in v0.3.0 

func (f *FakeContext) AssertWithParentCalledOnce(t ContextTestingT)

AssertWithParentCalledOnce calls t.Error if FakeContext.WithParent was not called exactly once

func (*FakeContext) AssertWithParentCalledOnceWith added in v0.3.0 

func (_f41 *FakeContext) AssertWithParentCalledOnceWith(t ContextTestingT, ident1 context.Context)

AssertWithParentCalledOnceWith calls t.Error if FakeContext.WithParent was not called exactly once with the given values

func (*FakeContext) AssertWithParentCalledWith added in v0.3.0 

func (_f39 *FakeContext) AssertWithParentCalledWith(t ContextTestingT, ident1 context.Context)

AssertWithParentCalledWith calls t.Error if FakeContext.WithParent was not called with the given values

func (*FakeContext) AssertWithParentNotCalled added in v0.3.0 

func (f *FakeContext) AssertWithParentNotCalled(t ContextTestingT)

AssertWithParentNotCalled calls t.Error if FakeContext.WithParent was called

func (*FakeContext) AssertWithRequestIDCalled added in v0.3.0 

func (f *FakeContext) AssertWithRequestIDCalled(t ContextTestingT)

AssertWithRequestIDCalled calls t.Error if FakeContext.WithRequestID was not called

func (*FakeContext) AssertWithRequestIDCalledN added in v0.3.0 

func (f *FakeContext) AssertWithRequestIDCalledN(t ContextTestingT, n int)

AssertWithRequestIDCalledN calls t.Error if FakeContext.WithRequestID was called less than n times

func (*FakeContext) AssertWithRequestIDCalledOnce added in v0.3.0 

func (f *FakeContext) AssertWithRequestIDCalledOnce(t ContextTestingT)

AssertWithRequestIDCalledOnce calls t.Error if FakeContext.WithRequestID was not called exactly once

func (*FakeContext) AssertWithRequestIDCalledOnceWith added in v0.3.0 

func (_f61 *FakeContext) AssertWithRequestIDCalledOnceWith(t ContextTestingT, ident1 string)

AssertWithRequestIDCalledOnceWith calls t.Error if FakeContext.WithRequestID was not called exactly once with the given values

func (*FakeContext) AssertWithRequestIDCalledWith added in v0.3.0 

func (_f59 *FakeContext) AssertWithRequestIDCalledWith(t ContextTestingT, ident1 string)

AssertWithRequestIDCalledWith calls t.Error if FakeContext.WithRequestID was not called with the given values

func (*FakeContext) AssertWithRequestIDNotCalled added in v0.3.0 

func (f *FakeContext) AssertWithRequestIDNotCalled(t ContextTestingT)

AssertWithRequestIDNotCalled calls t.Error if FakeContext.WithRequestID was called

func (*FakeContext) AssertWithSpanCalled added in v0.3.1 

func (f *FakeContext) AssertWithSpanCalled(t ContextTestingT)

AssertWithSpanCalled calls t.Error if FakeContext.WithSpan was not called

func (*FakeContext) AssertWithSpanCalledN added in v0.3.1 

func (f *FakeContext) AssertWithSpanCalledN(t ContextTestingT, n int)

AssertWithSpanCalledN calls t.Error if FakeContext.WithSpan was called less than n times

func (*FakeContext) AssertWithSpanCalledOnce added in v0.3.1 

func (f *FakeContext) AssertWithSpanCalledOnce(t ContextTestingT)

AssertWithSpanCalledOnce calls t.Error if FakeContext.WithSpan was not called exactly once

func (*FakeContext) AssertWithSpanCalledOnceWith added in v0.3.1 

func (_f71 *FakeContext) AssertWithSpanCalledOnceWith(t ContextTestingT, ident1 opentracing.Span)

AssertWithSpanCalledOnceWith calls t.Error if FakeContext.WithSpan was not called exactly once with the given values

func (*FakeContext) AssertWithSpanCalledWith added in v0.3.1 

func (_f69 *FakeContext) AssertWithSpanCalledWith(t ContextTestingT, ident1 opentracing.Span)

AssertWithSpanCalledWith calls t.Error if FakeContext.WithSpan was not called with the given values

func (*FakeContext) AssertWithSpanNotCalled added in v0.3.1 

func (f *FakeContext) AssertWithSpanNotCalled(t ContextTestingT)

AssertWithSpanNotCalled calls t.Error if FakeContext.WithSpan was called

func (*FakeContext) AssertWithTimeoutCalled added in v0.3.0 

func (f *FakeContext) AssertWithTimeoutCalled(t ContextTestingT)

AssertWithTimeoutCalled calls t.Error if FakeContext.WithTimeout was not called

func (*FakeContext) AssertWithTimeoutCalledN added in v0.3.0 

func (f *FakeContext) AssertWithTimeoutCalledN(t ContextTestingT, n int)

AssertWithTimeoutCalledN calls t.Error if FakeContext.WithTimeout was called less than n times

func (*FakeContext) AssertWithTimeoutCalledOnce added in v0.3.0 

func (f *FakeContext) AssertWithTimeoutCalledOnce(t ContextTestingT)

AssertWithTimeoutCalledOnce calls t.Error if FakeContext.WithTimeout was not called exactly once

func (*FakeContext) AssertWithTimeoutCalledOnceWith added in v0.3.0 

func (_f103 *FakeContext) AssertWithTimeoutCalledOnceWith(t ContextTestingT, ident1 time.Duration)

AssertWithTimeoutCalledOnceWith calls t.Error if FakeContext.WithTimeout was not called exactly once with the given values

func (*FakeContext) AssertWithTimeoutCalledWith added in v0.3.0 

func (_f101 *FakeContext) AssertWithTimeoutCalledWith(t ContextTestingT, ident1 time.Duration)

AssertWithTimeoutCalledWith calls t.Error if FakeContext.WithTimeout was not called with the given values

func (*FakeContext) AssertWithTimeoutNotCalled added in v0.3.0 

func (f *FakeContext) AssertWithTimeoutNotCalled(t ContextTestingT)

AssertWithTimeoutNotCalled calls t.Error if FakeContext.WithTimeout was called

func (*FakeContext) AssertWithValueCalled added in v0.3.0 

func (f *FakeContext) AssertWithValueCalled(t ContextTestingT)

AssertWithValueCalled calls t.Error if FakeContext.WithValue was not called

func (*FakeContext) AssertWithValueCalledN added in v0.3.0 

func (f *FakeContext) AssertWithValueCalledN(t ContextTestingT, n int)

AssertWithValueCalledN calls t.Error if FakeContext.WithValue was called less than n times

func (*FakeContext) AssertWithValueCalledOnce added in v0.3.0 

func (f *FakeContext) AssertWithValueCalledOnce(t ContextTestingT)

AssertWithValueCalledOnce calls t.Error if FakeContext.WithValue was not called exactly once

func (*FakeContext) AssertWithValueCalledOnceWith added in v0.3.0 

func (_f81 *FakeContext) AssertWithValueCalledOnceWith(t ContextTestingT, key interface{}, value interface{})

AssertWithValueCalledOnceWith calls t.Error if FakeContext.WithValue was not called exactly once with the given values

func (*FakeContext) AssertWithValueCalledWith added in v0.3.0 

func (_f79 *FakeContext) AssertWithValueCalledWith(t ContextTestingT, key interface{}, value interface{})

AssertWithValueCalledWith calls t.Error if FakeContext.WithValue was not called with the given values

func (*FakeContext) AssertWithValueNotCalled added in v0.3.0 

func (f *FakeContext) AssertWithValueNotCalled(t ContextTestingT)

AssertWithValueNotCalled calls t.Error if FakeContext.WithValue was called

func (*FakeContext) Deadline 

func (_f1 *FakeContext) Deadline() (deadline time.Time, ok bool)

func (*FakeContext) DeadlineCalled 

func (f *FakeContext) DeadlineCalled() bool

DeadlineCalled returns true if FakeContext.Deadline was called

func (*FakeContext) DeadlineCalledN 

func (f *FakeContext) DeadlineCalledN(n int) bool

DeadlineCalledN returns true if FakeContext.Deadline was called at least n times

func (*FakeContext) DeadlineCalledOnce 

func (f *FakeContext) DeadlineCalledOnce() bool

DeadlineCalledOnce returns true if FakeContext.Deadline was called exactly once

func (*FakeContext) DeadlineNotCalled 

func (f *FakeContext) DeadlineNotCalled() bool

DeadlineNotCalled returns true if FakeContext.Deadline was not called

func (*FakeContext) Done 

func (_f3 *FakeContext) Done() (ident1 <-chan struct{})

func (*FakeContext) DoneCalled 

func (f *FakeContext) DoneCalled() bool

DoneCalled returns true if FakeContext.Done was called

func (*FakeContext) DoneCalledN 

func (f *FakeContext) DoneCalledN(n int) bool

DoneCalledN returns true if FakeContext.Done was called at least n times

func (*FakeContext) DoneCalledOnce 

func (f *FakeContext) DoneCalledOnce() bool

DoneCalledOnce returns true if FakeContext.Done was called exactly once

func (*FakeContext) DoneNotCalled 

func (f *FakeContext) DoneNotCalled() bool

DoneNotCalled returns true if FakeContext.Done was not called

func (*FakeContext) Err 

func (_f5 *FakeContext) Err() (ident2 error)

func (*FakeContext) ErrCalled 

func (f *FakeContext) ErrCalled() bool

ErrCalled returns true if FakeContext.Err was called

func (*FakeContext) ErrCalledN 

func (f *FakeContext) ErrCalledN(n int) bool

ErrCalledN returns true if FakeContext.Err was called at least n times

func (*FakeContext) ErrCalledOnce 

func (f *FakeContext) ErrCalledOnce() bool

ErrCalledOnce returns true if FakeContext.Err was called exactly once

func (*FakeContext) ErrNotCalled 

func (f *FakeContext) ErrNotCalled() bool

ErrNotCalled returns true if FakeContext.Err was not called

func (*FakeContext) RequestID 

func (_f17 *FakeContext) RequestID() (ident1 string)

func (*FakeContext) RequestIDCalled 

func (f *FakeContext) RequestIDCalled() bool

RequestIDCalled returns true if FakeContext.RequestID was called

func (*FakeContext) RequestIDCalledN 

func (f *FakeContext) RequestIDCalledN(n int) bool

RequestIDCalledN returns true if FakeContext.RequestID was called at least n times

func (*FakeContext) RequestIDCalledOnce 

func (f *FakeContext) RequestIDCalledOnce() bool

RequestIDCalledOnce returns true if FakeContext.RequestID was called exactly once

func (*FakeContext) RequestIDNotCalled 

func (f *FakeContext) RequestIDNotCalled() bool

RequestIDNotCalled returns true if FakeContext.RequestID was not called

func (*FakeContext) Reset added in v0.3.0 

func (f *FakeContext) Reset()

func (*FakeContext) SetActorStub added in v0.3.1 

func (_f20 *FakeContext) SetActorStub(ident1 models.User)

SetActorStub configures Context.Actor to always return the given values

func (*FakeContext) SetDeadlineStub added in v0.3.1 

func (_f2 *FakeContext) SetDeadlineStub(deadline time.Time, ok bool)

SetDeadlineStub configures Context.Deadline to always return the given values

func (*FakeContext) SetDoneStub added in v0.3.1 

func (_f4 *FakeContext) SetDoneStub(ident1 <-chan struct{})

SetDoneStub configures Context.Done to always return the given values

func (*FakeContext) SetErrStub added in v0.3.1 

func (_f6 *FakeContext) SetErrStub(ident2 error)

SetErrStub configures Context.Err to always return the given values

func (*FakeContext) SetRequestIDStub added in v0.3.1 

func (_f18 *FakeContext) SetRequestIDStub(ident1 string)

SetRequestIDStub configures Context.RequestID to always return the given values

func (*FakeContext) SetSpanStub added in v0.3.1 

func (_f22 *FakeContext) SetSpanStub(ident1 opentracing.Span)

SetSpanStub configures Context.Span to always return the given values

func (*FakeContext) SetStartSpanInvocation added in v0.3.1 

func (_f25 *FakeContext) SetStartSpanInvocation(calls_f26 []*ContextStartSpanInvocation, fallback_f27 func() opentracing.Span)

SetStartSpanInvocation configures Context.StartSpan to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetStartSpanStub added in v0.3.1 

func (_f24 *FakeContext) SetStartSpanStub(ident3 opentracing.Span)

SetStartSpanStub configures Context.StartSpan to always return the given values

func (*FakeContext) SetValueInvocation added in v0.3.1 

func (_f9 *FakeContext) SetValueInvocation(calls_f10 []*ContextValueInvocation, fallback_f11 func() interface{})

SetValueInvocation configures Context.Value to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetValueStub added in v0.3.1 

func (_f8 *FakeContext) SetValueStub(ident3 interface{})

SetValueStub configures Context.Value to always return the given values

func (*FakeContext) SetWithActorInvocation added in v0.3.1 

func (_f45 *FakeContext) SetWithActorInvocation(calls_f46 []*ContextWithActorInvocation, fallback_f47 func() Context)

SetWithActorInvocation configures Context.WithActor to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetWithActorStub added in v0.3.1 

func (_f44 *FakeContext) SetWithActorStub(ident2 Context)

SetWithActorStub configures Context.WithActor to always return the given values

func (*FakeContext) SetWithCancelStub added in v0.3.1 

func (_f84 *FakeContext) SetWithCancelStub(ident1 Context, ident2 context.CancelFunc)

SetWithCancelStub configures Context.WithCancel to always return the given values

func (*FakeContext) SetWithDeadlineInvocation added in v0.3.1 

func (_f87 *FakeContext) SetWithDeadlineInvocation(calls_f88 []*ContextWithDeadlineInvocation, fallback_f89 func() (Context, context.CancelFunc))

SetWithDeadlineInvocation configures Context.WithDeadline to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetWithDeadlineStub added in v0.3.1 

func (_f86 *FakeContext) SetWithDeadlineStub(ident2 Context, ident3 context.CancelFunc)

SetWithDeadlineStub configures Context.WithDeadline to always return the given values

func (*FakeContext) SetWithParentInvocation added in v0.3.1 

func (_f35 *FakeContext) SetWithParentInvocation(calls_f36 []*ContextWithParentInvocation, fallback_f37 func() Context)

SetWithParentInvocation configures Context.WithParent to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetWithParentStub added in v0.3.1 

func (_f34 *FakeContext) SetWithParentStub(ident2 Context)

SetWithParentStub configures Context.WithParent to always return the given values

func (*FakeContext) SetWithRequestIDInvocation added in v0.3.1 

func (_f55 *FakeContext) SetWithRequestIDInvocation(calls_f56 []*ContextWithRequestIDInvocation, fallback_f57 func() Context)

SetWithRequestIDInvocation configures Context.WithRequestID to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetWithRequestIDStub added in v0.3.1 

func (_f54 *FakeContext) SetWithRequestIDStub(ident2 Context)

SetWithRequestIDStub configures Context.WithRequestID to always return the given values

func (*FakeContext) SetWithSpanInvocation added in v0.3.1 

func (_f65 *FakeContext) SetWithSpanInvocation(calls_f66 []*ContextWithSpanInvocation, fallback_f67 func() Context)

SetWithSpanInvocation configures Context.WithSpan to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetWithSpanStub added in v0.3.1 

func (_f64 *FakeContext) SetWithSpanStub(ident2 Context)

SetWithSpanStub configures Context.WithSpan to always return the given values

func (*FakeContext) SetWithTimeoutInvocation added in v0.3.1 

func (_f97 *FakeContext) SetWithTimeoutInvocation(calls_f98 []*ContextWithTimeoutInvocation, fallback_f99 func() (Context, context.CancelFunc))

SetWithTimeoutInvocation configures Context.WithTimeout to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetWithTimeoutStub added in v0.3.1 

func (_f96 *FakeContext) SetWithTimeoutStub(ident2 Context, ident3 context.CancelFunc)

SetWithTimeoutStub configures Context.WithTimeout to always return the given values

func (*FakeContext) SetWithValueInvocation added in v0.3.1 

func (_f75 *FakeContext) SetWithValueInvocation(calls_f76 []*ContextWithValueInvocation, fallback_f77 func() Context)

SetWithValueInvocation configures Context.WithValue to return the given results when called with the given parameters If no match is found for an invocation the result(s) of the fallback function are returned

func (*FakeContext) SetWithValueStub added in v0.3.1 

func (_f74 *FakeContext) SetWithValueStub(ident1 Context)

SetWithValueStub configures Context.WithValue to always return the given values

func (*FakeContext) Span added in v0.3.1 

func (_f21 *FakeContext) Span() (ident1 opentracing.Span)

func (*FakeContext) SpanCalled added in v0.3.1 

func (f *FakeContext) SpanCalled() bool

SpanCalled returns true if FakeContext.Span was called

func (*FakeContext) SpanCalledN added in v0.3.1 

func (f *FakeContext) SpanCalledN(n int) bool

SpanCalledN returns true if FakeContext.Span was called at least n times

func (*FakeContext) SpanCalledOnce added in v0.3.1 

func (f *FakeContext) SpanCalledOnce() bool

SpanCalledOnce returns true if FakeContext.Span was called exactly once

func (*FakeContext) SpanNotCalled added in v0.3.1 

func (f *FakeContext) SpanNotCalled() bool

SpanNotCalled returns true if FakeContext.Span was not called

func (*FakeContext) StartSpan added in v0.3.1 

func (_f23 *FakeContext) StartSpan(ident1 string, ident2 ...opentracing.StartSpanOption) (ident3 opentracing.Span)

func (*FakeContext) StartSpanCalled added in v0.3.1 

func (f *FakeContext) StartSpanCalled() bool

StartSpanCalled returns true if FakeContext.StartSpan was called

func (*FakeContext) StartSpanCalledN added in v0.3.1 

func (f *FakeContext) StartSpanCalledN(n int) bool

StartSpanCalledN returns true if FakeContext.StartSpan was called at least n times

func (*FakeContext) StartSpanCalledOnce added in v0.3.1 

func (f *FakeContext) StartSpanCalledOnce() bool

StartSpanCalledOnce returns true if FakeContext.StartSpan was called exactly once

func (*FakeContext) StartSpanCalledOnceWith added in v0.3.1 

func (_f30 *FakeContext) StartSpanCalledOnceWith(ident1 string, ident2 ...opentracing.StartSpanOption) bool

StartSpanCalledOnceWith returns true if FakeContext.StartSpan was called exactly once with the given values

func (*FakeContext) StartSpanCalledWith added in v0.3.1 

func (_f28 *FakeContext) StartSpanCalledWith(ident1 string, ident2 ...opentracing.StartSpanOption) (found bool)

StartSpanCalledWith returns true if FakeContext.StartSpan was called with the given values

func (*FakeContext) StartSpanNotCalled added in v0.3.1 

func (f *FakeContext) StartSpanNotCalled() bool

StartSpanNotCalled returns true if FakeContext.StartSpan was not called

func (*FakeContext) StartSpanResultsForCall added in v0.3.1 

func (_f32 *FakeContext) StartSpanResultsForCall(ident1 string, ident2 ...opentracing.StartSpanOption) (ident3 opentracing.Span, found bool)

StartSpanResultsForCall returns the result values for the first call to FakeContext.StartSpan with the given values

func (*FakeContext) Value 

func (_f7 *FakeContext) Value(key interface{}) (ident3 interface{})

func (*FakeContext) ValueCalled 

func (f *FakeContext) ValueCalled() bool

ValueCalled returns true if FakeContext.Value was called

func (*FakeContext) ValueCalledN 

func (f *FakeContext) ValueCalledN(n int) bool

ValueCalledN returns true if FakeContext.Value was called at least n times

func (*FakeContext) ValueCalledOnce 

func (f *FakeContext) ValueCalledOnce() bool

ValueCalledOnce returns true if FakeContext.Value was called exactly once

func (*FakeContext) ValueCalledOnceWith 

func (_f14 *FakeContext) ValueCalledOnceWith(key interface{}) bool

ValueCalledOnceWith returns true if FakeContext.Value was called exactly once with the given values

func (*FakeContext) ValueCalledWith 

func (_f12 *FakeContext) ValueCalledWith(key interface{}) (found bool)

ValueCalledWith returns true if FakeContext.Value was called with the given values

func (*FakeContext) ValueNotCalled 

func (f *FakeContext) ValueNotCalled() bool

ValueNotCalled returns true if FakeContext.Value was not called

func (*FakeContext) ValueResultsForCall 

func (_f16 *FakeContext) ValueResultsForCall(key interface{}) (ident3 interface{}, found bool)

ValueResultsForCall returns the result values for the first call to FakeContext.Value with the given values

func (*FakeContext) WithActor added in v0.3.0 

func (_f43 *FakeContext) WithActor(ident1 models.User) (ident2 Context)

func (*FakeContext) WithActorCalled added in v0.3.0 

func (f *FakeContext) WithActorCalled() bool

WithActorCalled returns true if FakeContext.WithActor was called

func (*FakeContext) WithActorCalledN added in v0.3.0 

func (f *FakeContext) WithActorCalledN(n int) bool

WithActorCalledN returns true if FakeContext.WithActor was called at least n times

func (*FakeContext) WithActorCalledOnce added in v0.3.0 

func (f *FakeContext) WithActorCalledOnce() bool

WithActorCalledOnce returns true if FakeContext.WithActor was called exactly once

func (*FakeContext) WithActorCalledOnceWith added in v0.3.0 

func (_f50 *FakeContext) WithActorCalledOnceWith(ident1 models.User) bool

WithActorCalledOnceWith returns true if FakeContext.WithActor was called exactly once with the given values

func (*FakeContext) WithActorCalledWith added in v0.3.0 

func (_f48 *FakeContext) WithActorCalledWith(ident1 models.User) (found bool)

WithActorCalledWith returns true if FakeContext.WithActor was called with the given values

func (*FakeContext) WithActorNotCalled added in v0.3.0 

func (f *FakeContext) WithActorNotCalled() bool

WithActorNotCalled returns true if FakeContext.WithActor was not called

func (*FakeContext) WithActorResultsForCall added in v0.3.0 

func (_f52 *FakeContext) WithActorResultsForCall(ident1 models.User) (ident2 Context, found bool)

WithActorResultsForCall returns the result values for the first call to FakeContext.WithActor with the given values

func (*FakeContext) WithCancel added in v0.3.0 

func (_f83 *FakeContext) WithCancel() (ident1 Context, ident2 context.CancelFunc)

func (*FakeContext) WithCancelCalled added in v0.3.0 

func (f *FakeContext) WithCancelCalled() bool

WithCancelCalled returns true if FakeContext.WithCancel was called

func (*FakeContext) WithCancelCalledN added in v0.3.0 

func (f *FakeContext) WithCancelCalledN(n int) bool

WithCancelCalledN returns true if FakeContext.WithCancel was called at least n times

func (*FakeContext) WithCancelCalledOnce added in v0.3.0 

func (f *FakeContext) WithCancelCalledOnce() bool

WithCancelCalledOnce returns true if FakeContext.WithCancel was called exactly once

func (*FakeContext) WithCancelNotCalled added in v0.3.0 

func (f *FakeContext) WithCancelNotCalled() bool

WithCancelNotCalled returns true if FakeContext.WithCancel was not called

func (*FakeContext) WithDeadline added in v0.3.0 

func (_f85 *FakeContext) WithDeadline(ident1 time.Time) (ident2 Context, ident3 context.CancelFunc)

func (*FakeContext) WithDeadlineCalled added in v0.3.0 

func (f *FakeContext) WithDeadlineCalled() bool

WithDeadlineCalled returns true if FakeContext.WithDeadline was called

func (*FakeContext) WithDeadlineCalledN added in v0.3.0 

func (f *FakeContext) WithDeadlineCalledN(n int) bool

WithDeadlineCalledN returns true if FakeContext.WithDeadline was called at least n times

func (*FakeContext) WithDeadlineCalledOnce added in v0.3.0 

func (f *FakeContext) WithDeadlineCalledOnce() bool

WithDeadlineCalledOnce returns true if FakeContext.WithDeadline was called exactly once

func (*FakeContext) WithDeadlineCalledOnceWith added in v0.3.0 

func (_f92 *FakeContext) WithDeadlineCalledOnceWith(ident1 time.Time) bool

WithDeadlineCalledOnceWith returns true if FakeContext.WithDeadline was called exactly once with the given values

func (*FakeContext) WithDeadlineCalledWith added in v0.3.0 

func (_f90 *FakeContext) WithDeadlineCalledWith(ident1 time.Time) (found bool)

WithDeadlineCalledWith returns true if FakeContext.WithDeadline was called with the given values

func (*FakeContext) WithDeadlineNotCalled added in v0.3.0 

func (f *FakeContext) WithDeadlineNotCalled() bool

WithDeadlineNotCalled returns true if FakeContext.WithDeadline was not called

func (*FakeContext) WithDeadlineResultsForCall added in v0.3.0 

func (_f94 *FakeContext) WithDeadlineResultsForCall(ident1 time.Time) (ident2 Context, ident3 context.CancelFunc, found bool)

WithDeadlineResultsForCall returns the result values for the first call to FakeContext.WithDeadline with the given values

func (*FakeContext) WithParent added in v0.3.0 

func (_f33 *FakeContext) WithParent(ident1 context.Context) (ident2 Context)

func (*FakeContext) WithParentCalled added in v0.3.0 

func (f *FakeContext) WithParentCalled() bool

WithParentCalled returns true if FakeContext.WithParent was called

func (*FakeContext) WithParentCalledN added in v0.3.0 

func (f *FakeContext) WithParentCalledN(n int) bool

WithParentCalledN returns true if FakeContext.WithParent was called at least n times

func (*FakeContext) WithParentCalledOnce added in v0.3.0 

func (f *FakeContext) WithParentCalledOnce() bool

WithParentCalledOnce returns true if FakeContext.WithParent was called exactly once

func (*FakeContext) WithParentCalledOnceWith added in v0.3.0 

func (_f40 *FakeContext) WithParentCalledOnceWith(ident1 context.Context) bool

WithParentCalledOnceWith returns true if FakeContext.WithParent was called exactly once with the given values

func (*FakeContext) WithParentCalledWith added in v0.3.0 

func (_f38 *FakeContext) WithParentCalledWith(ident1 context.Context) (found bool)

WithParentCalledWith returns true if FakeContext.WithParent was called with the given values

func (*FakeContext) WithParentNotCalled added in v0.3.0 

func (f *FakeContext) WithParentNotCalled() bool

WithParentNotCalled returns true if FakeContext.WithParent was not called

func (*FakeContext) WithParentResultsForCall added in v0.3.0 

func (_f42 *FakeContext) WithParentResultsForCall(ident1 context.Context) (ident2 Context, found bool)

WithParentResultsForCall returns the result values for the first call to FakeContext.WithParent with the given values

func (*FakeContext) WithRequestID added in v0.3.0 

func (_f53 *FakeContext) WithRequestID(ident1 string) (ident2 Context)

func (*FakeContext) WithRequestIDCalled added in v0.3.0 

func (f *FakeContext) WithRequestIDCalled() bool

WithRequestIDCalled returns true if FakeContext.WithRequestID was called

func (*FakeContext) WithRequestIDCalledN added in v0.3.0 

func (f *FakeContext) WithRequestIDCalledN(n int) bool

WithRequestIDCalledN returns true if FakeContext.WithRequestID was called at least n times

func (*FakeContext) WithRequestIDCalledOnce added in v0.3.0 

func (f *FakeContext) WithRequestIDCalledOnce() bool

WithRequestIDCalledOnce returns true if FakeContext.WithRequestID was called exactly once

func (*FakeContext) WithRequestIDCalledOnceWith added in v0.3.0 

func (_f60 *FakeContext) WithRequestIDCalledOnceWith(ident1 string) bool

WithRequestIDCalledOnceWith returns true if FakeContext.WithRequestID was called exactly once with the given values

func (*FakeContext) WithRequestIDCalledWith added in v0.3.0 

func (_f58 *FakeContext) WithRequestIDCalledWith(ident1 string) (found bool)

WithRequestIDCalledWith returns true if FakeContext.WithRequestID was called with the given values

func (*FakeContext) WithRequestIDNotCalled added in v0.3.0 

func (f *FakeContext) WithRequestIDNotCalled() bool

WithRequestIDNotCalled returns true if FakeContext.WithRequestID was not called

func (*FakeContext) WithRequestIDResultsForCall added in v0.3.0 

func (_f62 *FakeContext) WithRequestIDResultsForCall(ident1 string) (ident2 Context, found bool)

WithRequestIDResultsForCall returns the result values for the first call to FakeContext.WithRequestID with the given values

func (*FakeContext) WithSpan added in v0.3.1 

func (_f63 *FakeContext) WithSpan(ident1 opentracing.Span) (ident2 Context)

func (*FakeContext) WithSpanCalled added in v0.3.1 

func (f *FakeContext) WithSpanCalled() bool

WithSpanCalled returns true if FakeContext.WithSpan was called

func (*FakeContext) WithSpanCalledN added in v0.3.1 

func (f *FakeContext) WithSpanCalledN(n int) bool

WithSpanCalledN returns true if FakeContext.WithSpan was called at least n times

func (*FakeContext) WithSpanCalledOnce added in v0.3.1 

func (f *FakeContext) WithSpanCalledOnce() bool

WithSpanCalledOnce returns true if FakeContext.WithSpan was called exactly once

func (*FakeContext) WithSpanCalledOnceWith added in v0.3.1 

func (_f70 *FakeContext) WithSpanCalledOnceWith(ident1 opentracing.Span) bool

WithSpanCalledOnceWith returns true if FakeContext.WithSpan was called exactly once with the given values

func (*FakeContext) WithSpanCalledWith added in v0.3.1 

func (_f68 *FakeContext) WithSpanCalledWith(ident1 opentracing.Span) (found bool)

WithSpanCalledWith returns true if FakeContext.WithSpan was called with the given values

func (*FakeContext) WithSpanNotCalled added in v0.3.1 

func (f *FakeContext) WithSpanNotCalled() bool

WithSpanNotCalled returns true if FakeContext.WithSpan was not called

func (*FakeContext) WithSpanResultsForCall added in v0.3.1 

func (_f72 *FakeContext) WithSpanResultsForCall(ident1 opentracing.Span) (ident2 Context, found bool)

WithSpanResultsForCall returns the result values for the first call to FakeContext.WithSpan with the given values

func (*FakeContext) WithTimeout added in v0.3.0 

func (_f95 *FakeContext) WithTimeout(ident1 time.Duration) (ident2 Context, ident3 context.CancelFunc)

func (*FakeContext) WithTimeoutCalled added in v0.3.0 

func (f *FakeContext) WithTimeoutCalled() bool

WithTimeoutCalled returns true if FakeContext.WithTimeout was called

func (*FakeContext) WithTimeoutCalledN added in v0.3.0 

func (f *FakeContext) WithTimeoutCalledN(n int) bool

WithTimeoutCalledN returns true if FakeContext.WithTimeout was called at least n times

func (*FakeContext) WithTimeoutCalledOnce added in v0.3.0 

func (f *FakeContext) WithTimeoutCalledOnce() bool

WithTimeoutCalledOnce returns true if FakeContext.WithTimeout was called exactly once

func (*FakeContext) WithTimeoutCalledOnceWith added in v0.3.0 

func (_f102 *FakeContext) WithTimeoutCalledOnceWith(ident1 time.Duration) bool

WithTimeoutCalledOnceWith returns true if FakeContext.WithTimeout was called exactly once with the given values

func (*FakeContext) WithTimeoutCalledWith added in v0.3.0 

func (_f100 *FakeContext) WithTimeoutCalledWith(ident1 time.Duration) (found bool)

WithTimeoutCalledWith returns true if FakeContext.WithTimeout was called with the given values

func (*FakeContext) WithTimeoutNotCalled added in v0.3.0 

func (f *FakeContext) WithTimeoutNotCalled() bool

WithTimeoutNotCalled returns true if FakeContext.WithTimeout was not called

func (*FakeContext) WithTimeoutResultsForCall added in v0.3.0 

func (_f104 *FakeContext) WithTimeoutResultsForCall(ident1 time.Duration) (ident2 Context, ident3 context.CancelFunc, found bool)

WithTimeoutResultsForCall returns the result values for the first call to FakeContext.WithTimeout with the given values

func (*FakeContext) WithValue added in v0.3.0 

func (_f73 *FakeContext) WithValue(key interface{}, value interface{}) (ident1 Context)

func (*FakeContext) WithValueCalled added in v0.3.0 

func (f *FakeContext) WithValueCalled() bool

WithValueCalled returns true if FakeContext.WithValue was called

func (*FakeContext) WithValueCalledN added in v0.3.0 

func (f *FakeContext) WithValueCalledN(n int) bool

WithValueCalledN returns true if FakeContext.WithValue was called at least n times

func (*FakeContext) WithValueCalledOnce added in v0.3.0 

func (f *FakeContext) WithValueCalledOnce() bool

WithValueCalledOnce returns true if FakeContext.WithValue was called exactly once

func (*FakeContext) WithValueCalledOnceWith added in v0.3.0 

func (_f80 *FakeContext) WithValueCalledOnceWith(key interface{}, value interface{}) bool

WithValueCalledOnceWith returns true if FakeContext.WithValue was called exactly once with the given values

func (*FakeContext) WithValueCalledWith added in v0.3.0 

func (_f78 *FakeContext) WithValueCalledWith(key interface{}, value interface{}) (found bool)

WithValueCalledWith returns true if FakeContext.WithValue was called with the given values

func (*FakeContext) WithValueNotCalled added in v0.3.0 

func (f *FakeContext) WithValueNotCalled() bool

WithValueNotCalled returns true if FakeContext.WithValue was not called

func (*FakeContext) WithValueResultsForCall added in v0.3.0 

func (_f82 *FakeContext) WithValueResultsForCall(key interface{}, value interface{}) (ident1 Context, found bool)

WithValueResultsForCall returns the result values for the first call to FakeContext.WithValue with the given values

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.