cloudstack/WebhookService_mock.go

//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//

// Code generated by MockGen. DO NOT EDIT.
// Source: ./cloudstack/WebhookService.go
//
// Generated by this command:
//
//	mockgen -destination=./cloudstack/WebhookService_mock.go -package=cloudstack -copyright_file=header.txt -source=./cloudstack/WebhookService.go
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockWebhookServiceIface is a mock of WebhookServiceIface interface.
type MockWebhookServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockWebhookServiceIfaceMockRecorder
	isgomock struct{}
}

// MockWebhookServiceIfaceMockRecorder is the mock recorder for MockWebhookServiceIface.
type MockWebhookServiceIfaceMockRecorder struct {
	mock *MockWebhookServiceIface
}

// NewMockWebhookServiceIface creates a new mock instance.
func NewMockWebhookServiceIface(ctrl *gomock.Controller) *MockWebhookServiceIface {
	mock := &MockWebhookServiceIface{ctrl: ctrl}
	mock.recorder = &MockWebhookServiceIfaceMockRecorder{mock}
	return mock
}

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

// CreateWebhook mocks base method.
func (m *MockWebhookServiceIface) CreateWebhook(p *CreateWebhookParams) (*CreateWebhookResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWebhook", p)
	ret0, _ := ret[0].(*CreateWebhookResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWebhook indicates an expected call of CreateWebhook.
func (mr *MockWebhookServiceIfaceMockRecorder) CreateWebhook(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWebhook", reflect.TypeOf((*MockWebhookServiceIface)(nil).CreateWebhook), p)
}

// DeleteWebhook mocks base method.
func (m *MockWebhookServiceIface) DeleteWebhook(p *DeleteWebhookParams) (*DeleteWebhookResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWebhook", p)
	ret0, _ := ret[0].(*DeleteWebhookResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteWebhook indicates an expected call of DeleteWebhook.
func (mr *MockWebhookServiceIfaceMockRecorder) DeleteWebhook(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWebhook", reflect.TypeOf((*MockWebhookServiceIface)(nil).DeleteWebhook), p)
}

// DeleteWebhookDelivery mocks base method.
func (m *MockWebhookServiceIface) DeleteWebhookDelivery(p *DeleteWebhookDeliveryParams) (*DeleteWebhookDeliveryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWebhookDelivery", p)
	ret0, _ := ret[0].(*DeleteWebhookDeliveryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteWebhookDelivery indicates an expected call of DeleteWebhookDelivery.
func (mr *MockWebhookServiceIfaceMockRecorder) DeleteWebhookDelivery(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWebhookDelivery", reflect.TypeOf((*MockWebhookServiceIface)(nil).DeleteWebhookDelivery), p)
}

// ExecuteWebhookDelivery mocks base method.
func (m *MockWebhookServiceIface) ExecuteWebhookDelivery(p *ExecuteWebhookDeliveryParams) (*ExecuteWebhookDeliveryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteWebhookDelivery", p)
	ret0, _ := ret[0].(*ExecuteWebhookDeliveryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteWebhookDelivery indicates an expected call of ExecuteWebhookDelivery.
func (mr *MockWebhookServiceIfaceMockRecorder) ExecuteWebhookDelivery(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteWebhookDelivery", reflect.TypeOf((*MockWebhookServiceIface)(nil).ExecuteWebhookDelivery), p)
}

// GetWebhookByID mocks base method.
func (m *MockWebhookServiceIface) GetWebhookByID(id string, opts ...OptionFunc) (*Webhook, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWebhookByID", varargs...)
	ret0, _ := ret[0].(*Webhook)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetWebhookByID indicates an expected call of GetWebhookByID.
func (mr *MockWebhookServiceIfaceMockRecorder) GetWebhookByID(id any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebhookByID", reflect.TypeOf((*MockWebhookServiceIface)(nil).GetWebhookByID), varargs...)
}

// GetWebhookByName mocks base method.
func (m *MockWebhookServiceIface) GetWebhookByName(name string, opts ...OptionFunc) (*Webhook, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWebhookByName", varargs...)
	ret0, _ := ret[0].(*Webhook)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetWebhookByName indicates an expected call of GetWebhookByName.
func (mr *MockWebhookServiceIfaceMockRecorder) GetWebhookByName(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebhookByName", reflect.TypeOf((*MockWebhookServiceIface)(nil).GetWebhookByName), varargs...)
}

// GetWebhookDeliveryByID mocks base method.
func (m *MockWebhookServiceIface) GetWebhookDeliveryByID(id string, opts ...OptionFunc) (*WebhookDelivery, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWebhookDeliveryByID", varargs...)
	ret0, _ := ret[0].(*WebhookDelivery)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetWebhookDeliveryByID indicates an expected call of GetWebhookDeliveryByID.
func (mr *MockWebhookServiceIfaceMockRecorder) GetWebhookDeliveryByID(id any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebhookDeliveryByID", reflect.TypeOf((*MockWebhookServiceIface)(nil).GetWebhookDeliveryByID), varargs...)
}

// GetWebhookDeliveryByName mocks base method.
func (m *MockWebhookServiceIface) GetWebhookDeliveryByName(name string, opts ...OptionFunc) (*WebhookDelivery, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWebhookDeliveryByName", varargs...)
	ret0, _ := ret[0].(*WebhookDelivery)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetWebhookDeliveryByName indicates an expected call of GetWebhookDeliveryByName.
func (mr *MockWebhookServiceIfaceMockRecorder) GetWebhookDeliveryByName(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebhookDeliveryByName", reflect.TypeOf((*MockWebhookServiceIface)(nil).GetWebhookDeliveryByName), varargs...)
}

// GetWebhookDeliveryID mocks base method.
func (m *MockWebhookServiceIface) GetWebhookDeliveryID(keyword string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{keyword}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWebhookDeliveryID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetWebhookDeliveryID indicates an expected call of GetWebhookDeliveryID.
func (mr *MockWebhookServiceIfaceMockRecorder) GetWebhookDeliveryID(keyword any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{keyword}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebhookDeliveryID", reflect.TypeOf((*MockWebhookServiceIface)(nil).GetWebhookDeliveryID), varargs...)
}

// GetWebhookID mocks base method.
func (m *MockWebhookServiceIface) GetWebhookID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWebhookID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetWebhookID indicates an expected call of GetWebhookID.
func (mr *MockWebhookServiceIfaceMockRecorder) GetWebhookID(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebhookID", reflect.TypeOf((*MockWebhookServiceIface)(nil).GetWebhookID), varargs...)
}

// ListWebhookDeliveries mocks base method.
func (m *MockWebhookServiceIface) ListWebhookDeliveries(p *ListWebhookDeliveriesParams) (*ListWebhookDeliveriesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWebhookDeliveries", p)
	ret0, _ := ret[0].(*ListWebhookDeliveriesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWebhookDeliveries indicates an expected call of ListWebhookDeliveries.
func (mr *MockWebhookServiceIfaceMockRecorder) ListWebhookDeliveries(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWebhookDeliveries", reflect.TypeOf((*MockWebhookServiceIface)(nil).ListWebhookDeliveries), p)
}

// ListWebhooks mocks base method.
func (m *MockWebhookServiceIface) ListWebhooks(p *ListWebhooksParams) (*ListWebhooksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWebhooks", p)
	ret0, _ := ret[0].(*ListWebhooksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWebhooks indicates an expected call of ListWebhooks.
func (mr *MockWebhookServiceIfaceMockRecorder) ListWebhooks(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWebhooks", reflect.TypeOf((*MockWebhookServiceIface)(nil).ListWebhooks), p)
}

// NewCreateWebhookParams mocks base method.
func (m *MockWebhookServiceIface) NewCreateWebhookParams(name, payloadurl string) *CreateWebhookParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateWebhookParams", name, payloadurl)
	ret0, _ := ret[0].(*CreateWebhookParams)
	return ret0
}

// NewCreateWebhookParams indicates an expected call of NewCreateWebhookParams.
func (mr *MockWebhookServiceIfaceMockRecorder) NewCreateWebhookParams(name, payloadurl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateWebhookParams", reflect.TypeOf((*MockWebhookServiceIface)(nil).NewCreateWebhookParams), name, payloadurl)
}

// NewDeleteWebhookDeliveryParams mocks base method.
func (m *MockWebhookServiceIface) NewDeleteWebhookDeliveryParams() *DeleteWebhookDeliveryParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteWebhookDeliveryParams")
	ret0, _ := ret[0].(*DeleteWebhookDeliveryParams)
	return ret0
}

// NewDeleteWebhookDeliveryParams indicates an expected call of NewDeleteWebhookDeliveryParams.
func (mr *MockWebhookServiceIfaceMockRecorder) NewDeleteWebhookDeliveryParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteWebhookDeliveryParams", reflect.TypeOf((*MockWebhookServiceIface)(nil).NewDeleteWebhookDeliveryParams))
}

// NewDeleteWebhookParams mocks base method.
func (m *MockWebhookServiceIface) NewDeleteWebhookParams(id string) *DeleteWebhookParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteWebhookParams", id)
	ret0, _ := ret[0].(*DeleteWebhookParams)
	return ret0
}

// NewDeleteWebhookParams indicates an expected call of NewDeleteWebhookParams.
func (mr *MockWebhookServiceIfaceMockRecorder) NewDeleteWebhookParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteWebhookParams", reflect.TypeOf((*MockWebhookServiceIface)(nil).NewDeleteWebhookParams), id)
}

// NewExecuteWebhookDeliveryParams mocks base method.
func (m *MockWebhookServiceIface) NewExecuteWebhookDeliveryParams() *ExecuteWebhookDeliveryParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewExecuteWebhookDeliveryParams")
	ret0, _ := ret[0].(*ExecuteWebhookDeliveryParams)
	return ret0
}

// NewExecuteWebhookDeliveryParams indicates an expected call of NewExecuteWebhookDeliveryParams.
func (mr *MockWebhookServiceIfaceMockRecorder) NewExecuteWebhookDeliveryParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewExecuteWebhookDeliveryParams", reflect.TypeOf((*MockWebhookServiceIface)(nil).NewExecuteWebhookDeliveryParams))
}

// NewListWebhookDeliveriesParams mocks base method.
func (m *MockWebhookServiceIface) NewListWebhookDeliveriesParams() *ListWebhookDeliveriesParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListWebhookDeliveriesParams")
	ret0, _ := ret[0].(*ListWebhookDeliveriesParams)
	return ret0
}

// NewListWebhookDeliveriesParams indicates an expected call of NewListWebhookDeliveriesParams.
func (mr *MockWebhookServiceIfaceMockRecorder) NewListWebhookDeliveriesParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListWebhookDeliveriesParams", reflect.TypeOf((*MockWebhookServiceIface)(nil).NewListWebhookDeliveriesParams))
}

// NewListWebhooksParams mocks base method.
func (m *MockWebhookServiceIface) NewListWebhooksParams() *ListWebhooksParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListWebhooksParams")
	ret0, _ := ret[0].(*ListWebhooksParams)
	return ret0
}

// NewListWebhooksParams indicates an expected call of NewListWebhooksParams.
func (mr *MockWebhookServiceIfaceMockRecorder) NewListWebhooksParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListWebhooksParams", reflect.TypeOf((*MockWebhookServiceIface)(nil).NewListWebhooksParams))
}

// NewUpdateWebhookParams mocks base method.
func (m *MockWebhookServiceIface) NewUpdateWebhookParams(id string) *UpdateWebhookParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateWebhookParams", id)
	ret0, _ := ret[0].(*UpdateWebhookParams)
	return ret0
}

// NewUpdateWebhookParams indicates an expected call of NewUpdateWebhookParams.
func (mr *MockWebhookServiceIfaceMockRecorder) NewUpdateWebhookParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateWebhookParams", reflect.TypeOf((*MockWebhookServiceIface)(nil).NewUpdateWebhookParams), id)
}

// UpdateWebhook mocks base method.
func (m *MockWebhookServiceIface) UpdateWebhook(p *UpdateWebhookParams) (*UpdateWebhookResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWebhook", p)
	ret0, _ := ret[0].(*UpdateWebhookResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWebhook indicates an expected call of UpdateWebhook.
func (mr *MockWebhookServiceIfaceMockRecorder) UpdateWebhook(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWebhook", reflect.TypeOf((*MockWebhookServiceIface)(nil).UpdateWebhook), p)
}