hetty/pkg/sender/reqlog_mock_test.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package sender_test

import (
	"context"
	"github.com/dstotijn/hetty/pkg/proxy"
	"github.com/dstotijn/hetty/pkg/reqlog"
	"github.com/oklog/ulid"
	"sync"
)

// Ensure, that ReqLogServiceMock does implement reqlog.Service.
// If this is not the case, regenerate this file with moq.
var _ reqlog.Service = &ReqLogServiceMock{}

// ReqLogServiceMock is a mock implementation of reqlog.Service.
//
// 	func TestSomethingThatUsesService(t *testing.T) {
//
// 		// make and configure a mocked reqlog.Service
// 		mockedService := &ReqLogServiceMock{
// 			ActiveProjectIDFunc: func() ulid.ULID {
// 				panic("mock out the ActiveProjectID method")
// 			},
// 			BypassOutOfScopeRequestsFunc: func() bool {
// 				panic("mock out the BypassOutOfScopeRequests method")
// 			},
// 			ClearRequestsFunc: func(ctx context.Context, projectID ulid.ULID) error {
// 				panic("mock out the ClearRequests method")
// 			},
// 			FindReqsFilterFunc: func() reqlog.FindRequestsFilter {
// 				panic("mock out the FindReqsFilter method")
// 			},
// 			FindRequestLogByIDFunc: func(ctx context.Context, id ulid.ULID) (reqlog.RequestLog, error) {
// 				panic("mock out the FindRequestLogByID method")
// 			},
// 			FindRequestsFunc: func(ctx context.Context) ([]reqlog.RequestLog, error) {
// 				panic("mock out the FindRequests method")
// 			},
// 			RequestModifierFunc: func(next proxy.RequestModifyFunc) proxy.RequestModifyFunc {
// 				panic("mock out the RequestModifier method")
// 			},
// 			ResponseModifierFunc: func(next proxy.ResponseModifyFunc) proxy.ResponseModifyFunc {
// 				panic("mock out the ResponseModifier method")
// 			},
// 			SetActiveProjectIDFunc: func(id ulid.ULID)  {
// 				panic("mock out the SetActiveProjectID method")
// 			},
// 			SetBypassOutOfScopeRequestsFunc: func(b bool)  {
// 				panic("mock out the SetBypassOutOfScopeRequests method")
// 			},
// 			SetFindReqsFilterFunc: func(filter reqlog.FindRequestsFilter)  {
// 				panic("mock out the SetFindReqsFilter method")
// 			},
// 		}
//
// 		// use mockedService in code that requires reqlog.Service
// 		// and then make assertions.
//
// 	}
type ReqLogServiceMock struct {
	// ActiveProjectIDFunc mocks the ActiveProjectID method.
	ActiveProjectIDFunc func() ulid.ULID

	// BypassOutOfScopeRequestsFunc mocks the BypassOutOfScopeRequests method.
	BypassOutOfScopeRequestsFunc func() bool

	// ClearRequestsFunc mocks the ClearRequests method.
	ClearRequestsFunc func(ctx context.Context, projectID ulid.ULID) error

	// FindReqsFilterFunc mocks the FindReqsFilter method.
	FindReqsFilterFunc func() reqlog.FindRequestsFilter

	// FindRequestLogByIDFunc mocks the FindRequestLogByID method.
	FindRequestLogByIDFunc func(ctx context.Context, id ulid.ULID) (reqlog.RequestLog, error)

	// FindRequestsFunc mocks the FindRequests method.
	FindRequestsFunc func(ctx context.Context) ([]reqlog.RequestLog, error)

	// RequestModifierFunc mocks the RequestModifier method.
	RequestModifierFunc func(next proxy.RequestModifyFunc) proxy.RequestModifyFunc

	// ResponseModifierFunc mocks the ResponseModifier method.
	ResponseModifierFunc func(next proxy.ResponseModifyFunc) proxy.ResponseModifyFunc

	// SetActiveProjectIDFunc mocks the SetActiveProjectID method.
	SetActiveProjectIDFunc func(id ulid.ULID)

	// SetBypassOutOfScopeRequestsFunc mocks the SetBypassOutOfScopeRequests method.
	SetBypassOutOfScopeRequestsFunc func(b bool)

	// SetFindReqsFilterFunc mocks the SetFindReqsFilter method.
	SetFindReqsFilterFunc func(filter reqlog.FindRequestsFilter)

	// calls tracks calls to the methods.
	calls struct {
		// ActiveProjectID holds details about calls to the ActiveProjectID method.
		ActiveProjectID []struct {
		}
		// BypassOutOfScopeRequests holds details about calls to the BypassOutOfScopeRequests method.
		BypassOutOfScopeRequests []struct {
		}
		// ClearRequests holds details about calls to the ClearRequests method.
		ClearRequests []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// ProjectID is the projectID argument value.
			ProjectID ulid.ULID
		}
		// FindReqsFilter holds details about calls to the FindReqsFilter method.
		FindReqsFilter []struct {
		}
		// FindRequestLogByID holds details about calls to the FindRequestLogByID method.
		FindRequestLogByID []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// ID is the id argument value.
			ID ulid.ULID
		}
		// FindRequests holds details about calls to the FindRequests method.
		FindRequests []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
		}
		// RequestModifier holds details about calls to the RequestModifier method.
		RequestModifier []struct {
			// Next is the next argument value.
			Next proxy.RequestModifyFunc
		}
		// ResponseModifier holds details about calls to the ResponseModifier method.
		ResponseModifier []struct {
			// Next is the next argument value.
			Next proxy.ResponseModifyFunc
		}
		// SetActiveProjectID holds details about calls to the SetActiveProjectID method.
		SetActiveProjectID []struct {
			// ID is the id argument value.
			ID ulid.ULID
		}
		// SetBypassOutOfScopeRequests holds details about calls to the SetBypassOutOfScopeRequests method.
		SetBypassOutOfScopeRequests []struct {
			// B is the b argument value.
			B bool
		}
		// SetFindReqsFilter holds details about calls to the SetFindReqsFilter method.
		SetFindReqsFilter []struct {
			// Filter is the filter argument value.
			Filter reqlog.FindRequestsFilter
		}
	}
	lockActiveProjectID             sync.RWMutex
	lockBypassOutOfScopeRequests    sync.RWMutex
	lockClearRequests               sync.RWMutex
	lockFindReqsFilter              sync.RWMutex
	lockFindRequestLogByID          sync.RWMutex
	lockFindRequests                sync.RWMutex
	lockRequestModifier             sync.RWMutex
	lockResponseModifier            sync.RWMutex
	lockSetActiveProjectID          sync.RWMutex
	lockSetBypassOutOfScopeRequests sync.RWMutex
	lockSetFindReqsFilter           sync.RWMutex
}

