github.com/goravel/framework@v1.13.9/contracts/route/mocks/Route.go

// Code generated by mockery v2.33.1. DO NOT EDIT.

package mocks

import (
	http "github.com/goravel/framework/contracts/http"
	mock "github.com/stretchr/testify/mock"

	nethttp "net/http"

	route "github.com/goravel/framework/contracts/route"
)

// Route is an autogenerated mock type for the Route type
type Route struct {
	mock.Mock
}

// Any provides a mock function with given fields: relativePath, handler
func (_m *Route) Any(relativePath string, handler http.HandlerFunc) {
	_m.Called(relativePath, handler)
}

// Delete provides a mock function with given fields: relativePath, handler
func (_m *Route) Delete(relativePath string, handler http.HandlerFunc) {
	_m.Called(relativePath, handler)
}

// Fallback provides a mock function with given fields: handler
func (_m *Route) Fallback(handler http.HandlerFunc) {
	_m.Called(handler)
}

// Get provides a mock function with given fields: relativePath, handler
func (_m *Route) Get(relativePath string, handler http.HandlerFunc) {
	_m.Called(relativePath, handler)
}

// GlobalMiddleware provides a mock function with given fields: middlewares
func (_m *Route) GlobalMiddleware(middlewares ...http.Middleware) {
	_va := make([]interface{}, len(middlewares))
	for _i := range middlewares {
		_va[_i] = middlewares[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	_m.Called(_ca...)
}

// Group provides a mock function with given fields: handler
func (_m *Route) Group(handler route.GroupFunc) {
	_m.Called(handler)
}

// Middleware provides a mock function with given fields: middlewares
func (_m *Route) Middleware(middlewares ...http.Middleware) route.Router {
	_va := make([]interface{}, len(middlewares))
	for _i := range middlewares {
		_va[_i] = middlewares[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 route.Router
	if rf, ok := ret.Get(0).(func(...http.Middleware) route.Router); ok {
		r0 = rf(middlewares...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(route.Router)
		}
	}

	return r0
}

// Options provides a mock function with given fields: relativePath, handler
func (_m *Route) Options(relativePath string, handler http.HandlerFunc) {
	_m.Called(relativePath, handler)
}

// Patch provides a mock function with given fields: relativePath, handler
func (_m *Route) Patch(relativePath string, handler http.HandlerFunc) {
	_m.Called(relativePath, handler)
}

// Post provides a mock function with given fields: relativePath, handler
func (_m *Route) Post(relativePath string, handler http.HandlerFunc) {
	_m.Called(relativePath, handler)
}

// Prefix provides a mock function with given fields: addr
func (_m *Route) Prefix(addr string) route.Router {
	ret := _m.Called(addr)

	var r0 route.Router
	if rf, ok := ret.Get(0).(func(string) route.Router); ok {
		r0 = rf(addr)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(route.Router)
		}
	}

	return r0
}

// Put provides a mock function with given fields: relativePath, handler
func (_m *Route) Put(relativePath string, handler http.HandlerFunc) {
	_m.Called(relativePath, handler)
}

// Resource provides a mock function with given fields: relativePath, controller
func (_m *Route) Resource(relativePath string, controller http.ResourceController) {
	_m.Called(relativePath, controller)
}

// Run provides a mock function with given fields: host
func (_m *Route) Run(host ...string) error {
	_va := make([]interface{}, len(host))
	for _i := range host {
		_va[_i] = host[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(...string) error); ok {
		r0 = rf(host...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// RunTLS provides a mock function with given fields: host
func (_m *Route) RunTLS(host ...string) error {
	_va := make([]interface{}, len(host))
	for _i := range host {
		_va[_i] = host[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(...string) error); ok {
		r0 = rf(host...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// RunTLSWithCert provides a mock function with given fields: host, certFile, keyFile
func (_m *Route) RunTLSWithCert(host string, certFile string, keyFile string) error {
	ret := _m.Called(host, certFile, keyFile)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string, string) error); ok {
		r0 = rf(host, certFile, keyFile)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ServeHTTP provides a mock function with given fields: writer, request
func (_m *Route) ServeHTTP(writer nethttp.ResponseWriter, request *nethttp.Request) {
	_m.Called(writer, request)
}

// Static provides a mock function with given fields: relativePath, root
func (_m *Route) Static(relativePath string, root string) {
	_m.Called(relativePath, root)
}

// StaticFS provides a mock function with given fields: relativePath, fs
func (_m *Route) StaticFS(relativePath string, fs nethttp.FileSystem) {
	_m.Called(relativePath, fs)
}

// StaticFile provides a mock function with given fields: relativePath, filepath
func (_m *Route) StaticFile(relativePath string, filepath string) {
	_m.Called(relativePath, filepath)
}

// NewRoute creates a new instance of Route. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewRoute(t interface {
	mock.TestingT
	Cleanup(func())
}) *Route {
	mock := &Route{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}