mock

package
v0.0.0-...-835bfbe Latest Latest
Warning

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

 Go to latest Published: Jan 29, 2021 License: Apache-2.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ClientMock 

type ClientMock struct {
	// CloseFunc mocks the Close method.
	CloseFunc func() error

	// DatasetFunc mocks the Dataset method.
	DatasetFunc func(in1 string) bqiface.Dataset

	// DatasetInProjectFunc mocks the DatasetInProject method.
	DatasetInProjectFunc func(in1 string, in2 string) bqiface.Dataset

	// DatasetsFunc mocks the Datasets method.
	DatasetsFunc func(in1 context.Context) bqiface.DatasetIterator

	// DatasetsInProjectFunc mocks the DatasetsInProject method.
	DatasetsInProjectFunc func(in1 context.Context, in2 string) bqiface.DatasetIterator

	// JobFromIDFunc mocks the JobFromID method.
	JobFromIDFunc func(in1 context.Context, in2 string) (bqiface.Job, error)

	// JobFromIDLocationFunc mocks the JobFromIDLocation method.
	JobFromIDLocationFunc func(in1 context.Context, in2 string, in3 string) (bqiface.Job, error)

	// JobsFunc mocks the Jobs method.
	JobsFunc func(in1 context.Context) bqiface.JobIterator

	// LocationFunc mocks the Location method.
	LocationFunc func() string

	// QueryFunc mocks the Query method.
	QueryFunc func(in1 string) bqiface.Query

	// SetLocationFunc mocks the SetLocation method.
	SetLocationFunc func(in1 string)
	// contains filtered or unexported fields
}

ClientMock is a mock implementation of bqiface.Client. 

    func TestSomethingThatUsesClient(t *testing.T) {

        // make and configure a mocked bqiface.Client
        mockedClient := &ClientMock{
            CloseFunc: func() error {
	               panic("mock out the Close method")
            },
            DatasetFunc: func(in1 string) bqiface.Dataset {
	               panic("mock out the Dataset method")
            },
            DatasetInProjectFunc: func(in1 string, in2 string) bqiface.Dataset {
	               panic("mock out the DatasetInProject method")
            },
            DatasetsFunc: func(in1 context.Context) bqiface.DatasetIterator {
	               panic("mock out the Datasets method")
            },
            DatasetsInProjectFunc: func(in1 context.Context, in2 string) bqiface.DatasetIterator {
	               panic("mock out the DatasetsInProject method")
            },
            JobFromIDFunc: func(in1 context.Context, in2 string) (bqiface.Job, error) {
	               panic("mock out the JobFromID method")
            },
            JobFromIDLocationFunc: func(in1 context.Context, in2 string, in3 string) (bqiface.Job, error) {
	               panic("mock out the JobFromIDLocation method")
            },
            JobsFunc: func(in1 context.Context) bqiface.JobIterator {
	               panic("mock out the Jobs method")
            },
            LocationFunc: func() string {
	               panic("mock out the Location method")
            },
            QueryFunc: func(in1 string) bqiface.Query {
	               panic("mock out the Query method")
            },
            SetLocationFunc: func(in1 string)  {
	               panic("mock out the SetLocation method")
            },
        }

        // use mockedClient in code that requires bqiface.Client
        // and then make assertions.

    }

func (*ClientMock) Close 

func (mock *ClientMock) Close() error

Close calls CloseFunc.

func (*ClientMock) CloseCalls 

func (mock *ClientMock) CloseCalls() []struct {
}

CloseCalls gets all the calls that were made to Close. Check the length with: 

len(mockedClient.CloseCalls())

func (*ClientMock) Dataset 

func (mock *ClientMock) Dataset(in1 string) bqiface.Dataset

Dataset calls DatasetFunc.

func (*ClientMock) DatasetCalls 

func (mock *ClientMock) DatasetCalls() []struct {
	In1 string
}

DatasetCalls gets all the calls that were made to Dataset. Check the length with: 

len(mockedClient.DatasetCalls())

func (*ClientMock) DatasetInProject 

func (mock *ClientMock) DatasetInProject(in1 string, in2 string) bqiface.Dataset

DatasetInProject calls DatasetInProjectFunc.

func (*ClientMock) DatasetInProjectCalls 

func (mock *ClientMock) DatasetInProjectCalls() []struct {
	In1 string
	In2 string
}

DatasetInProjectCalls gets all the calls that were made to DatasetInProject. Check the length with: 

len(mockedClient.DatasetInProjectCalls())

func (*ClientMock) Datasets 

func (mock *ClientMock) Datasets(in1 context.Context) bqiface.DatasetIterator

Datasets calls DatasetsFunc.

func (*ClientMock) DatasetsCalls 

func (mock *ClientMock) DatasetsCalls() []struct {
	In1 context.Context
}

DatasetsCalls gets all the calls that were made to Datasets. Check the length with: 

len(mockedClient.DatasetsCalls())

func (*ClientMock) DatasetsInProject 

func (mock *ClientMock) DatasetsInProject(in1 context.Context, in2 string) bqiface.DatasetIterator

DatasetsInProject calls DatasetsInProjectFunc.

func (*ClientMock) DatasetsInProjectCalls 

func (mock *ClientMock) DatasetsInProjectCalls() []struct {
	In1 context.Context
	In2 string
}

DatasetsInProjectCalls gets all the calls that were made to DatasetsInProject. Check the length with: 

len(mockedClient.DatasetsInProjectCalls())

func (*ClientMock) JobFromID 

func (mock *ClientMock) JobFromID(in1 context.Context, in2 string) (bqiface.Job, error)

JobFromID calls JobFromIDFunc.

func (*ClientMock) JobFromIDCalls 

func (mock *ClientMock) JobFromIDCalls() []struct {
	In1 context.Context
	In2 string
}

JobFromIDCalls gets all the calls that were made to JobFromID. Check the length with: 

len(mockedClient.JobFromIDCalls())

func (*ClientMock) JobFromIDLocation 

func (mock *ClientMock) JobFromIDLocation(in1 context.Context, in2 string, in3 string) (bqiface.Job, error)

JobFromIDLocation calls JobFromIDLocationFunc.

func (*ClientMock) JobFromIDLocationCalls 

func (mock *ClientMock) JobFromIDLocationCalls() []struct {
	In1 context.Context
	In2 string
	In3 string
}

JobFromIDLocationCalls gets all the calls that were made to JobFromIDLocation. Check the length with: 

len(mockedClient.JobFromIDLocationCalls())

func (*ClientMock) Jobs 

func (mock *ClientMock) Jobs(in1 context.Context) bqiface.JobIterator

Jobs calls JobsFunc.

func (*ClientMock) JobsCalls 

func (mock *ClientMock) JobsCalls() []struct {
	In1 context.Context
}

JobsCalls gets all the calls that were made to Jobs. Check the length with: 

len(mockedClient.JobsCalls())

func (*ClientMock) Location 

