mock

package
v0.0.1 Latest Latest
Warning

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

 Go to latest Published: Oct 24, 2021 License: GPL-3.0 Imports: 7 Imported by: 0

Documentation

Overview

Package mock provides a basic mock for testing the datastore.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Add 

type Add struct {
	Mock
	// contains filtered or unexported fields
}

Add is a mock datastore.Add

func NewAdd 

func NewAdd(t *testing.T) *Add

NewAdd creates a mock datastore.Add

func NewAddWithFail 

func NewAddWithFail(t *testing.T, expect ...interface{}) *Add

NewAddWithFail creates a mock datastore.Add with an expected failure

func (*Add) Execute 

func (a *Add) Execute(ctx context.Context) (int, error)

func (*Add) Item 

func (a *Add) Item(value map[string]interface{}) datastore.Add

func (*Add) Query 

func (a *Add) Query(query datastore.Query) datastore.Add

func (*Add) Statement 

func (a *Add) Statement() (string, []interface{}, error)

func (*Add) To 

func (a *Add) To(collection string) datastore.Add

type Cursor 

type Cursor struct {
	Mock
	// contains filtered or unexported fields
}

func NewCursor 

func NewCursor(t *testing.T) *Cursor

NewCursor creates a mock datastore.Cursor

func NewCursorWithFail 

func NewCursorWithFail(t *testing.T, expect ...interface{}) *Cursor

NewCursorWithFail creates a mock datastore.Cursor with an expected failure

func (*Cursor) Close 

func (c *Cursor) Close()

func (*Cursor) Decode 

func (c *Cursor) Decode(values ...interface{}) error

func (*Cursor) Error 

func (c *Cursor) Error() error

func (*Cursor) Next 

func (c *Cursor) Next() bool

type Expect 

type Expect struct {
	// contains filtered or unexported fields
}

func (*Expect) Return 

func (e *Expect) Return(output ...interface{})

type Filter 

type Filter struct {
	Mock
	// contains filtered or unexported fields
}

Filter is a mock datastore.Filter

func NewFilter 

func NewFilter(t *testing.T) *Filter

NewFilter creates a mock datastore.Filter

func NewFilterWithFail 

func NewFilterWithFail(t *testing.T, expect ...interface{}) *Filter

NewFilterWithFail creates a mock datastore.Filter with an expected failure

func (*Filter) And 

func (f *Filter) And(another datastore.Filter) datastore.Filter

func (*Filter) BeginsWith 

func (f *Filter) BeginsWith(key string, prefix string) datastore.Filter

func (*Filter) Contains 

func (f *Filter) Contains(key string, value interface{}) datastore.Filter

func (*Filter) EndsWith 

func (f *Filter) EndsWith(key string, suffix string) datastore.Filter

func (*Filter) Eq 

func (f *Filter) Eq(key string, value interface{}) datastore.Filter

func (*Filter) Gt 

func (f *Filter) Gt(key string, value interface{}) datastore.Filter

func (*Filter) Lt 

func (f *Filter) Lt(key string, value interface{}) datastore.Filter

func (*Filter) NotContains 

func (f *Filter) NotContains(key string, value interface{}) datastore.Filter

func (*Filter) NotEq 

func (f *Filter) NotEq(key string, value interface{}) datastore.Filter

func (*Filter) Or 

func (f *Filter) Or(another datastore.Filter) datastore.Filter

type Mock 

type Mock struct {
	// contains filtered or unexported fields
}

func (*Mock) Assert 

func (m *Mock) Assert(t *testing.T)

func (*Mock) Call 

func (m *Mock) Call(t *testing.T, args ...interface{}) []interface{}

func (*Mock) Expect 

func (m *Mock) Expect(funcName string, args ...interface{}) *Expect

func (*Mock) Fatal 

func (m *Mock) Fatal(t *testing.T, args ...interface{})

func (*Mock) Fatalf 

func (m *Mock) Fatalf(t *testing.T, format string, args ...interface{})

type Query 

type Query struct {
	Mock
	// contains filtered or unexported fields
}

Query is a mock datastore.Query

func NewQuery 

func NewQuery(t *testing.T) *Query

NewQuery creates a mock datastore.Query

func NewQueryWithFail 

func NewQueryWithFail(t *testing.T, expect ...interface{}) *Query

NewQueryWithFail creates a mock datastore.Query with an expected failure

func (*Query) After 

func (q *Query) After(key string, value interface{}) datastore.Query

func (*Query) And 

func (q *Query) And(collection string, args ...interface{}) datastore.Query

func (*Query) Execute 

func (q *Query) Execute(ctx context.Context) (datastore.Cursor, error)

func (*Query) Filter 

func (q *Query) Filter(filter datastore.Filter) datastore.Query

