mq.go

// Code generated by MockGen. DO NOT EDIT.
// Source: mq.go

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

import (
	context "context"
	reflect "reflect"

	mq "github.com/aws/aws-sdk-go-v2/service/mq"
	gomock "github.com/golang/mock/gomock"
)

// MockMqClient is a mock of MqClient interface.
type MockMqClient struct {
	ctrl     *gomock.Controller
	recorder *MockMqClientMockRecorder
}

// MockMqClientMockRecorder is the mock recorder for MockMqClient.
type MockMqClientMockRecorder struct {
	mock *MockMqClient
}

// NewMockMqClient creates a new mock instance.
func NewMockMqClient(ctrl *gomock.Controller) *MockMqClient {
	mock := &MockMqClient{ctrl: ctrl}
	mock.recorder = &MockMqClientMockRecorder{mock}
	return mock
}

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

// DescribeBroker mocks base method.
func (m *MockMqClient) DescribeBroker(arg0 context.Context, arg1 *mq.DescribeBrokerInput, arg2 ...func(*mq.Options)) (*mq.DescribeBrokerOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBroker", varargs...)
	ret0, _ := ret[0].(*mq.DescribeBrokerOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBroker indicates an expected call of DescribeBroker.
func (mr *MockMqClientMockRecorder) DescribeBroker(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBroker", reflect.TypeOf((*MockMqClient)(nil).DescribeBroker), varargs...)
}

// DescribeBrokerEngineTypes mocks base method.
func (m *MockMqClient) DescribeBrokerEngineTypes(arg0 context.Context, arg1 *mq.DescribeBrokerEngineTypesInput, arg2 ...func(*mq.Options)) (*mq.DescribeBrokerEngineTypesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBrokerEngineTypes", varargs...)
	ret0, _ := ret[0].(*mq.DescribeBrokerEngineTypesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBrokerEngineTypes indicates an expected call of DescribeBrokerEngineTypes.
func (mr *MockMqClientMockRecorder) DescribeBrokerEngineTypes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBrokerEngineTypes", reflect.TypeOf((*MockMqClient)(nil).DescribeBrokerEngineTypes), varargs...)
}

// DescribeBrokerInstanceOptions mocks base method.
func (m *MockMqClient) DescribeBrokerInstanceOptions(arg0 context.Context, arg1 *mq.DescribeBrokerInstanceOptionsInput, arg2 ...func(*mq.Options)) (*mq.DescribeBrokerInstanceOptionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBrokerInstanceOptions", varargs...)
	ret0, _ := ret[0].(*mq.DescribeBrokerInstanceOptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBrokerInstanceOptions indicates an expected call of DescribeBrokerInstanceOptions.
func (mr *MockMqClientMockRecorder) DescribeBrokerInstanceOptions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBrokerInstanceOptions", reflect.TypeOf((*MockMqClient)(nil).DescribeBrokerInstanceOptions), varargs...)
}

// DescribeConfiguration mocks base method.
func (m *MockMqClient) DescribeConfiguration(arg0 context.Context, arg1 *mq.DescribeConfigurationInput, arg2 ...func(*mq.Options)) (*mq.DescribeConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeConfiguration", varargs...)
	ret0, _ := ret[0].(*mq.DescribeConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeConfiguration indicates an expected call of DescribeConfiguration.
func (mr *MockMqClientMockRecorder) DescribeConfiguration(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfiguration", reflect.TypeOf((*MockMqClient)(nil).DescribeConfiguration), varargs...)
}

// DescribeConfigurationRevision mocks base method.
func (m *MockMqClient) DescribeConfigurationRevision(arg0 context.Context, arg1 *mq.DescribeConfigurationRevisionInput, arg2 ...func(*mq.Options)) (*mq.DescribeConfigurationRevisionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeConfigurationRevision", varargs...)
	ret0, _ := ret[0].(*mq.DescribeConfigurationRevisionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeConfigurationRevision indicates an expected call of DescribeConfigurationRevision.
func (mr *MockMqClientMockRecorder) DescribeConfigurationRevision(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationRevision", reflect.TypeOf((*MockMqClient)(nil).DescribeConfigurationRevision), varargs...)
}

// DescribeUser mocks base method.
func (m *MockMqClient) DescribeUser(arg0 context.Context, arg1 *mq.DescribeUserInput, arg2 ...func(*mq.Options)) (*mq.DescribeUserOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeUser", varargs...)
	ret0, _ := ret[0].(*mq.DescribeUserOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeUser indicates an expected call of DescribeUser.
func (mr *MockMqClientMockRecorder) DescribeUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUser", reflect.TypeOf((*MockMqClient)(nil).DescribeUser), varargs...)
}

// ListBrokers mocks base method.
func (m *MockMqClient) ListBrokers(arg0 context.Context, arg1 *mq.ListBrokersInput, arg2 ...func(*mq.Options)) (*mq.ListBrokersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBrokers", varargs...)
	ret0, _ := ret[0].(*mq.ListBrokersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBrokers indicates an expected call of ListBrokers.
func (mr *MockMqClientMockRecorder) ListBrokers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBrokers", reflect.TypeOf((*MockMqClient)(nil).ListBrokers), varargs...)
}

// ListConfigurationRevisions mocks base method.
func (m *MockMqClient) ListConfigurationRevisions(arg0 context.Context, arg1 *mq.ListConfigurationRevisionsInput, arg2 ...func(*mq.Options)) (*mq.ListConfigurationRevisionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListConfigurationRevisions", varargs...)
	ret0, _ := ret[0].(*mq.ListConfigurationRevisionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConfigurationRevisions indicates an expected call of ListConfigurationRevisions.
func (mr *MockMqClientMockRecorder) ListConfigurationRevisions(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConfigurationRevisions", reflect.TypeOf((*MockMqClient)(nil).ListConfigurationRevisions), varargs...)
}

// ListConfigurations mocks base method.
func (m *MockMqClient) ListConfigurations(arg0 context.Context, arg1 *mq.ListConfigurationsInput, arg2 ...func(*mq.Options)) (*mq.ListConfigurationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListConfigurations", varargs...)
	ret0, _ := ret[0].(*mq.ListConfigurationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConfigurations indicates an expected call of ListConfigurations.
func (mr *MockMqClientMockRecorder) ListConfigurations(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConfigurations", reflect.TypeOf((*MockMqClient)(nil).ListConfigurations), varargs...)
}

// ListTags mocks base method.
func (m *MockMqClient) ListTags(arg0 context.Context, arg1 *mq.ListTagsInput, arg2 ...func(*mq.Options)) (*mq.ListTagsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTags", varargs...)
	ret0, _ := ret[0].(*mq.ListTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTags indicates an expected call of ListTags.
func (mr *MockMqClientMockRecorder) ListTags(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockMqClient)(nil).ListTags), varargs...)
}

// ListUsers mocks base method.
func (m *MockMqClient) ListUsers(arg0 context.Context, arg1 *mq.ListUsersInput, arg2 ...func(*mq.Options)) (*mq.ListUsersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUsers", varargs...)
	ret0, _ := ret[0].(*mq.ListUsersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUsers indicates an expected call of ListUsers.
func (mr *MockMqClientMockRecorder) ListUsers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsers", reflect.TypeOf((*MockMqClient)(nil).ListUsers), varargs...)
}