func (mock *ClientMock) Location() string

Location calls LocationFunc.

func (*ClientMock) LocationCalls 

func (mock *ClientMock) LocationCalls() []struct {
}

LocationCalls gets all the calls that were made to Location. Check the length with: 

len(mockedClient.LocationCalls())

func (*ClientMock) Query 

func (mock *ClientMock) Query(in1 string) bqiface.Query

Query calls QueryFunc.

func (*ClientMock) QueryCalls 

func (mock *ClientMock) QueryCalls() []struct {
	In1 string
}

QueryCalls gets all the calls that were made to Query. Check the length with: 

len(mockedClient.QueryCalls())

func (*ClientMock) SetLocation 

func (mock *ClientMock) SetLocation(in1 string)

SetLocation calls SetLocationFunc.

func (*ClientMock) SetLocationCalls 

func (mock *ClientMock) SetLocationCalls() []struct {
	In1 string
}

SetLocationCalls gets all the calls that were made to SetLocation. Check the length with: 

len(mockedClient.SetLocationCalls())

type CopierMock 

type CopierMock struct {
	// JobIDConfigFunc mocks the JobIDConfig method.
	JobIDConfigFunc func() *bigquery.JobIDConfig

	// RunFunc mocks the Run method.
	RunFunc func(in1 context.Context) (bqiface.Job, error)

	// SetCopyConfigFunc mocks the SetCopyConfig method.
	SetCopyConfigFunc func(in1 bqiface.CopyConfig)
	// contains filtered or unexported fields
}

CopierMock is a mock implementation of bqiface.Copier. 

    func TestSomethingThatUsesCopier(t *testing.T) {

        // make and configure a mocked bqiface.Copier
        mockedCopier := &CopierMock{
            JobIDConfigFunc: func() *bigquery.JobIDConfig {
	               panic("mock out the JobIDConfig method")
            },
            RunFunc: func(in1 context.Context) (bqiface.Job, error) {
	               panic("mock out the Run method")
            },
            SetCopyConfigFunc: func(in1 bqiface.CopyConfig)  {
	               panic("mock out the SetCopyConfig method")
            },
        }

        // use mockedCopier in code that requires bqiface.Copier
        // and then make assertions.

    }

func (*CopierMock) JobIDConfig 

func (mock *CopierMock) JobIDConfig() *bigquery.JobIDConfig

JobIDConfig calls JobIDConfigFunc.

func (*CopierMock) JobIDConfigCalls 

func (mock *CopierMock) JobIDConfigCalls() []struct {
}

JobIDConfigCalls gets all the calls that were made to JobIDConfig. Check the length with: 

len(mockedCopier.JobIDConfigCalls())

func (*CopierMock) Run 

func (mock *CopierMock) Run(in1 context.Context) (bqiface.Job, error)

Run calls RunFunc.

func (*CopierMock) RunCalls 

func (mock *CopierMock) RunCalls() []struct {
	In1 context.Context
}

RunCalls gets all the calls that were made to Run. Check the length with: 

len(mockedCopier.RunCalls())

func (*CopierMock) SetCopyConfig 

func (mock *CopierMock) SetCopyConfig(in1 bqiface.CopyConfig)

SetCopyConfig calls SetCopyConfigFunc.

func (*CopierMock) SetCopyConfigCalls 

func (mock *CopierMock) SetCopyConfigCalls() []struct {
	In1 bqiface.CopyConfig
}

SetCopyConfigCalls gets all the calls that were made to SetCopyConfig. Check the length with: 

len(mockedCopier.SetCopyConfigCalls())

type DatasetIteratorMock 

type DatasetIteratorMock struct {
	// NextFunc mocks the Next method.
	NextFunc func() (bqiface.Dataset, error)

	// PageInfoFunc mocks the PageInfo method.
	PageInfoFunc func() *iterator.PageInfo

	// SetFilterFunc mocks the SetFilter method.
	SetFilterFunc func(in1 string)

	// SetListHiddenFunc mocks the SetListHidden method.
	SetListHiddenFunc func(in1 bool)

	// SetProjectIDFunc mocks the SetProjectID method.
	SetProjectIDFunc func(in1 string)
	// contains filtered or unexported fields
}

DatasetIteratorMock is a mock implementation of bqiface.DatasetIterator. 

    func TestSomethingThatUsesDatasetIterator(t *testing.T) {

        // make and configure a mocked bqiface.DatasetIterator
        mockedDatasetIterator := &DatasetIteratorMock{
            NextFunc: func() (bqiface.Dataset, error) {
	               panic("mock out the Next method")
            },
            PageInfoFunc: func() *iterator.PageInfo {
	               panic("mock out the PageInfo method")
            },
            SetFilterFunc: func(in1 string)  {
	               panic("mock out the SetFilter method")
            },
            SetListHiddenFunc: func(in1 bool)  {
	               panic("mock out the SetListHidden method")
            },
            SetProjectIDFunc: func(in1 string)  {
	               panic("mock out the SetProjectID method")
            },
        }

        // use mockedDatasetIterator in code that requires bqiface.DatasetIterator
        // and then make assertions.

    }

func (*DatasetIteratorMock) Next 

func (mock *DatasetIteratorMock) Next() (bqiface.Dataset, error)

Next calls NextFunc.

func (*DatasetIteratorMock) NextCalls 

func (mock *DatasetIteratorMock) NextCalls() []struct {
}

NextCalls gets all the calls that were made to Next. Check the length with: 

len(mockedDatasetIterator.NextCalls())

func (*DatasetIteratorMock) PageInfo 

func (mock *DatasetIteratorMock) PageInfo() *iterator.PageInfo

PageInfo calls PageInfoFunc.

func (*DatasetIteratorMock) PageInfoCalls 

func (mock *DatasetIteratorMock) PageInfoCalls() []struct {
}

PageInfoCalls gets all the calls that were made to PageInfo. Check the length with: 

len(mockedDatasetIterator.PageInfoCalls())

func (*DatasetIteratorMock) SetFilter 

func (mock *DatasetIteratorMock) SetFilter(in1 string)

SetFilter calls SetFilterFunc.

func (*DatasetIteratorMock) SetFilterCalls 

func (mock *DatasetIteratorMock) SetFilterCalls() []struct {
	In1 string
}

SetFilterCalls gets all the calls that were made to SetFilter. Check the length with: 

len(mockedDatasetIterator.SetFilterCalls())

func (*DatasetIteratorMock) SetListHidden 

func (mock *DatasetIteratorMock) SetListHidden(in1 bool)

SetListHidden calls SetListHiddenFunc.

func (*DatasetIteratorMock) SetListHiddenCalls 

func (mock *DatasetIteratorMock) SetListHiddenCalls() []struct {
	In1 bool
}

SetListHiddenCalls gets all the calls that were made to SetListHidden. Check the length with: 

len(mockedDatasetIterator.SetListHiddenCalls())

