github.com/aporeto-inc/trireme-lib@v10.358.0+incompatible/controller/pkg/ipsetmanager/mock_ipsetmanager/ipsetmanagermock.go

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

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

import (
	gomock "github.com/golang/mock/gomock"
	policy "go.aporeto.io/enforcerd/trireme-lib/policy"
	net "net"
	reflect "reflect"
)

// MockServerL3 is a mock of ServerL3 interface
type MockServerL3 struct {
	ctrl     *gomock.Controller
	recorder *MockServerL3MockRecorder
}

// MockServerL3MockRecorder is the mock recorder for MockServerL3
type MockServerL3MockRecorder struct {
	mock *MockServerL3
}

// NewMockServerL3 creates a new mock instance
func NewMockServerL3(ctrl *gomock.Controller) *MockServerL3 {
	mock := &MockServerL3{ctrl: ctrl}
	mock.recorder = &MockServerL3MockRecorder{mock}
	return mock
}

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

// CreateServerPortSet mocks base method
func (m *MockServerL3) CreateServerPortSet(contextID string) error {
	ret := m.ctrl.Call(m, "CreateServerPortSet", contextID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateServerPortSet indicates an expected call of CreateServerPortSet
func (mr *MockServerL3MockRecorder) CreateServerPortSet(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServerPortSet", reflect.TypeOf((*MockServerL3)(nil).CreateServerPortSet), contextID)
}

// GetServerPortSetName mocks base method
func (m *MockServerL3) GetServerPortSetName(contextID string) string {
	ret := m.ctrl.Call(m, "GetServerPortSetName", contextID)
	ret0, _ := ret[0].(string)
	return ret0
}

// GetServerPortSetName indicates an expected call of GetServerPortSetName
func (mr *MockServerL3MockRecorder) GetServerPortSetName(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerPortSetName", reflect.TypeOf((*MockServerL3)(nil).GetServerPortSetName), contextID)
}

// DestroyServerPortSet mocks base method
func (m *MockServerL3) DestroyServerPortSet(contextID string) error {
	ret := m.ctrl.Call(m, "DestroyServerPortSet", contextID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyServerPortSet indicates an expected call of DestroyServerPortSet
func (mr *MockServerL3MockRecorder) DestroyServerPortSet(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyServerPortSet", reflect.TypeOf((*MockServerL3)(nil).DestroyServerPortSet), contextID)
}

// AddPortToServerPortSet mocks base method
func (m *MockServerL3) AddPortToServerPortSet(contextID, port string) error {
	ret := m.ctrl.Call(m, "AddPortToServerPortSet", contextID, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddPortToServerPortSet indicates an expected call of AddPortToServerPortSet
func (mr *MockServerL3MockRecorder) AddPortToServerPortSet(contextID, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPortToServerPortSet", reflect.TypeOf((*MockServerL3)(nil).AddPortToServerPortSet), contextID, port)
}

// DeletePortFromServerPortSet mocks base method
func (m *MockServerL3) DeletePortFromServerPortSet(contextID, port string) error {
	ret := m.ctrl.Call(m, "DeletePortFromServerPortSet", contextID, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePortFromServerPortSet indicates an expected call of DeletePortFromServerPortSet
func (mr *MockServerL3MockRecorder) DeletePortFromServerPortSet(contextID, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePortFromServerPortSet", reflect.TypeOf((*MockServerL3)(nil).DeletePortFromServerPortSet), contextID, port)
}

// MockAclL3 is a mock of AclL3 interface
type MockAclL3 struct {
	ctrl     *gomock.Controller
	recorder *MockAclL3MockRecorder
}

// MockAclL3MockRecorder is the mock recorder for MockAclL3
type MockAclL3MockRecorder struct {
	mock *MockAclL3
}

// NewMockAclL3 creates a new mock instance
func NewMockAclL3(ctrl *gomock.Controller) *MockAclL3 {
	mock := &MockAclL3{ctrl: ctrl}
	mock.recorder = &MockAclL3MockRecorder{mock}
	return mock
}

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

// RegisterExternalNets mocks base method
func (m *MockAclL3) RegisterExternalNets(contextID string, extnets policy.IPRuleList) error {
	ret := m.ctrl.Call(m, "RegisterExternalNets", contextID, extnets)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterExternalNets indicates an expected call of RegisterExternalNets
func (mr *MockAclL3MockRecorder) RegisterExternalNets(contextID, extnets interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterExternalNets", reflect.TypeOf((*MockAclL3)(nil).RegisterExternalNets), contextID, extnets)
}

// UpdateACLIPsets mocks base method
func (m *MockAclL3) UpdateACLIPsets(arg0 []string, arg1 string) {
	m.ctrl.Call(m, "UpdateACLIPsets", arg0, arg1)
}

// UpdateACLIPsets indicates an expected call of UpdateACLIPsets
func (mr *MockAclL3MockRecorder) UpdateACLIPsets(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateACLIPsets", reflect.TypeOf((*MockAclL3)(nil).UpdateACLIPsets), arg0, arg1)
}

// DestroyUnusedIPsets mocks base method
func (m *MockAclL3) DestroyUnusedIPsets() {
	m.ctrl.Call(m, "DestroyUnusedIPsets")
}

// DestroyUnusedIPsets indicates an expected call of DestroyUnusedIPsets
func (mr *MockAclL3MockRecorder) DestroyUnusedIPsets() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyUnusedIPsets", reflect.TypeOf((*MockAclL3)(nil).DestroyUnusedIPsets))
}

// RemoveExternalNets mocks base method
func (m *MockAclL3) RemoveExternalNets(contextID string) {
	m.ctrl.Call(m, "RemoveExternalNets", contextID)
}

// RemoveExternalNets indicates an expected call of RemoveExternalNets
func (mr *MockAclL3MockRecorder) RemoveExternalNets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveExternalNets", reflect.TypeOf((*MockAclL3)(nil).RemoveExternalNets), contextID)
}

// GetACLIPsetsNames mocks base method
func (m *MockAclL3) GetACLIPsetsNames(extnets policy.IPRuleList) []string {
	ret := m.ctrl.Call(m, "GetACLIPsetsNames", extnets)
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetACLIPsetsNames indicates an expected call of GetACLIPsetsNames
func (mr *MockAclL3MockRecorder) GetACLIPsetsNames(extnets interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetACLIPsetsNames", reflect.TypeOf((*MockAclL3)(nil).GetACLIPsetsNames), extnets)
}

// MockProxyL4 is a mock of ProxyL4 interface
type MockProxyL4 struct {
	ctrl     *gomock.Controller
	recorder *MockProxyL4MockRecorder
}

// MockProxyL4MockRecorder is the mock recorder for MockProxyL4
type MockProxyL4MockRecorder struct {
	mock *MockProxyL4
}

// NewMockProxyL4 creates a new mock instance
func NewMockProxyL4(ctrl *gomock.Controller) *MockProxyL4 {
	mock := &MockProxyL4{ctrl: ctrl}
	mock.recorder = &MockProxyL4MockRecorder{mock}
	return mock
}

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

// CreateProxySets mocks base method
func (m *MockProxyL4) CreateProxySets(contextID string) error {
	ret := m.ctrl.Call(m, "CreateProxySets", contextID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateProxySets indicates an expected call of CreateProxySets
func (mr *MockProxyL4MockRecorder) CreateProxySets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProxySets", reflect.TypeOf((*MockProxyL4)(nil).CreateProxySets), contextID)
}

// GetProxySetNames mocks base method
func (m *MockProxyL4) GetProxySetNames(contextID string) (string, string) {
	ret := m.ctrl.Call(m, "GetProxySetNames", contextID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(string)
	return ret0, ret1
}

// GetProxySetNames indicates an expected call of GetProxySetNames
func (mr *MockProxyL4MockRecorder) GetProxySetNames(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProxySetNames", reflect.TypeOf((*MockProxyL4)(nil).GetProxySetNames), contextID)
}

// DestroyProxySets mocks base method
func (m *MockProxyL4) DestroyProxySets(contextID string) {
	m.ctrl.Call(m, "DestroyProxySets", contextID)
}

// DestroyProxySets indicates an expected call of DestroyProxySets
func (mr *MockProxyL4MockRecorder) DestroyProxySets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyProxySets", reflect.TypeOf((*MockProxyL4)(nil).DestroyProxySets), contextID)
}

// FlushProxySets mocks base method
func (m *MockProxyL4) FlushProxySets(contextID string) {
	m.ctrl.Call(m, "FlushProxySets", contextID)
}

// FlushProxySets indicates an expected call of FlushProxySets
func (mr *MockProxyL4MockRecorder) FlushProxySets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushProxySets", reflect.TypeOf((*MockProxyL4)(nil).FlushProxySets), contextID)
}

// AddIPPortToDependentService mocks base method
func (m *MockProxyL4) AddIPPortToDependentService(contextID string, ip *net.IPNet, port string) error {
	ret := m.ctrl.Call(m, "AddIPPortToDependentService", contextID, ip, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddIPPortToDependentService indicates an expected call of AddIPPortToDependentService
func (mr *MockProxyL4MockRecorder) AddIPPortToDependentService(contextID, ip, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddIPPortToDependentService", reflect.TypeOf((*MockProxyL4)(nil).AddIPPortToDependentService), contextID, ip, port)
}

// AddPortToExposedService mocks base method
func (m *MockProxyL4) AddPortToExposedService(contextID, port string) error {
	ret := m.ctrl.Call(m, "AddPortToExposedService", contextID, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddPortToExposedService indicates an expected call of AddPortToExposedService
func (mr *MockProxyL4MockRecorder) AddPortToExposedService(contextID, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPortToExposedService", reflect.TypeOf((*MockProxyL4)(nil).AddPortToExposedService), contextID, port)
}

// MockIPSetManager is a mock of IPSetManager interface
type MockIPSetManager struct {
	ctrl     *gomock.Controller
	recorder *MockIPSetManagerMockRecorder
}

// MockIPSetManagerMockRecorder is the mock recorder for MockIPSetManager
type MockIPSetManagerMockRecorder struct {
	mock *MockIPSetManager
}

// NewMockIPSetManager creates a new mock instance
func NewMockIPSetManager(ctrl *gomock.Controller) *MockIPSetManager {
	mock := &MockIPSetManager{ctrl: ctrl}
	mock.recorder = &MockIPSetManagerMockRecorder{mock}
	return mock
}

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

// CreateServerPortSet mocks base method
func (m *MockIPSetManager) CreateServerPortSet(contextID string) error {
	ret := m.ctrl.Call(m, "CreateServerPortSet", contextID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateServerPortSet indicates an expected call of CreateServerPortSet
func (mr *MockIPSetManagerMockRecorder) CreateServerPortSet(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServerPortSet", reflect.TypeOf((*MockIPSetManager)(nil).CreateServerPortSet), contextID)
}

// GetServerPortSetName mocks base method
func (m *MockIPSetManager) GetServerPortSetName(contextID string) string {
	ret := m.ctrl.Call(m, "GetServerPortSetName", contextID)
	ret0, _ := ret[0].(string)
	return ret0
}

// GetServerPortSetName indicates an expected call of GetServerPortSetName
func (mr *MockIPSetManagerMockRecorder) GetServerPortSetName(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerPortSetName", reflect.TypeOf((*MockIPSetManager)(nil).GetServerPortSetName), contextID)
}

// DestroyServerPortSet mocks base method
func (m *MockIPSetManager) DestroyServerPortSet(contextID string) error {
	ret := m.ctrl.Call(m, "DestroyServerPortSet", contextID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyServerPortSet indicates an expected call of DestroyServerPortSet
func (mr *MockIPSetManagerMockRecorder) DestroyServerPortSet(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyServerPortSet", reflect.TypeOf((*MockIPSetManager)(nil).DestroyServerPortSet), contextID)
}

// AddPortToServerPortSet mocks base method
func (m *MockIPSetManager) AddPortToServerPortSet(contextID, port string) error {
	ret := m.ctrl.Call(m, "AddPortToServerPortSet", contextID, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddPortToServerPortSet indicates an expected call of AddPortToServerPortSet
func (mr *MockIPSetManagerMockRecorder) AddPortToServerPortSet(contextID, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPortToServerPortSet", reflect.TypeOf((*MockIPSetManager)(nil).AddPortToServerPortSet), contextID, port)
}

// DeletePortFromServerPortSet mocks base method
func (m *MockIPSetManager) DeletePortFromServerPortSet(contextID, port string) error {
	ret := m.ctrl.Call(m, "DeletePortFromServerPortSet", contextID, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePortFromServerPortSet indicates an expected call of DeletePortFromServerPortSet
func (mr *MockIPSetManagerMockRecorder) DeletePortFromServerPortSet(contextID, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePortFromServerPortSet", reflect.TypeOf((*MockIPSetManager)(nil).DeletePortFromServerPortSet), contextID, port)
}

// RegisterExternalNets mocks base method
func (m *MockIPSetManager) RegisterExternalNets(contextID string, extnets policy.IPRuleList) error {
	ret := m.ctrl.Call(m, "RegisterExternalNets", contextID, extnets)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterExternalNets indicates an expected call of RegisterExternalNets
func (mr *MockIPSetManagerMockRecorder) RegisterExternalNets(contextID, extnets interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterExternalNets", reflect.TypeOf((*MockIPSetManager)(nil).RegisterExternalNets), contextID, extnets)
}

// UpdateACLIPsets mocks base method
func (m *MockIPSetManager) UpdateACLIPsets(arg0 []string, arg1 string) {
	m.ctrl.Call(m, "UpdateACLIPsets", arg0, arg1)
}

// UpdateACLIPsets indicates an expected call of UpdateACLIPsets
func (mr *MockIPSetManagerMockRecorder) UpdateACLIPsets(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateACLIPsets", reflect.TypeOf((*MockIPSetManager)(nil).UpdateACLIPsets), arg0, arg1)
}

// DestroyUnusedIPsets mocks base method
func (m *MockIPSetManager) DestroyUnusedIPsets() {
	m.ctrl.Call(m, "DestroyUnusedIPsets")
}

// DestroyUnusedIPsets indicates an expected call of DestroyUnusedIPsets
func (mr *MockIPSetManagerMockRecorder) DestroyUnusedIPsets() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyUnusedIPsets", reflect.TypeOf((*MockIPSetManager)(nil).DestroyUnusedIPsets))
}

// RemoveExternalNets mocks base method
func (m *MockIPSetManager) RemoveExternalNets(contextID string) {
	m.ctrl.Call(m, "RemoveExternalNets", contextID)
}

// RemoveExternalNets indicates an expected call of RemoveExternalNets
func (mr *MockIPSetManagerMockRecorder) RemoveExternalNets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveExternalNets", reflect.TypeOf((*MockIPSetManager)(nil).RemoveExternalNets), contextID)
}

// GetACLIPsetsNames mocks base method
func (m *MockIPSetManager) GetACLIPsetsNames(extnets policy.IPRuleList) []string {
	ret := m.ctrl.Call(m, "GetACLIPsetsNames", extnets)
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetACLIPsetsNames indicates an expected call of GetACLIPsetsNames
func (mr *MockIPSetManagerMockRecorder) GetACLIPsetsNames(extnets interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetACLIPsetsNames", reflect.TypeOf((*MockIPSetManager)(nil).GetACLIPsetsNames), extnets)
}

// CreateProxySets mocks base method
func (m *MockIPSetManager) CreateProxySets(contextID string) error {
	ret := m.ctrl.Call(m, "CreateProxySets", contextID)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateProxySets indicates an expected call of CreateProxySets
func (mr *MockIPSetManagerMockRecorder) CreateProxySets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProxySets", reflect.TypeOf((*MockIPSetManager)(nil).CreateProxySets), contextID)
}

// GetProxySetNames mocks base method
func (m *MockIPSetManager) GetProxySetNames(contextID string) (string, string) {
	ret := m.ctrl.Call(m, "GetProxySetNames", contextID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(string)
	return ret0, ret1
}

// GetProxySetNames indicates an expected call of GetProxySetNames
func (mr *MockIPSetManagerMockRecorder) GetProxySetNames(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProxySetNames", reflect.TypeOf((*MockIPSetManager)(nil).GetProxySetNames), contextID)
}

// DestroyProxySets mocks base method
func (m *MockIPSetManager) DestroyProxySets(contextID string) {
	m.ctrl.Call(m, "DestroyProxySets", contextID)
}

// DestroyProxySets indicates an expected call of DestroyProxySets
func (mr *MockIPSetManagerMockRecorder) DestroyProxySets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyProxySets", reflect.TypeOf((*MockIPSetManager)(nil).DestroyProxySets), contextID)
}

// FlushProxySets mocks base method
func (m *MockIPSetManager) FlushProxySets(contextID string) {
	m.ctrl.Call(m, "FlushProxySets", contextID)
}

// FlushProxySets indicates an expected call of FlushProxySets
func (mr *MockIPSetManagerMockRecorder) FlushProxySets(contextID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushProxySets", reflect.TypeOf((*MockIPSetManager)(nil).FlushProxySets), contextID)
}

// AddIPPortToDependentService mocks base method
func (m *MockIPSetManager) AddIPPortToDependentService(contextID string, ip *net.IPNet, port string) error {
	ret := m.ctrl.Call(m, "AddIPPortToDependentService", contextID, ip, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddIPPortToDependentService indicates an expected call of AddIPPortToDependentService
func (mr *MockIPSetManagerMockRecorder) AddIPPortToDependentService(contextID, ip, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddIPPortToDependentService", reflect.TypeOf((*MockIPSetManager)(nil).AddIPPortToDependentService), contextID, ip, port)
}

// AddPortToExposedService mocks base method
func (m *MockIPSetManager) AddPortToExposedService(contextID, port string) error {
	ret := m.ctrl.Call(m, "AddPortToExposedService", contextID, port)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddPortToExposedService indicates an expected call of AddPortToExposedService
func (mr *MockIPSetManagerMockRecorder) AddPortToExposedService(contextID, port interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPortToExposedService", reflect.TypeOf((*MockIPSetManager)(nil).AddPortToExposedService), contextID, port)
}