// Code generated by MockGen. DO NOT EDIT.
// Source: ./pkg/processor/interface.go

// Package mock_data_processor is a generated GoMock package.
package mock_data_processor

import (
	reflect "reflect"

	s3 "github.com/aws/aws-sdk-go-v2/service/s3"
	gomock "github.com/golang/mock/gomock"
	context "golang.org/x/net/context"
)

// Mocks3Client is a mock of s3Client interface.
type Mocks3Client struct {
	ctrl     *gomock.Controller
	recorder *Mocks3ClientMockRecorder
}

// Mocks3ClientMockRecorder is the mock recorder for Mocks3Client.
type Mocks3ClientMockRecorder struct {
	mock *Mocks3Client
}

// NewMocks3Client creates a new mock instance.
func NewMocks3Client(ctrl *gomock.Controller) *Mocks3Client {
	mock := &Mocks3Client{ctrl: ctrl}
	mock.recorder = &Mocks3ClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mocks3Client) EXPECT() *Mocks3ClientMockRecorder {
	return m.recorder
}

// GetObject mocks base method.
func (m *Mocks3Client) GetObject(ctx context.Context, params *s3.GetObjectInput, optFns ...func(*s3.Options)) (*s3.GetObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObject", varargs...)
	ret0, _ := ret[0].(*s3.GetObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObject indicates an expected call of GetObject.
func (mr *Mocks3ClientMockRecorder) GetObject(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*Mocks3Client)(nil).GetObject), varargs...)
}

// ListObjects mocks base method.
func (m *Mocks3Client) ListObjects(ctx context.Context, params *s3.ListObjectsInput, optFns ...func(*s3.Options)) (*s3.ListObjectsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjects", varargs...)
	ret0, _ := ret[0].(*s3.ListObjectsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjects indicates an expected call of ListObjects.
func (mr *Mocks3ClientMockRecorder) ListObjects(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjects", reflect.TypeOf((*Mocks3Client)(nil).ListObjects), varargs...)
}

// PutObject mocks base method.
func (m *Mocks3Client) PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutObject", varargs...)
	ret0, _ := ret[0].(*s3.PutObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutObject indicates an expected call of PutObject.
func (mr *Mocks3ClientMockRecorder) PutObject(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*Mocks3Client)(nil).PutObject), varargs...)
}

// MockS3 is a mock of S3 interface.
type MockS3 struct {
	ctrl     *gomock.Controller
	recorder *MockS3MockRecorder
}

// MockS3MockRecorder is the mock recorder for MockS3.
type MockS3MockRecorder struct {
	mock *MockS3
}

// NewMockS3 creates a new mock instance.
func NewMockS3(ctrl *gomock.Controller) *MockS3 {
	mock := &MockS3{ctrl: ctrl}
	mock.recorder = &MockS3MockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockS3) EXPECT() *MockS3MockRecorder {
	return m.recorder
}