func (*DatasetIteratorMock) SetProjectID 

func (mock *DatasetIteratorMock) SetProjectID(in1 string)

SetProjectID calls SetProjectIDFunc.

func (*DatasetIteratorMock) SetProjectIDCalls 

func (mock *DatasetIteratorMock) SetProjectIDCalls() []struct {
	In1 string
}

SetProjectIDCalls gets all the calls that were made to SetProjectID. Check the length with: 

len(mockedDatasetIterator.SetProjectIDCalls())

type DatasetMock 

type DatasetMock struct {
	// CreateFunc mocks the Create method.
	CreateFunc func(in1 context.Context, in2 *bqiface.DatasetMetadata) error

	// DatasetIDFunc mocks the DatasetID method.
	DatasetIDFunc func() string

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(in1 context.Context) error

	// DeleteWithContentsFunc mocks the DeleteWithContents method.
	DeleteWithContentsFunc func(in1 context.Context) error

	// MetadataFunc mocks the Metadata method.
	MetadataFunc func(in1 context.Context) (*bqiface.DatasetMetadata, error)

	// ProjectIDFunc mocks the ProjectID method.
	ProjectIDFunc func() string

	// TableFunc mocks the Table method.
	TableFunc func(in1 string) bqiface.Table

	// TablesFunc mocks the Tables method.
	TablesFunc func(in1 context.Context) bqiface.TableIterator

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 context.Context, in2 bqiface.DatasetMetadataToUpdate, in3 string) (*bqiface.DatasetMetadata, error)
	// contains filtered or unexported fields
}

DatasetMock is a mock implementation of bqiface.Dataset. 

    func TestSomethingThatUsesDataset(t *testing.T) {

        // make and configure a mocked bqiface.Dataset
        mockedDataset := &DatasetMock{
            CreateFunc: func(in1 context.Context, in2 *bqiface.DatasetMetadata) error {
	               panic("mock out the Create method")
            },
            DatasetIDFunc: func() string {
	               panic("mock out the DatasetID method")
            },
            DeleteFunc: func(in1 context.Context) error {
	               panic("mock out the Delete method")
            },
            DeleteWithContentsFunc: func(in1 context.Context) error {
	               panic("mock out the DeleteWithContents method")
            },
            MetadataFunc: func(in1 context.Context) (*bqiface.DatasetMetadata, error) {
	               panic("mock out the Metadata method")
            },
            ProjectIDFunc: func() string {
	               panic("mock out the ProjectID method")
            },
            TableFunc: func(in1 string) bqiface.Table {
	               panic("mock out the Table method")
            },
            TablesFunc: func(in1 context.Context) bqiface.TableIterator {
	               panic("mock out the Tables method")
            },
            UpdateFunc: func(in1 context.Context, in2 bqiface.DatasetMetadataToUpdate, in3 string) (*bqiface.DatasetMetadata, error) {
	               panic("mock out the Update method")
            },
        }

        // use mockedDataset in code that requires bqiface.Dataset
        // and then make assertions.

    }

func (*DatasetMock) Create 

func (mock *DatasetMock) Create(in1 context.Context, in2 *bqiface.DatasetMetadata) error

Create calls CreateFunc.

func (*DatasetMock) CreateCalls 

func (mock *DatasetMock) CreateCalls() []struct {
	In1 context.Context
	In2 *bqiface.DatasetMetadata
}

CreateCalls gets all the calls that were made to Create. Check the length with: 

len(mockedDataset.CreateCalls())

func (*DatasetMock) DatasetID 

func (mock *DatasetMock) DatasetID() string

DatasetID calls DatasetIDFunc.

func (*DatasetMock) DatasetIDCalls 

func (mock *DatasetMock) DatasetIDCalls() []struct {
}

DatasetIDCalls gets all the calls that were made to DatasetID. Check the length with: 

len(mockedDataset.DatasetIDCalls())

func (*DatasetMock) Delete 

func (mock *DatasetMock) Delete(in1 context.Context) error

Delete calls DeleteFunc.

func (*DatasetMock) DeleteCalls 

func (mock *DatasetMock) DeleteCalls() []struct {
	In1 context.Context
}

DeleteCalls gets all the calls that were made to Delete. Check the length with: 

len(mockedDataset.DeleteCalls())

func (*DatasetMock) DeleteWithContents 

func (mock *DatasetMock) DeleteWithContents(in1 context.Context) error

DeleteWithContents calls DeleteWithContentsFunc.

func (*DatasetMock) DeleteWithContentsCalls 

func (mock *DatasetMock) DeleteWithContentsCalls() []struct {
	In1 context.Context
}

DeleteWithContentsCalls gets all the calls that were made to DeleteWithContents. Check the length with: 

len(mockedDataset.DeleteWithContentsCalls())

func (*DatasetMock) Metadata 

func (mock *DatasetMock) Metadata(in1 context.Context) (*bqiface.DatasetMetadata, error)

Metadata calls MetadataFunc.

func (*DatasetMock) MetadataCalls 

func (mock *DatasetMock) MetadataCalls() []struct {
	In1 context.Context
}

MetadataCalls gets all the calls that were made to Metadata. Check the length with: 

len(mockedDataset.MetadataCalls())

func (*DatasetMock) ProjectID 

func (mock *DatasetMock) ProjectID() string

ProjectID calls ProjectIDFunc.

func (*DatasetMock) ProjectIDCalls 

func (mock *DatasetMock) ProjectIDCalls() []struct {
}

ProjectIDCalls gets all the calls that were made to ProjectID. Check the length with: 

len(mockedDataset.ProjectIDCalls())

func (*DatasetMock) Table 

func (mock *DatasetMock) Table(in1 string) bqiface.Table

Table calls TableFunc.

func (*DatasetMock) TableCalls 

func (mock *DatasetMock) TableCalls() []struct {
	In1 string
}

TableCalls gets all the calls that were made to Table. Check the length with: 

len(mockedDataset.TableCalls())

func (*DatasetMock) Tables 

func (mock *DatasetMock) Tables(in1 context.Context) bqiface.TableIterator

Tables calls TablesFunc.

func (*DatasetMock) TablesCalls 

func (mock *DatasetMock) TablesCalls() []struct {
	In1 context.Context
}

TablesCalls gets all the calls that were made to Tables. Check the length with: 

len(mockedDataset.TablesCalls())

func (*DatasetMock) Update 

func (mock *DatasetMock) Update(in1 context.Context, in2 bqiface.DatasetMetadataToUpdate, in3 string) (*bqiface.DatasetMetadata, error)

Update calls UpdateFunc.

func (*DatasetMock) UpdateCalls 

func (mock *DatasetMock) UpdateCalls() []struct {
	In1 context.Context
	In2 bqiface.DatasetMetadataToUpdate
	In3 string
}

UpdateCalls gets all the calls that were made to Update. Check the length with: 

len(mockedDataset.UpdateCalls())