func (*Query) First 

func (q *Query) First(first int) datastore.Query

func (*Query) From 

func (q *Query) From(collection string) datastore.Query

func (*Query) Order 

func (q *Query) Order(by string) datastore.Query

func (*Query) Return 

func (q *Query) Return(key string, args ...interface{}) datastore.Query

func (*Query) Secondary 

func (q *Query) Secondary() datastore.Query

func (*Query) Statement 

func (q *Query) Statement() (string, []interface{}, error)

type Remove 

type Remove struct {
	Mock
	// contains filtered or unexported fields
}

Remove is a mock datastore.Remove

func NewRemove 

func NewRemove(t *testing.T) *Remove

NewRemove creates a mock datastore.Remove

func NewRemoveWithFail 

func NewRemoveWithFail(t *testing.T, expect ...interface{}) *Remove

NewRemoveWithFail creates a mock datastore.Remove with an expected failure

func (*Remove) After 

func (r *Remove) After(key string, value interface{}) datastore.Remove

func (*Remove) Execute 

func (r *Remove) Execute(ctx context.Context) (int, error)

func (*Remove) Filter 

func (r *Remove) Filter(filter datastore.Filter) datastore.Remove

func (*Remove) First 

func (r *Remove) First(first int) datastore.Remove

func (*Remove) From 

func (r *Remove) From(collection string) datastore.Remove

func (*Remove) Order 

func (r *Remove) Order(by string) datastore.Remove

func (*Remove) Statement 

func (r *Remove) Statement() (string, []interface{}, error)

type Snapper 

type Snapper struct {
	Mock
	// contains filtered or unexported fields
}

Snapper is a mock datastore.Snapper

func NewSnapper 

func NewSnapper(t *testing.T) *Snapper

NewSnapper creates a mock snapper

func NewSnapperWithFail 

func NewSnapperWithFail(t *testing.T, expect ...interface{}) *Snapper

NewSnapperWithFail creates a mock datastore.Snapper with an expected failure

func (*Snapper) Snapshot 

func (s *Snapper) Snapshot() map[string]interface{}

type Store 

type Store struct {
	Mock
	// contains filtered or unexported fields
}

Store is a mock datastore.Client

func NewDisconnectedStore 

func NewDisconnectedStore(t *testing.T) *Store

NewDisconnectedStore creates a new disconnected mock store

func NewDisconnectedStoreWithFail 

func NewDisconnectedStoreWithFail(t *testing.T, expect ...interface{}) *Store

NewDisconnectedStoreWithFail creates a disconnected store with an expected failure

func NewStore 

func NewStore(t *testing.T) *Store

NewStore creates a connected mock store

func (*Store) Add 

func (s *Store) Add() datastore.Add

func (*Store) Connect 

func (s *Store) Connect() error

func (*Store) Filter 

func (s *Store) Filter() datastore.Filter

func (*Store) Query 

func (s *Store) Query() datastore.Query

func (*Store) Remove 

func (s *Store) Remove() datastore.Remove

func (*Store) Transaction 

func (s *Store) Transaction(ctx context.Context) (datastore.Transaction, error)

func (*Store) Update 

func (s *Store) Update() datastore.Update

type Transaction 

type Transaction struct {
	Mock
	// contains filtered or unexported fields
}

Transaction is a mock datastore.Transaction

func NewTransaction 

func NewTransaction(t *testing.T) *Transaction

NewTransaction creates a mock datastore.Transaction

func NewTransactionWithFail 

func NewTransactionWithFail(t *testing.T, expect ...interface{}) *Transaction

NewTransactionWithFail creates a mock datastore.Transaction with an expected failure

func (*Transaction) Commit 

func (tx *Transaction) Commit() error

func (*Transaction) Execute 

func (tx *Transaction) Execute(statement datastore.Encoder) (int, error)

func (*Transaction) Rollback 

func (tx *Transaction) Rollback() error

type Update 

type Update struct {
	Mock
	// contains filtered or unexported fields
}

Update is a mock datastore.Update

func NewUpdate 

func NewUpdate(t *testing.T) *Update

NewUpdate creates a mock datastore.Update

func NewUpdateWithFail 

func NewUpdateWithFail(t *testing.T, expect ...interface{}) *Update

NewUpdateWithFail creates a mock datastore.Update with an expected failure

func (*Update) Execute 

func (u *Update) Execute(ctx context.Context) (int, error)

func (*Update) Filter 

func (u *Update) Filter(filter datastore.Filter) datastore.Update

func (*Update) In 

func (u *Update) In(collection string) datastore.Update

func (*Update) Item 

func (u *Update) Item(snapshot map[string]interface{}) datastore.Update

func (*Update) Statement 

func (u *Update) Statement() (string, []interface{}, error)

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.