// ActiveProjectID calls ActiveProjectIDFunc.
func (mock *ReqLogServiceMock) ActiveProjectID() ulid.ULID {
	if mock.ActiveProjectIDFunc == nil {
		panic("ReqLogServiceMock.ActiveProjectIDFunc: method is nil but Service.ActiveProjectID was just called")
	}
	callInfo := struct {
	}{}
	mock.lockActiveProjectID.Lock()
	mock.calls.ActiveProjectID = append(mock.calls.ActiveProjectID, callInfo)
	mock.lockActiveProjectID.Unlock()
	return mock.ActiveProjectIDFunc()
}

// ActiveProjectIDCalls gets all the calls that were made to ActiveProjectID.
// Check the length with:
//     len(mockedService.ActiveProjectIDCalls())
func (mock *ReqLogServiceMock) ActiveProjectIDCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockActiveProjectID.RLock()
	calls = mock.calls.ActiveProjectID
	mock.lockActiveProjectID.RUnlock()
	return calls
}

// BypassOutOfScopeRequests calls BypassOutOfScopeRequestsFunc.
func (mock *ReqLogServiceMock) BypassOutOfScopeRequests() bool {
	if mock.BypassOutOfScopeRequestsFunc == nil {
		panic("ReqLogServiceMock.BypassOutOfScopeRequestsFunc: method is nil but Service.BypassOutOfScopeRequests was just called")
	}
	callInfo := struct {
	}{}
	mock.lockBypassOutOfScopeRequests.Lock()
	mock.calls.BypassOutOfScopeRequests = append(mock.calls.BypassOutOfScopeRequests, callInfo)
	mock.lockBypassOutOfScopeRequests.Unlock()
	return mock.BypassOutOfScopeRequestsFunc()
}