type ExtractorMock 

type ExtractorMock struct {
	// JobIDConfigFunc mocks the JobIDConfig method.
	JobIDConfigFunc func() *bigquery.JobIDConfig

	// RunFunc mocks the Run method.
	RunFunc func(in1 context.Context) (bqiface.Job, error)

	// SetExtractConfigFunc mocks the SetExtractConfig method.
	SetExtractConfigFunc func(in1 bqiface.ExtractConfig)
	// contains filtered or unexported fields
}

ExtractorMock is a mock implementation of bqiface.Extractor. 

    func TestSomethingThatUsesExtractor(t *testing.T) {

        // make and configure a mocked bqiface.Extractor
        mockedExtractor := &ExtractorMock{
            JobIDConfigFunc: func() *bigquery.JobIDConfig {
	               panic("mock out the JobIDConfig method")
            },
            RunFunc: func(in1 context.Context) (bqiface.Job, error) {
	               panic("mock out the Run method")
            },
            SetExtractConfigFunc: func(in1 bqiface.ExtractConfig)  {
	               panic("mock out the SetExtractConfig method")
            },
        }

        // use mockedExtractor in code that requires bqiface.Extractor
        // and then make assertions.

    }

func (*ExtractorMock) JobIDConfig 

func (mock *ExtractorMock) JobIDConfig() *bigquery.JobIDConfig

JobIDConfig calls JobIDConfigFunc.

func (*ExtractorMock) JobIDConfigCalls 

func (mock *ExtractorMock) JobIDConfigCalls() []struct {
}

JobIDConfigCalls gets all the calls that were made to JobIDConfig. Check the length with: 

len(mockedExtractor.JobIDConfigCalls())

func (*ExtractorMock) Run 

func (mock *ExtractorMock) Run(in1 context.Context) (bqiface.Job, error)

Run calls RunFunc.

func (*ExtractorMock) RunCalls 

func (mock *ExtractorMock) RunCalls() []struct {
	In1 context.Context
}

RunCalls gets all the calls that were made to Run. Check the length with: 

len(mockedExtractor.RunCalls())

func (*ExtractorMock) SetExtractConfig 

func (mock *ExtractorMock) SetExtractConfig(in1 bqiface.ExtractConfig)

SetExtractConfig calls SetExtractConfigFunc.

func (*ExtractorMock) SetExtractConfigCalls 

func (mock *ExtractorMock) SetExtractConfigCalls() []struct {
	In1 bqiface.ExtractConfig
}

SetExtractConfigCalls gets all the calls that were made to SetExtractConfig. Check the length with: 

len(mockedExtractor.SetExtractConfigCalls())

type JobIteratorMock 

type JobIteratorMock struct {
	// NextFunc mocks the Next method.
	NextFunc func() (bqiface.Job, error)

	// PageInfoFunc mocks the PageInfo method.
	PageInfoFunc func() *iterator.PageInfo

	// SetAllUsersFunc mocks the SetAllUsers method.
	SetAllUsersFunc func(in1 bool)

	// SetProjectIDFunc mocks the SetProjectID method.
	SetProjectIDFunc func(in1 string)

	// SetStateFunc mocks the SetState method.
	SetStateFunc func(in1 bigquery.State)
	// contains filtered or unexported fields
}

JobIteratorMock is a mock implementation of bqiface.JobIterator. 

    func TestSomethingThatUsesJobIterator(t *testing.T) {

        // make and configure a mocked bqiface.JobIterator
        mockedJobIterator := &JobIteratorMock{
            NextFunc: func() (bqiface.Job, error) {
	               panic("mock out the Next method")
            },
            PageInfoFunc: func() *iterator.PageInfo {
	               panic("mock out the PageInfo method")
            },
            SetAllUsersFunc: func(in1 bool)  {
	               panic("mock out the SetAllUsers method")
            },
            SetProjectIDFunc: func(in1 string)  {
	               panic("mock out the SetProjectID method")
            },
            SetStateFunc: func(in1 bigquery.State)  {
	               panic("mock out the SetState method")
            },
        }

        // use mockedJobIterator in code that requires bqiface.JobIterator
        // and then make assertions.

    }

func (*JobIteratorMock) Next 

func (mock *JobIteratorMock) Next() (bqiface.Job, error)

Next calls NextFunc.

func (*JobIteratorMock) NextCalls 

func (mock *JobIteratorMock) NextCalls() []struct {
}

NextCalls gets all the calls that were made to Next. Check the length with: 

len(mockedJobIterator.NextCalls())

func (*JobIteratorMock) PageInfo 

func (mock *JobIteratorMock) PageInfo() *iterator.PageInfo

PageInfo calls PageInfoFunc.

func (*JobIteratorMock) PageInfoCalls 

func (mock *JobIteratorMock) PageInfoCalls() []struct {
}

PageInfoCalls gets all the calls that were made to PageInfo. Check the length with: 

len(mockedJobIterator.PageInfoCalls())

func (*JobIteratorMock) SetAllUsers 

func (mock *JobIteratorMock) SetAllUsers(in1 bool)

SetAllUsers calls SetAllUsersFunc.

func (*JobIteratorMock) SetAllUsersCalls 

func (mock *JobIteratorMock) SetAllUsersCalls() []struct {
	In1 bool
}

SetAllUsersCalls gets all the calls that were made to SetAllUsers. Check the length with: 

len(mockedJobIterator.SetAllUsersCalls())

func (*JobIteratorMock) SetProjectID 

func (mock *JobIteratorMock) SetProjectID(in1 string)

SetProjectID calls SetProjectIDFunc.

func (*JobIteratorMock) SetProjectIDCalls 

func (mock *JobIteratorMock) SetProjectIDCalls() []struct {
	In1 string
}

SetProjectIDCalls gets all the calls that were made to SetProjectID. Check the length with: 

len(mockedJobIterator.SetProjectIDCalls())

func (*JobIteratorMock) SetState 

func (mock *JobIteratorMock) SetState(in1 bigquery.State)

SetState calls SetStateFunc.

func (*JobIteratorMock) SetStateCalls 

func (mock *JobIteratorMock) SetStateCalls() []struct {
	In1 bigquery.State
}

SetStateCalls gets all the calls that were made to SetState. Check the length with: 

len(mockedJobIterator.SetStateCalls())

type JobMock 

type JobMock struct {
	// CancelFunc mocks the Cancel method.
	CancelFunc func(in1 context.Context) error

	// ConfigFunc mocks the Config method.
	ConfigFunc func() (bigquery.JobConfig, error)

	// IDFunc mocks the ID method.
	IDFunc func() string

	// LastStatusFunc mocks the LastStatus method.
	LastStatusFunc func() *bigquery.JobStatus

	// LocationFunc mocks the Location method.
	LocationFunc func() string

	// ReadFunc mocks the Read method.
	ReadFunc func(in1 context.Context) (bqiface.RowIterator, error)

	// StatusFunc mocks the Status method.
	StatusFunc func(in1 context.Context) (*bigquery.JobStatus, error)

	// WaitFunc mocks the Wait method.
	WaitFunc func(in1 context.Context) (*bigquery.JobStatus, error)
	// contains filtered or unexported fields
}