// DownloadFiles mocks base method.
func (m *MockS3) DownloadFiles(bucket, prefix string) (map[string]*s3.GetObjectOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadFiles", bucket, prefix)
	ret0, _ := ret[0].(map[string]*s3.GetObjectOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DownloadFiles indicates an expected call of DownloadFiles.
func (mr *MockS3MockRecorder) DownloadFiles(bucket, prefix interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadFiles", reflect.TypeOf((*MockS3)(nil).DownloadFiles), bucket, prefix)
}

// UploadFile mocks base method.
func (m *MockS3) UploadFile(fn, bucket, key string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadFile", fn, bucket, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// UploadFile indicates an expected call of UploadFile.
func (mr *MockS3MockRecorder) UploadFile(fn, bucket, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadFile", reflect.TypeOf((*MockS3)(nil).UploadFile), fn, bucket, key)
}

// MockProcessor is a mock of Processor interface.
type MockProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockProcessorMockRecorder
}

// MockProcessorMockRecorder is the mock recorder for MockProcessor.
type MockProcessorMockRecorder struct {
	mock *MockProcessor
}

// NewMockProcessor creates a new mock instance.
func NewMockProcessor(ctrl *gomock.Controller) *MockProcessor {
	mock := &MockProcessor{ctrl: ctrl}
	mock.recorder = &MockProcessorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProcessor) EXPECT() *MockProcessorMockRecorder {
	return m.recorder
}

// CleanData mocks base method.
func (m *MockProcessor) CleanData(bucket, dir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanData", bucket, dir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// CleanData indicates an expected call of CleanData.
func (mr *MockProcessorMockRecorder) CleanData(bucket, dir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanData", reflect.TypeOf((*MockProcessor)(nil).CleanData), bucket, dir, dataSource, version)
}

// GenerateDB mocks base method.
func (m *MockProcessor) GenerateDB(bucket, dir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateDB", bucket, dir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// GenerateDB indicates an expected call of GenerateDB.
func (mr *MockProcessorMockRecorder) GenerateDB(bucket, dir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDB", reflect.TypeOf((*MockProcessor)(nil).GenerateDB), bucket, dir, dataSource, version)
}

// JoinCleanedData mocks base method.
func (m *MockProcessor) JoinCleanedData(readDir, writeDir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinCleanedData", readDir, writeDir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// JoinCleanedData indicates an expected call of JoinCleanedData.
func (mr *MockProcessorMockRecorder) JoinCleanedData(readDir, writeDir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinCleanedData", reflect.TypeOf((*MockProcessor)(nil).JoinCleanedData), readDir, writeDir, dataSource, version)
}

// MergeProcessedData mocks base method.
func (m *MockProcessor) MergeProcessedData(bucket, writeDir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeProcessedData", bucket, writeDir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// MergeProcessedData indicates an expected call of MergeProcessedData.
func (mr *MockProcessorMockRecorder) MergeProcessedData(bucket, writeDir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeProcessedData", reflect.TypeOf((*MockProcessor)(nil).MergeProcessedData), bucket, writeDir, dataSource, version)
}

// ProcessCleanedData mocks base method.
func (m *MockProcessor) ProcessCleanedData(readDir, writeDir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessCleanedData", readDir, writeDir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessCleanedData indicates an expected call of ProcessCleanedData.
func (mr *MockProcessorMockRecorder) ProcessCleanedData(readDir, writeDir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessCleanedData", reflect.TypeOf((*MockProcessor)(nil).ProcessCleanedData), readDir, writeDir, dataSource, version)
}

// UploadConstructedDB mocks base method.
func (m *MockProcessor) UploadConstructedDB(bucket, dir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadConstructedDB", bucket, dir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// UploadConstructedDB indicates an expected call of UploadConstructedDB.
func (mr *MockProcessorMockRecorder) UploadConstructedDB(bucket, dir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadConstructedDB", reflect.TypeOf((*MockProcessor)(nil).UploadConstructedDB), bucket, dir, dataSource, version)
}

// UploadJoinedData mocks base method.
func (m *MockProcessor) UploadJoinedData(bucket, dir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadJoinedData", bucket, dir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// UploadJoinedData indicates an expected call of UploadJoinedData.
func (mr *MockProcessorMockRecorder) UploadJoinedData(bucket, dir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadJoinedData", reflect.TypeOf((*MockProcessor)(nil).UploadJoinedData), bucket, dir, dataSource, version)
}

// UploadMergedData mocks base method.
func (m *MockProcessor) UploadMergedData(bucket, dir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadMergedData", bucket, dir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// UploadMergedData indicates an expected call of UploadMergedData.
func (mr *MockProcessorMockRecorder) UploadMergedData(bucket, dir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadMergedData", reflect.TypeOf((*MockProcessor)(nil).UploadMergedData), bucket, dir, dataSource, version)
}

// UploadProcessedData mocks base method.
func (m *MockProcessor) UploadProcessedData(bucket, dir, dataSource, version string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadProcessedData", bucket, dir, dataSource, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// UploadProcessedData indicates an expected call of UploadProcessedData.
func (mr *MockProcessorMockRecorder) UploadProcessedData(bucket, dir, dataSource, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadProcessedData", reflect.TypeOf((*MockProcessor)(nil).UploadProcessedData), bucket, dir, dataSource, version)
}

// MockTask is a mock of Task interface.
type MockTask struct {
	ctrl     *gomock.Controller
	recorder *MockTaskMockRecorder
}

// MockTaskMockRecorder is the mock recorder for MockTask.
type MockTaskMockRecorder struct {
	mock *MockTask
}

// NewMockTask creates a new mock instance.
func NewMockTask(ctrl *gomock.Controller) *MockTask {
	mock := &MockTask{ctrl: ctrl}
	mock.recorder = &MockTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTask) EXPECT() *MockTaskMockRecorder {
	return m.recorder
}

// CleanAndProcessData mocks base method.
func (m *MockTask) CleanAndProcessData(bucket string, dataSources []string, version string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CleanAndProcessData", bucket, dataSources, version)
}

// CleanAndProcessData indicates an expected call of CleanAndProcessData.
func (mr *MockTaskMockRecorder) CleanAndProcessData(bucket, dataSources, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanAndProcessData", reflect.TypeOf((*MockTask)(nil).CleanAndProcessData), bucket, dataSources, version)
}

// JoinData mocks base method.
func (m *MockTask) JoinData(bucket, evaBucket string, dataSources []string, version string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "JoinData", bucket, evaBucket, dataSources, version)
}

// JoinData indicates an expected call of JoinData.
func (mr *MockTaskMockRecorder) JoinData(bucket, evaBucket, dataSources, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinData", reflect.TypeOf((*MockTask)(nil).JoinData), bucket, evaBucket, dataSources, version)
}

// MergeData mocks base method.
func (m *MockTask) MergeData(bucket, evaBucket string, dataSources []string, version string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "MergeData", bucket, evaBucket, dataSources, version)
}

// MergeData indicates an expected call of MergeData.
func (mr *MockTaskMockRecorder) MergeData(bucket, evaBucket, dataSources, version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeData", reflect.TypeOf((*MockTask)(nil).MergeData), bucket, evaBucket, dataSources, version)
}