// BypassOutOfScopeRequestsCalls gets all the calls that were made to BypassOutOfScopeRequests.
// Check the length with:
//     len(mockedService.BypassOutOfScopeRequestsCalls())
func (mock *ReqLogServiceMock) BypassOutOfScopeRequestsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockBypassOutOfScopeRequests.RLock()
	calls = mock.calls.BypassOutOfScopeRequests
	mock.lockBypassOutOfScopeRequests.RUnlock()
	return calls
}

// ClearRequests calls ClearRequestsFunc.
func (mock *ReqLogServiceMock) ClearRequests(ctx context.Context, projectID ulid.ULID) error {
	if mock.ClearRequestsFunc == nil {
		panic("ReqLogServiceMock.ClearRequestsFunc: method is nil but Service.ClearRequests was just called")
	}
	callInfo := struct {
		Ctx       context.Context
		ProjectID ulid.ULID
	}{
		Ctx:       ctx,
		ProjectID: projectID,
	}
	mock.lockClearRequests.Lock()
	mock.calls.ClearRequests = append(mock.calls.ClearRequests, callInfo)
	mock.lockClearRequests.Unlock()
	return mock.ClearRequestsFunc(ctx, projectID)
}

// ClearRequestsCalls gets all the calls that were made to ClearRequests.
// Check the length with:
//     len(mockedService.ClearRequestsCalls())
func (mock *ReqLogServiceMock) ClearRequestsCalls() []struct {
	Ctx       context.Context
	ProjectID ulid.ULID
} {
	var calls []struct {
		Ctx       context.Context
		ProjectID ulid.ULID
	}
	mock.lockClearRequests.RLock()
	calls = mock.calls.ClearRequests
	mock.lockClearRequests.RUnlock()
	return calls
}

// FindReqsFilter calls FindReqsFilterFunc.
func (mock *ReqLogServiceMock) FindReqsFilter() reqlog.FindRequestsFilter {
	if mock.FindReqsFilterFunc == nil {
		panic("ReqLogServiceMock.FindReqsFilterFunc: method is nil but Service.FindReqsFilter was just called")
	}
	callInfo := struct {
	}{}
	mock.lockFindReqsFilter.Lock()
	mock.calls.FindReqsFilter = append(mock.calls.FindReqsFilter, callInfo)
	mock.lockFindReqsFilter.Unlock()
	return mock.FindReqsFilterFunc()
}

// FindReqsFilterCalls gets all the calls that were made to FindReqsFilter.
// Check the length with:
//     len(mockedService.FindReqsFilterCalls())
func (mock *ReqLogServiceMock) FindReqsFilterCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockFindReqsFilter.RLock()
	calls = mock.calls.FindReqsFilter
	mock.lockFindReqsFilter.RUnlock()
	return calls
}

// FindRequestLogByID calls FindRequestLogByIDFunc.
func (mock *ReqLogServiceMock) FindRequestLogByID(ctx context.Context, id ulid.ULID) (reqlog.RequestLog, error) {
	if mock.FindRequestLogByIDFunc == nil {
		panic("ReqLogServiceMock.FindRequestLogByIDFunc: method is nil but Service.FindRequestLogByID was just called")
	}
	callInfo := struct {
		Ctx context.Context
		ID  ulid.ULID
	}{
		Ctx: ctx,
		ID:  id,
	}
	mock.lockFindRequestLogByID.Lock()
	mock.calls.FindRequestLogByID = append(mock.calls.FindRequestLogByID, callInfo)
	mock.lockFindRequestLogByID.Unlock()
	return mock.FindRequestLogByIDFunc(ctx, id)
}