JobMock is a mock implementation of bqiface.Job. 

    func TestSomethingThatUsesJob(t *testing.T) {

        // make and configure a mocked bqiface.Job
        mockedJob := &JobMock{
            CancelFunc: func(in1 context.Context) error {
	               panic("mock out the Cancel method")
            },
            ConfigFunc: func() (bigquery.JobConfig, error) {
	               panic("mock out the Config method")
            },
            IDFunc: func() string {
	               panic("mock out the ID method")
            },
            LastStatusFunc: func() *bigquery.JobStatus {
	               panic("mock out the LastStatus method")
            },
            LocationFunc: func() string {
	               panic("mock out the Location method")
            },
            ReadFunc: func(in1 context.Context) (bqiface.RowIterator, error) {
	               panic("mock out the Read method")
            },
            StatusFunc: func(in1 context.Context) (*bigquery.JobStatus, error) {
	               panic("mock out the Status method")
            },
            WaitFunc: func(in1 context.Context) (*bigquery.JobStatus, error) {
	               panic("mock out the Wait method")
            },
        }

        // use mockedJob in code that requires bqiface.Job
        // and then make assertions.

    }

func (*JobMock) Cancel 

func (mock *JobMock) Cancel(in1 context.Context) error

Cancel calls CancelFunc.

func (*JobMock) CancelCalls 

func (mock *JobMock) CancelCalls() []struct {
	In1 context.Context
}

CancelCalls gets all the calls that were made to Cancel. Check the length with: 

len(mockedJob.CancelCalls())

func (*JobMock) Config 

func (mock *JobMock) Config() (bigquery.JobConfig, error)

Config calls ConfigFunc.

func (*JobMock) ConfigCalls 

func (mock *JobMock) ConfigCalls() []struct {
}

ConfigCalls gets all the calls that were made to Config. Check the length with: 

len(mockedJob.ConfigCalls())

func (*JobMock) ID 

func (mock *JobMock) ID() string

ID calls IDFunc.

func (*JobMock) IDCalls 

func (mock *JobMock) IDCalls() []struct {
}

IDCalls gets all the calls that were made to ID. Check the length with: 

len(mockedJob.IDCalls())

func (*JobMock) LastStatus 

func (mock *JobMock) LastStatus() *bigquery.JobStatus

LastStatus calls LastStatusFunc.

func (*JobMock) LastStatusCalls 

func (mock *JobMock) LastStatusCalls() []struct {
}

LastStatusCalls gets all the calls that were made to LastStatus. Check the length with: 

len(mockedJob.LastStatusCalls())

func (*JobMock) Location 

func (mock *JobMock) Location() string

Location calls LocationFunc.

func (*JobMock) LocationCalls 

func (mock *JobMock) LocationCalls() []struct {
}

LocationCalls gets all the calls that were made to Location. Check the length with: 

len(mockedJob.LocationCalls())

func (*JobMock) Read 

func (mock *JobMock) Read(in1 context.Context) (bqiface.RowIterator, error)

Read calls ReadFunc.

func (*JobMock) ReadCalls 

func (mock *JobMock) ReadCalls() []struct {
	In1 context.Context
}

ReadCalls gets all the calls that were made to Read. Check the length with: 

len(mockedJob.ReadCalls())

func (*JobMock) Status 

func (mock *JobMock) Status(in1 context.Context) (*bigquery.JobStatus, error)

Status calls StatusFunc.

func (*JobMock) StatusCalls 

func (mock *JobMock) StatusCalls() []struct {
	In1 context.Context
}

StatusCalls gets all the calls that were made to Status. Check the length with: 

len(mockedJob.StatusCalls())

func (*JobMock) Wait 

func (mock *JobMock) Wait(in1 context.Context) (*bigquery.JobStatus, error)

Wait calls WaitFunc.

func (*JobMock) WaitCalls 

func (mock *JobMock) WaitCalls() []struct {
	In1 context.Context
}

WaitCalls gets all the calls that were made to Wait. Check the length with: 

len(mockedJob.WaitCalls())

type LoaderMock 

type LoaderMock struct {
	// JobIDConfigFunc mocks the JobIDConfig method.
	JobIDConfigFunc func() *bigquery.JobIDConfig

	// RunFunc mocks the Run method.
	RunFunc func(in1 context.Context) (bqiface.Job, error)

	// SetLoadConfigFunc mocks the SetLoadConfig method.
	SetLoadConfigFunc func(in1 bqiface.LoadConfig)
	// contains filtered or unexported fields
}

LoaderMock is a mock implementation of bqiface.Loader. 

    func TestSomethingThatUsesLoader(t *testing.T) {

        // make and configure a mocked bqiface.Loader
        mockedLoader := &LoaderMock{
            JobIDConfigFunc: func() *bigquery.JobIDConfig {
	               panic("mock out the JobIDConfig method")
            },
            RunFunc: func(in1 context.Context) (bqiface.Job, error) {
	               panic("mock out the Run method")
            },
            SetLoadConfigFunc: func(in1 bqiface.LoadConfig)  {
	               panic("mock out the SetLoadConfig method")
            },
        }

        // use mockedLoader in code that requires bqiface.Loader
        // and then make assertions.

    }

func (*LoaderMock) JobIDConfig 

func (mock *LoaderMock) JobIDConfig() *bigquery.JobIDConfig

JobIDConfig calls JobIDConfigFunc.

func (*LoaderMock) JobIDConfigCalls 

func (mock *LoaderMock) JobIDConfigCalls() []struct {
}

JobIDConfigCalls gets all the calls that were made to JobIDConfig. Check the length with: 

len(mockedLoader.JobIDConfigCalls())

func (*LoaderMock) Run 

func (mock *LoaderMock) Run(in1 context.Context) (bqiface.Job, error)

Run calls RunFunc.

func (*LoaderMock) RunCalls 

func (mock *LoaderMock) RunCalls() []struct {
	In1 context.Context
}

RunCalls gets all the calls that were made to Run. Check the length with: 

len(mockedLoader.RunCalls())

func (*LoaderMock) SetLoadConfig 

func (mock *LoaderMock) SetLoadConfig(in1 bqiface.LoadConfig)

SetLoadConfig calls SetLoadConfigFunc.

func (*LoaderMock) SetLoadConfigCalls 

func (mock *LoaderMock) SetLoadConfigCalls() []struct {
	In1 bqiface.LoadConfig
}

SetLoadConfigCalls gets all the calls that were made to SetLoadConfig. Check the length with: 

len(mockedLoader.SetLoadConfigCalls())

type QueryMock 

