mock

Documentation

Overview

Package mock contains mock implementations of the query package interfaces for testing.

Index

• Variables
• func CreateMockFromSource(spec plan.ProcedureSpec, id execute.DatasetID, ctx execute.Administration) (execute.Source, error)
• type AscendingTimeProvider
  • func (atp *AscendingTimeProvider) CurrentTime() values.Time
• type Compiler
  • func (c Compiler) Compile(ctx context.Context) (flux.Program, error)
  • func (c Compiler) CompilerType() flux.CompilerType
• type Executor
  • func NewExecutor() *Executor
  • func (e *Executor) Execute(ctx context.Context, p *plan.Spec, a *memory.Allocator) (map[string]flux.Result, <-chan flux.Metadata, error)
• type Program
  • func (p *Program) Start(ctx context.Context, alloc *memory.Allocator) (flux.Query, error)
• type Query
  • func (q *Query) Cancel()
  • func (q *Query) Done()
  • func (q *Query) Err() error
  • func (q *Query) ProduceResults(resultProvider func(results chan<- flux.Result, canceled <-chan struct{}))
  • func (q *Query) Results() <-chan flux.Result
  • func (q *Query) SetErr(err error)
  • func (q *Query) SetStatistics(stats flux.Statistics)
  • func (q *Query) Statistics() flux.Statistics
• type Source
  • func (s *Source) AddTransformation(t execute.Transformation)
  • func (s *Source) Run(ctx context.Context)

Variables

var NoMetadata <-chan flux.Metadata

Functions

func CreateMockFromSource

func CreateMockFromSource(spec plan.ProcedureSpec, id execute.DatasetID, ctx execute.Administration) (execute.Source, error)

CreateMockFromSource will register a mock "from" source. Use it like this in the init() of your test:

execute.RegisterSource(influxdb.FromKind, mock.CreateMockFromSource)

Types

type AscendingTimeProvider

type AscendingTimeProvider struct {
	Start int64
}

AscendingTimeProvider provides ascending timestamps every nanosecond starting from Start.

func (*AscendingTimeProvider) CurrentTime

func (atp *AscendingTimeProvider) CurrentTime() values.Time

type Compiler

type Compiler struct {
	CompileFn func(ctx context.Context) (flux.Program, error)
	Type      flux.CompilerType
}

func (Compiler) Compile

func (c Compiler) Compile(ctx context.Context) (flux.Program, error)

func (Compiler) CompilerType

func (c Compiler) CompilerType() flux.CompilerType

type Executor

type Executor struct {
	ExecuteFn func(ctx context.Context, p *plan.Spec, a *memory.Allocator) (map[string]flux.Result, <-chan flux.Metadata, error)
}

Executor is a mock implementation of an execute.Executor.

func NewExecutor

func NewExecutor() *Executor

NewExecutor returns a mock Executor where its methods will return zero values.

func (*Executor) Execute

func (e *Executor) Execute(ctx context.Context, p *plan.Spec, a *memory.Allocator) (map[string]flux.Result, <-chan flux.Metadata, error)

type Program

type Program struct {
	StartFn   func(ctx context.Context, alloc *memory.Allocator) (*Query, error)
	ExecuteFn func(ctx context.Context, q *Query, alloc *memory.Allocator)
}

Program is a mock program that can be returned by the mock compiler. It will construct a mock query that will then be passed to ExecuteFn.

func (*Program) Start

func (p *Program) Start(ctx context.Context, alloc *memory.Allocator) (flux.Query, error)

type Query

type Query struct {
	ResultsCh chan flux.Result
	CancelFn  func()

	Canceled chan struct{}
	// contains filtered or unexported fields
}

Query provides a customizable query that implements flux.Query. Results, as well as errors, statistics, and the cancel function can be set.

func (*Query) Cancel

func (q *Query) Cancel()

func (*Query) Done

func (q *Query) Done()

func (*Query) Err

func (q *Query) Err() error

func (*Query) ProduceResults

func (q *Query) ProduceResults(resultProvider func(results chan<- flux.Result, canceled <-chan struct{}))

ProduceResults lets the user provide a function to produce results on the channel returned by `Results`. `resultProvider` should check if `canceled` has been closed before sending results. E.g.: ```

 func (results chan<- flux.Result, canceled <-chan struct{}) {
	 for _, r := range resultsSlice {
		 select {
		 case <-canceled:
		 	 return
		 default:
			 results <- r
		 }
	 }
 }

``` `resultProvider` is run in a separate goroutine and Results() is closed after function completion. ProduceResults can be called only once per Query.

func (*Query) Results

func (q *Query) Results() <-chan flux.Result

func (*Query) SetErr

func (q *Query) SetErr(err error)

SetErr sets the error for this query and `Cancel`s it

func (*Query) SetStatistics

func (q *Query) SetStatistics(stats flux.Statistics)

SetStatistics sets stats for this query. Stats will be available after `Done` is called.

func (*Query) Statistics

func (q *Query) Statistics() flux.Statistics

type Source

type Source struct {
	AddTransformationFn func(transformation execute.Transformation)
	RunFn               func(ctx context.Context)
}

Source is a mock source that performs the given functions. By default it does nothing.

func (*Source) AddTransformation

func (s *Source) AddTransformation(t execute.Transformation)

func (*Source) Run

func (s *Source) Run(ctx context.Context)