// FindRequestLogByIDCalls gets all the calls that were made to FindRequestLogByID.
// Check the length with:
//     len(mockedService.FindRequestLogByIDCalls())
func (mock *ReqLogServiceMock) FindRequestLogByIDCalls() []struct {
	Ctx context.Context
	ID  ulid.ULID
} {
	var calls []struct {
		Ctx context.Context
		ID  ulid.ULID
	}
	mock.lockFindRequestLogByID.RLock()
	calls = mock.calls.FindRequestLogByID
	mock.lockFindRequestLogByID.RUnlock()
	return calls
}

// FindRequests calls FindRequestsFunc.
func (mock *ReqLogServiceMock) FindRequests(ctx context.Context) ([]reqlog.RequestLog, error) {
	if mock.FindRequestsFunc == nil {
		panic("ReqLogServiceMock.FindRequestsFunc: method is nil but Service.FindRequests was just called")
	}
	callInfo := struct {
		Ctx context.Context
	}{
		Ctx: ctx,
	}
	mock.lockFindRequests.Lock()
	mock.calls.FindRequests = append(mock.calls.FindRequests, callInfo)
	mock.lockFindRequests.Unlock()
	return mock.FindRequestsFunc(ctx)
}

// FindRequestsCalls gets all the calls that were made to FindRequests.
// Check the length with:
//     len(mockedService.FindRequestsCalls())
func (mock *ReqLogServiceMock) FindRequestsCalls() []struct {
	Ctx context.Context
} {
	var calls []struct {
		Ctx context.Context
	}
	mock.lockFindRequests.RLock()
	calls = mock.calls.FindRequests
	mock.lockFindRequests.RUnlock()
	return calls
}

// RequestModifier calls RequestModifierFunc.
func (mock *ReqLogServiceMock) RequestModifier(next proxy.RequestModifyFunc) proxy.RequestModifyFunc {
	if mock.RequestModifierFunc == nil {
		panic("ReqLogServiceMock.RequestModifierFunc: method is nil but Service.RequestModifier was just called")
	}
	callInfo := struct {
		Next proxy.RequestModifyFunc
	}{
		Next: next,
	}
	mock.lockRequestModifier.Lock()
	mock.calls.RequestModifier = append(mock.calls.RequestModifier, callInfo)
	mock.lockRequestModifier.Unlock()
	return mock.RequestModifierFunc(next)
}

// RequestModifierCalls gets all the calls that were made to RequestModifier.
// Check the length with:
//     len(mockedService.RequestModifierCalls())
func (mock *ReqLogServiceMock) RequestModifierCalls() []struct {
	Next proxy.RequestModifyFunc
} {
	var calls []struct {
		Next proxy.RequestModifyFunc
	}
	mock.lockRequestModifier.RLock()
	calls = mock.calls.RequestModifier
	mock.lockRequestModifier.RUnlock()
	return calls
}

// ResponseModifier calls ResponseModifierFunc.
func (mock *ReqLogServiceMock) ResponseModifier(next proxy.ResponseModifyFunc) proxy.ResponseModifyFunc {
	if mock.ResponseModifierFunc == nil {
		panic("ReqLogServiceMock.ResponseModifierFunc: method is nil but Service.ResponseModifier was just called")
	}
	callInfo := struct {
		Next proxy.ResponseModifyFunc
	}{
		Next: next,
	}
	mock.lockResponseModifier.Lock()
	mock.calls.ResponseModifier = append(mock.calls.ResponseModifier, callInfo)
	mock.lockResponseModifier.Unlock()
	return mock.ResponseModifierFunc(next)
}

// ResponseModifierCalls gets all the calls that were made to ResponseModifier.
// Check the length with:
//     len(mockedService.ResponseModifierCalls())
func (mock *ReqLogServiceMock) ResponseModifierCalls() []struct {
	Next proxy.ResponseModifyFunc
} {
	var calls []struct {
		Next proxy.ResponseModifyFunc
	}
	mock.lockResponseModifier.RLock()
	calls = mock.calls.ResponseModifier
	mock.lockResponseModifier.RUnlock()
	return calls
}