type QueryMock struct {
	// JobIDConfigFunc mocks the JobIDConfig method.
	JobIDConfigFunc func() *bigquery.JobIDConfig

	// ReadFunc mocks the Read method.
	ReadFunc func(in1 context.Context) (bqiface.RowIterator, error)

	// RunFunc mocks the Run method.
	RunFunc func(in1 context.Context) (bqiface.Job, error)

	// SetQueryConfigFunc mocks the SetQueryConfig method.
	SetQueryConfigFunc func(in1 bqiface.QueryConfig)
	// contains filtered or unexported fields
}

QueryMock is a mock implementation of bqiface.Query. 

    func TestSomethingThatUsesQuery(t *testing.T) {

        // make and configure a mocked bqiface.Query
        mockedQuery := &QueryMock{
            JobIDConfigFunc: func() *bigquery.JobIDConfig {
	               panic("mock out the JobIDConfig method")
            },
            ReadFunc: func(in1 context.Context) (bqiface.RowIterator, error) {
	               panic("mock out the Read method")
            },
            RunFunc: func(in1 context.Context) (bqiface.Job, error) {
	               panic("mock out the Run method")
            },
            SetQueryConfigFunc: func(in1 bqiface.QueryConfig)  {
	               panic("mock out the SetQueryConfig method")
            },
        }

        // use mockedQuery in code that requires bqiface.Query
        // and then make assertions.

    }

func (*QueryMock) JobIDConfig 

func (mock *QueryMock) JobIDConfig() *bigquery.JobIDConfig

JobIDConfig calls JobIDConfigFunc.

func (*QueryMock) JobIDConfigCalls 

func (mock *QueryMock) JobIDConfigCalls() []struct {
}

JobIDConfigCalls gets all the calls that were made to JobIDConfig. Check the length with: 

len(mockedQuery.JobIDConfigCalls())

func (*QueryMock) Read 

func (mock *QueryMock) Read(in1 context.Context) (bqiface.RowIterator, error)

Read calls ReadFunc.

func (*QueryMock) ReadCalls 

func (mock *QueryMock) ReadCalls() []struct {
	In1 context.Context
}

ReadCalls gets all the calls that were made to Read. Check the length with: 

len(mockedQuery.ReadCalls())

func (*QueryMock) Run 

func (mock *QueryMock) Run(in1 context.Context) (bqiface.Job, error)

Run calls RunFunc.

func (*QueryMock) RunCalls 

func (mock *QueryMock) RunCalls() []struct {
	In1 context.Context
}

RunCalls gets all the calls that were made to Run. Check the length with: 

len(mockedQuery.RunCalls())

func (*QueryMock) SetQueryConfig 

func (mock *QueryMock) SetQueryConfig(in1 bqiface.QueryConfig)

SetQueryConfig calls SetQueryConfigFunc.

func (*QueryMock) SetQueryConfigCalls 

func (mock *QueryMock) SetQueryConfigCalls() []struct {
	In1 bqiface.QueryConfig
}

SetQueryConfigCalls gets all the calls that were made to SetQueryConfig. Check the length with: 

len(mockedQuery.SetQueryConfigCalls())

type RowIteratorMock 

type RowIteratorMock struct {
	// NextFunc mocks the Next method.
	NextFunc func(in1 interface{}) error

	// PageInfoFunc mocks the PageInfo method.
	PageInfoFunc func() *iterator.PageInfo

	// SchemaFunc mocks the Schema method.
	SchemaFunc func() bigquery.Schema

	// SetStartIndexFunc mocks the SetStartIndex method.
	SetStartIndexFunc func(in1 uint64)

	// TotalRowsFunc mocks the TotalRows method.
	TotalRowsFunc func() uint64
	// contains filtered or unexported fields
}

RowIteratorMock is a mock implementation of bqiface.RowIterator. 

    func TestSomethingThatUsesRowIterator(t *testing.T) {

        // make and configure a mocked bqiface.RowIterator
        mockedRowIterator := &RowIteratorMock{
            NextFunc: func(in1 interface{}) error {
	               panic("mock out the Next method")
            },
            PageInfoFunc: func() *iterator.PageInfo {
	               panic("mock out the PageInfo method")
            },
            SchemaFunc: func() bigquery.Schema {
	               panic("mock out the Schema method")
            },
            SetStartIndexFunc: func(in1 uint64)  {
	               panic("mock out the SetStartIndex method")
            },
            TotalRowsFunc: func() uint64 {
	               panic("mock out the TotalRows method")
            },
        }

        // use mockedRowIterator in code that requires bqiface.RowIterator
        // and then make assertions.

    }

func (*RowIteratorMock) Next 

func (mock *RowIteratorMock) Next(in1 interface{}) error

Next calls NextFunc.

func (*RowIteratorMock) NextCalls 

func (mock *RowIteratorMock) NextCalls() []struct {
	In1 interface{}
}

NextCalls gets all the calls that were made to Next. Check the length with: 

len(mockedRowIterator.NextCalls())

func (*RowIteratorMock) PageInfo 

func (mock *RowIteratorMock) PageInfo() *iterator.PageInfo

PageInfo calls PageInfoFunc.

func (*RowIteratorMock) PageInfoCalls 

func (mock *RowIteratorMock) PageInfoCalls() []struct {
}

PageInfoCalls gets all the calls that were made to PageInfo. Check the length with: 

len(mockedRowIterator.PageInfoCalls())

func (*RowIteratorMock) Schema 

func (mock *RowIteratorMock) Schema() bigquery.Schema

Schema calls SchemaFunc.

func (*RowIteratorMock) SchemaCalls 

func (mock *RowIteratorMock) SchemaCalls() []struct {
}

SchemaCalls gets all the calls that were made to Schema. Check the length with: 

len(mockedRowIterator.SchemaCalls())

func (*RowIteratorMock) SetStartIndex 

func (mock *RowIteratorMock) SetStartIndex(in1 uint64)

SetStartIndex calls SetStartIndexFunc.

func (*RowIteratorMock) SetStartIndexCalls 

func (mock *RowIteratorMock) SetStartIndexCalls() []struct {
	In1 uint64
}

SetStartIndexCalls gets all the calls that were made to SetStartIndex. Check the length with: 

len(mockedRowIterator.SetStartIndexCalls())

func (*RowIteratorMock) TotalRows 

func (mock *RowIteratorMock) TotalRows() uint64

TotalRows calls TotalRowsFunc.

func (*RowIteratorMock) TotalRowsCalls 

func (mock *RowIteratorMock) TotalRowsCalls() []struct {
}

TotalRowsCalls gets all the calls that were made to TotalRows. Check the length with: 

len(mockedRowIterator.TotalRowsCalls())

type TableIteratorMock 

type TableIteratorMock struct {
	// NextFunc mocks the Next method.
	NextFunc func() (bqiface.Table, error)

	// PageInfoFunc mocks the PageInfo method.
	PageInfoFunc func() *iterator.PageInfo
	// contains filtered or unexported fields
}