// SetActiveProjectID calls SetActiveProjectIDFunc.
func (mock *ReqLogServiceMock) SetActiveProjectID(id ulid.ULID) {
	if mock.SetActiveProjectIDFunc == nil {
		panic("ReqLogServiceMock.SetActiveProjectIDFunc: method is nil but Service.SetActiveProjectID was just called")
	}
	callInfo := struct {
		ID ulid.ULID
	}{
		ID: id,
	}
	mock.lockSetActiveProjectID.Lock()
	mock.calls.SetActiveProjectID = append(mock.calls.SetActiveProjectID, callInfo)
	mock.lockSetActiveProjectID.Unlock()
	mock.SetActiveProjectIDFunc(id)
}

// SetActiveProjectIDCalls gets all the calls that were made to SetActiveProjectID.
// Check the length with:
//     len(mockedService.SetActiveProjectIDCalls())
func (mock *ReqLogServiceMock) SetActiveProjectIDCalls() []struct {
	ID ulid.ULID
} {
	var calls []struct {
		ID ulid.ULID
	}
	mock.lockSetActiveProjectID.RLock()
	calls = mock.calls.SetActiveProjectID
	mock.lockSetActiveProjectID.RUnlock()
	return calls
}

// SetBypassOutOfScopeRequests calls SetBypassOutOfScopeRequestsFunc.
func (mock *ReqLogServiceMock) SetBypassOutOfScopeRequests(b bool) {
	if mock.SetBypassOutOfScopeRequestsFunc == nil {
		panic("ReqLogServiceMock.SetBypassOutOfScopeRequestsFunc: method is nil but Service.SetBypassOutOfScopeRequests was just called")
	}
	callInfo := struct {
		B bool
	}{
		B: b,
	}
	mock.lockSetBypassOutOfScopeRequests.Lock()
	mock.calls.SetBypassOutOfScopeRequests = append(mock.calls.SetBypassOutOfScopeRequests, callInfo)
	mock.lockSetBypassOutOfScopeRequests.Unlock()
	mock.SetBypassOutOfScopeRequestsFunc(b)
}

// SetBypassOutOfScopeRequestsCalls gets all the calls that were made to SetBypassOutOfScopeRequests.
// Check the length with:
//     len(mockedService.SetBypassOutOfScopeRequestsCalls())
func (mock *ReqLogServiceMock) SetBypassOutOfScopeRequestsCalls() []struct {
	B bool
} {
	var calls []struct {
		B bool
	}
	mock.lockSetBypassOutOfScopeRequests.RLock()
	calls = mock.calls.SetBypassOutOfScopeRequests
	mock.lockSetBypassOutOfScopeRequests.RUnlock()
	return calls
}

// SetFindReqsFilter calls SetFindReqsFilterFunc.
func (mock *ReqLogServiceMock) SetFindReqsFilter(filter reqlog.FindRequestsFilter) {
	if mock.SetFindReqsFilterFunc == nil {
		panic("ReqLogServiceMock.SetFindReqsFilterFunc: method is nil but Service.SetFindReqsFilter was just called")
	}
	callInfo := struct {
		Filter reqlog.FindRequestsFilter
	}{
		Filter: filter,
	}
	mock.lockSetFindReqsFilter.Lock()
	mock.calls.SetFindReqsFilter = append(mock.calls.SetFindReqsFilter, callInfo)
	mock.lockSetFindReqsFilter.Unlock()
	mock.SetFindReqsFilterFunc(filter)
}

// SetFindReqsFilterCalls gets all the calls that were made to SetFindReqsFilter.
// Check the length with:
//     len(mockedService.SetFindReqsFilterCalls())
func (mock *ReqLogServiceMock) SetFindReqsFilterCalls() []struct {
	Filter reqlog.FindRequestsFilter
} {
	var calls []struct {
		Filter reqlog.FindRequestsFilter
	}
	mock.lockSetFindReqsFilter.RLock()
	calls = mock.calls.SetFindReqsFilter
	mock.lockSetFindReqsFilter.RUnlock()
	return calls
}