TableIteratorMock is a mock implementation of bqiface.TableIterator. 

    func TestSomethingThatUsesTableIterator(t *testing.T) {

        // make and configure a mocked bqiface.TableIterator
        mockedTableIterator := &TableIteratorMock{
            NextFunc: func() (bqiface.Table, error) {
	               panic("mock out the Next method")
            },
            PageInfoFunc: func() *iterator.PageInfo {
	               panic("mock out the PageInfo method")
            },
        }

        // use mockedTableIterator in code that requires bqiface.TableIterator
        // and then make assertions.

    }

func (*TableIteratorMock) Next 

func (mock *TableIteratorMock) Next() (bqiface.Table, error)

Next calls NextFunc.

func (*TableIteratorMock) NextCalls 

func (mock *TableIteratorMock) NextCalls() []struct {
}

NextCalls gets all the calls that were made to Next. Check the length with: 

len(mockedTableIterator.NextCalls())

func (*TableIteratorMock) PageInfo 

func (mock *TableIteratorMock) PageInfo() *iterator.PageInfo

PageInfo calls PageInfoFunc.

func (*TableIteratorMock) PageInfoCalls 

func (mock *TableIteratorMock) PageInfoCalls() []struct {
}

PageInfoCalls gets all the calls that were made to PageInfo. Check the length with: 

len(mockedTableIterator.PageInfoCalls())

type TableMock 

type TableMock struct {
	// CopierFromFunc mocks the CopierFrom method.
	CopierFromFunc func(in1 ...bqiface.Table) bqiface.Copier

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 context.Context, in2 *bigquery.TableMetadata) error

	// DatasetIDFunc mocks the DatasetID method.
	DatasetIDFunc func() string

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(in1 context.Context) error

	// ExtractorToFunc mocks the ExtractorTo method.
	ExtractorToFunc func(dst *bigquery.GCSReference) bqiface.Extractor

	// FullyQualifiedNameFunc mocks the FullyQualifiedName method.
	FullyQualifiedNameFunc func() string

	// LoaderFromFunc mocks the LoaderFrom method.
	LoaderFromFunc func(in1 bigquery.LoadSource) bqiface.Loader

	// MetadataFunc mocks the Metadata method.
	MetadataFunc func(in1 context.Context) (*bigquery.TableMetadata, error)

	// ProjectIDFunc mocks the ProjectID method.
	ProjectIDFunc func() string

	// ReadFunc mocks the Read method.
	ReadFunc func(ctx context.Context) bqiface.RowIterator

	// TableIDFunc mocks the TableID method.
	TableIDFunc func() string

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 context.Context, in2 bigquery.TableMetadataToUpdate, in3 string) (*bigquery.TableMetadata, error)

	// UploaderFunc mocks the Uploader method.
	UploaderFunc func() bqiface.Uploader
	// contains filtered or unexported fields
}

TableMock is a mock implementation of bqiface.Table. 

    func TestSomethingThatUsesTable(t *testing.T) {

        // make and configure a mocked bqiface.Table
        mockedTable := &TableMock{
            CopierFromFunc: func(in1 ...bqiface.Table) bqiface.Copier {
	               panic("mock out the CopierFrom method")
            },
            CreateFunc: func(in1 context.Context, in2 *bigquery.TableMetadata) error {
	               panic("mock out the Create method")
            },
            DatasetIDFunc: func() string {
	               panic("mock out the DatasetID method")
            },
            DeleteFunc: func(in1 context.Context) error {
	               panic("mock out the Delete method")
            },
            ExtractorToFunc: func(dst *bigquery.GCSReference) bqiface.Extractor {
	               panic("mock out the ExtractorTo method")
            },
            FullyQualifiedNameFunc: func() string {
	               panic("mock out the FullyQualifiedName method")
            },
            LoaderFromFunc: func(in1 bigquery.LoadSource) bqiface.Loader {
	               panic("mock out the LoaderFrom method")
            },
            MetadataFunc: func(in1 context.Context) (*bigquery.TableMetadata, error) {
	               panic("mock out the Metadata method")
            },
            ProjectIDFunc: func() string {
	               panic("mock out the ProjectID method")
            },
            ReadFunc: func(ctx context.Context) bqiface.RowIterator {
	               panic("mock out the Read method")
            },
            TableIDFunc: func() string {
	               panic("mock out the TableID method")
            },
            UpdateFunc: func(in1 context.Context, in2 bigquery.TableMetadataToUpdate, in3 string) (*bigquery.TableMetadata, error) {
	               panic("mock out the Update method")
            },
            UploaderFunc: func() bqiface.Uploader {
	               panic("mock out the Uploader method")
            },
        }

        // use mockedTable in code that requires bqiface.Table
        // and then make assertions.

    }

func (*TableMock) CopierFrom 

func (mock *TableMock) CopierFrom(in1 ...bqiface.Table) bqiface.Copier

CopierFrom calls CopierFromFunc.

func (*TableMock) CopierFromCalls 

func (mock *TableMock) CopierFromCalls() []struct {
	In1 []bqiface.Table
}

CopierFromCalls gets all the calls that were made to CopierFrom. Check the length with: 

len(mockedTable.CopierFromCalls())

func (*TableMock) Create 

func (mock *TableMock) Create(in1 context.Context, in2 *bigquery.TableMetadata) error

Create calls CreateFunc.

func (*TableMock) CreateCalls 

func (mock *TableMock) CreateCalls() []struct {
	In1 context.Context
	In2 *bigquery.TableMetadata
}

CreateCalls gets all the calls that were made to Create. Check the length with: 

len(mockedTable.CreateCalls())

func (*TableMock) DatasetID 

func (mock *TableMock) DatasetID() string

DatasetID calls DatasetIDFunc.

func (*TableMock) DatasetIDCalls 

func (mock *TableMock) DatasetIDCalls() []struct {
}

DatasetIDCalls gets all the calls that were made to DatasetID. Check the length with: 

len(mockedTable.DatasetIDCalls())

func (*TableMock) Delete 

func (mock *TableMock) Delete(in1 context.Context) error

Delete calls DeleteFunc.

func (*TableMock) DeleteCalls 

func (mock *TableMock) DeleteCalls() []struct {
	In1 context.Context
}

DeleteCalls gets all the calls that were made to Delete. Check the length with: 

len(mockedTable.DeleteCalls())

func (*TableMock) ExtractorTo 

func (mock *TableMock) ExtractorTo(dst *bigquery.GCSReference) bqiface.Extractor

ExtractorTo calls ExtractorToFunc.

func (*TableMock) ExtractorToCalls 

func (mock *TableMock) ExtractorToCalls() []struct {
	Dst *bigquery.GCSReference
}

ExtractorToCalls gets all the calls that were made to ExtractorTo. Check the length with: 

len(mockedTable.ExtractorToCalls())

func (*TableMock) FullyQualifiedName 

func (mock *TableMock) FullyQualifiedName() string

FullyQualifiedName calls FullyQualifiedNameFunc.

func (*TableMock) FullyQualifiedNameCalls 

func (mock *TableMock) FullyQualifiedNameCalls() []struct {
}

FullyQualifiedNameCalls gets all the calls that were made to FullyQualifiedName. Check the length with: 

len(mockedTable.FullyQualifiedNameCalls())

func (*TableMock) LoaderFrom 

func (mock *TableMock) LoaderFrom(in1 bigquery.LoadSource) bqiface.Loader

LoaderFrom calls LoaderFromFunc.

func (*TableMock) LoaderFromCalls 

func (mock *TableMock) LoaderFromCalls() []struct {
	In1 bigquery.LoadSource
}

LoaderFromCalls gets all the calls that were made to LoaderFrom. Check the length with: 

len(mockedTable.LoaderFromCalls())

func (*TableMock) Metadata 

func (mock *TableMock) Metadata(in1 context.Context) (*bigquery.TableMetadata, error)

Metadata calls MetadataFunc.

func (*TableMock) MetadataCalls 

func (mock *TableMock) MetadataCalls() []struct {
	In1 context.Context
}

MetadataCalls gets all the calls that were made to Metadata. Check the length with: 

len(mockedTable.MetadataCalls())

func (*TableMock) ProjectID 

func (mock *TableMock) ProjectID() string

ProjectID calls ProjectIDFunc.

func (*TableMock) ProjectIDCalls 

func (mock *TableMock) ProjectIDCalls() []struct {
}

ProjectIDCalls gets all the calls that were made to ProjectID. Check the length with: 

len(mockedTable.ProjectIDCalls())

func (*TableMock) Read 

func (mock *TableMock) Read(ctx context.Context) bqiface.RowIterator

Read calls ReadFunc.

func (*TableMock) ReadCalls 

func (mock *TableMock) ReadCalls() []struct {
	Ctx context.Context
}

ReadCalls gets all the calls that were made to Read. Check the length with: 

len(mockedTable.ReadCalls())

func (*TableMock) TableID 

func (mock *TableMock) TableID() string

TableID calls TableIDFunc.

func (*TableMock) TableIDCalls 

func (mock *TableMock) TableIDCalls() []struct {
}

TableIDCalls gets all the calls that were made to TableID. Check the length with: 

len(mockedTable.TableIDCalls())

func (*TableMock) Update 

func (mock *TableMock) Update(in1 context.Context, in2 bigquery.TableMetadataToUpdate, in3 string) (*bigquery.TableMetadata, error)

Update calls UpdateFunc.

func (*TableMock) UpdateCalls 

func (mock *TableMock) UpdateCalls() []struct {
	In1 context.Context
	In2 bigquery.TableMetadataToUpdate
	In3 string
}

UpdateCalls gets all the calls that were made to Update. Check the length with: 

len(mockedTable.UpdateCalls())

func (*TableMock) Uploader 

func (mock *TableMock) Uploader() bqiface.Uploader

Uploader calls UploaderFunc.

func (*TableMock) UploaderCalls 

func (mock *TableMock) UploaderCalls() []struct {
}

UploaderCalls gets all the calls that were made to Uploader. Check the length with: 

len(mockedTable.UploaderCalls())

type UploaderMock 

type UploaderMock struct {
	// PutFunc mocks the Put method.
	PutFunc func(in1 context.Context, in2 interface{}) error

	// SetIgnoreUnknownValuesFunc mocks the SetIgnoreUnknownValues method.
	SetIgnoreUnknownValuesFunc func(in1 bool)

	// SetSkipInvalidRowsFunc mocks the SetSkipInvalidRows method.
	SetSkipInvalidRowsFunc func(in1 bool)

	// SetTableTemplateSuffixFunc mocks the SetTableTemplateSuffix method.
	SetTableTemplateSuffixFunc func(in1 string)
	// contains filtered or unexported fields
}

UploaderMock is a mock implementation of bqiface.Uploader. 

    func TestSomethingThatUsesUploader(t *testing.T) {

        // make and configure a mocked bqiface.Uploader
        mockedUploader := &UploaderMock{
            PutFunc: func(in1 context.Context, in2 interface{}) error {
	               panic("mock out the Put method")
            },
            SetIgnoreUnknownValuesFunc: func(in1 bool)  {
	               panic("mock out the SetIgnoreUnknownValues method")
            },
            SetSkipInvalidRowsFunc: func(in1 bool)  {
	               panic("mock out the SetSkipInvalidRows method")
            },
            SetTableTemplateSuffixFunc: func(in1 string)  {
	               panic("mock out the SetTableTemplateSuffix method")
            },
        }

        // use mockedUploader in code that requires bqiface.Uploader
        // and then make assertions.

    }

func (*UploaderMock) Put 

func (mock *UploaderMock) Put(in1 context.Context, in2 interface{}) error

Put calls PutFunc.

func (*UploaderMock) PutCalls 

func (mock *UploaderMock) PutCalls() []struct {
	In1 context.Context
	In2 interface{}
}

PutCalls gets all the calls that were made to Put. Check the length with: 

len(mockedUploader.PutCalls())

func (*UploaderMock) SetIgnoreUnknownValues 

func (mock *UploaderMock) SetIgnoreUnknownValues(in1 bool)

SetIgnoreUnknownValues calls SetIgnoreUnknownValuesFunc.

func (*UploaderMock) SetIgnoreUnknownValuesCalls 

func (mock *UploaderMock) SetIgnoreUnknownValuesCalls() []struct {
	In1 bool
}

SetIgnoreUnknownValuesCalls gets all the calls that were made to SetIgnoreUnknownValues. Check the length with: 

len(mockedUploader.SetIgnoreUnknownValuesCalls())

func (*UploaderMock) SetSkipInvalidRows 

func (mock *UploaderMock) SetSkipInvalidRows(in1 bool)

SetSkipInvalidRows calls SetSkipInvalidRowsFunc.

func (*UploaderMock) SetSkipInvalidRowsCalls 

func (mock *UploaderMock) SetSkipInvalidRowsCalls() []struct {
	In1 bool
}

SetSkipInvalidRowsCalls gets all the calls that were made to SetSkipInvalidRows. Check the length with: 

len(mockedUploader.SetSkipInvalidRowsCalls())

func (*UploaderMock) SetTableTemplateSuffix 

func (mock *UploaderMock) SetTableTemplateSuffix(in1 string)

SetTableTemplateSuffix calls SetTableTemplateSuffixFunc.

func (*UploaderMock) SetTableTemplateSuffixCalls 

func (mock *UploaderMock) SetTableTemplateSuffixCalls() []struct {
	In1 string
}

SetTableTemplateSuffixCalls gets all the calls that were made to SetTableTemplateSuffix. Check the length with: 

len(mockedUploader.SetTableTemplateSuffixCalls())

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.