cli/internal/codespaces/rpc/codespace/codespace_host_service.v1.proto.mock.go

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

package codespace

import (
	context "context"
	sync "sync"
)

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

// CodespaceHostServerMock is a mock implementation of CodespaceHostServer.
//
//	func TestSomethingThatUsesCodespaceHostServer(t *testing.T) {
//
//		// make and configure a mocked CodespaceHostServer
//		mockedCodespaceHostServer := &CodespaceHostServerMock{
//			NotifyCodespaceOfClientActivityFunc: func(contextMoqParam context.Context, notifyCodespaceOfClientActivityRequest *NotifyCodespaceOfClientActivityRequest) (*NotifyCodespaceOfClientActivityResponse, error) {
//				panic("mock out the NotifyCodespaceOfClientActivity method")
//			},
//			RebuildContainerAsyncFunc: func(contextMoqParam context.Context, rebuildContainerRequest *RebuildContainerRequest) (*RebuildContainerResponse, error) {
//				panic("mock out the RebuildContainerAsync method")
//			},
//			mustEmbedUnimplementedCodespaceHostServerFunc: func()  {
//				panic("mock out the mustEmbedUnimplementedCodespaceHostServer method")
//			},
//		}
//
//		// use mockedCodespaceHostServer in code that requires CodespaceHostServer
//		// and then make assertions.
//
//	}
type CodespaceHostServerMock struct {
	// NotifyCodespaceOfClientActivityFunc mocks the NotifyCodespaceOfClientActivity method.
	NotifyCodespaceOfClientActivityFunc func(contextMoqParam context.Context, notifyCodespaceOfClientActivityRequest *NotifyCodespaceOfClientActivityRequest) (*NotifyCodespaceOfClientActivityResponse, error)

	// RebuildContainerAsyncFunc mocks the RebuildContainerAsync method.
	RebuildContainerAsyncFunc func(contextMoqParam context.Context, rebuildContainerRequest *RebuildContainerRequest) (*RebuildContainerResponse, error)

	// mustEmbedUnimplementedCodespaceHostServerFunc mocks the mustEmbedUnimplementedCodespaceHostServer method.
	mustEmbedUnimplementedCodespaceHostServerFunc func()

	// calls tracks calls to the methods.
	calls struct {
		// NotifyCodespaceOfClientActivity holds details about calls to the NotifyCodespaceOfClientActivity method.
		NotifyCodespaceOfClientActivity []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// NotifyCodespaceOfClientActivityRequest is the notifyCodespaceOfClientActivityRequest argument value.
			NotifyCodespaceOfClientActivityRequest *NotifyCodespaceOfClientActivityRequest
		}
		// RebuildContainerAsync holds details about calls to the RebuildContainerAsync method.
		RebuildContainerAsync []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// RebuildContainerRequest is the rebuildContainerRequest argument value.
			RebuildContainerRequest *RebuildContainerRequest
		}
		// mustEmbedUnimplementedCodespaceHostServer holds details about calls to the mustEmbedUnimplementedCodespaceHostServer method.
		mustEmbedUnimplementedCodespaceHostServer []struct {
		}
	}
	lockNotifyCodespaceOfClientActivity           sync.RWMutex
	lockRebuildContainerAsync                     sync.RWMutex
	lockmustEmbedUnimplementedCodespaceHostServer sync.RWMutex
}

// NotifyCodespaceOfClientActivity calls NotifyCodespaceOfClientActivityFunc.
func (mock *CodespaceHostServerMock) NotifyCodespaceOfClientActivity(contextMoqParam context.Context, notifyCodespaceOfClientActivityRequest *NotifyCodespaceOfClientActivityRequest) (*NotifyCodespaceOfClientActivityResponse, error) {
	if mock.NotifyCodespaceOfClientActivityFunc == nil {
		panic("CodespaceHostServerMock.NotifyCodespaceOfClientActivityFunc: method is nil but CodespaceHostServer.NotifyCodespaceOfClientActivity was just called")
	}
	callInfo := struct {
		ContextMoqParam                        context.Context
		NotifyCodespaceOfClientActivityRequest *NotifyCodespaceOfClientActivityRequest
	}{
		ContextMoqParam:                        contextMoqParam,
		NotifyCodespaceOfClientActivityRequest: notifyCodespaceOfClientActivityRequest,
	}
	mock.lockNotifyCodespaceOfClientActivity.Lock()
	mock.calls.NotifyCodespaceOfClientActivity = append(mock.calls.NotifyCodespaceOfClientActivity, callInfo)
	mock.lockNotifyCodespaceOfClientActivity.Unlock()
	return mock.NotifyCodespaceOfClientActivityFunc(contextMoqParam, notifyCodespaceOfClientActivityRequest)
}

// NotifyCodespaceOfClientActivityCalls gets all the calls that were made to NotifyCodespaceOfClientActivity.
// Check the length with:
//
//	len(mockedCodespaceHostServer.NotifyCodespaceOfClientActivityCalls())
func (mock *CodespaceHostServerMock) NotifyCodespaceOfClientActivityCalls() []struct {
	ContextMoqParam                        context.Context
	NotifyCodespaceOfClientActivityRequest *NotifyCodespaceOfClientActivityRequest
} {
	var calls []struct {
		ContextMoqParam                        context.Context
		NotifyCodespaceOfClientActivityRequest *NotifyCodespaceOfClientActivityRequest
	}
	mock.lockNotifyCodespaceOfClientActivity.RLock()
	calls = mock.calls.NotifyCodespaceOfClientActivity
	mock.lockNotifyCodespaceOfClientActivity.RUnlock()
	return calls
}

// RebuildContainerAsync calls RebuildContainerAsyncFunc.
func (mock *CodespaceHostServerMock) RebuildContainerAsync(contextMoqParam context.Context, rebuildContainerRequest *RebuildContainerRequest) (*RebuildContainerResponse, error) {
	if mock.RebuildContainerAsyncFunc == nil {
		panic("CodespaceHostServerMock.RebuildContainerAsyncFunc: method is nil but CodespaceHostServer.RebuildContainerAsync was just called")
	}
	callInfo := struct {
		ContextMoqParam         context.Context
		RebuildContainerRequest *RebuildContainerRequest
	}{
		ContextMoqParam:         contextMoqParam,
		RebuildContainerRequest: rebuildContainerRequest,
	}
	mock.lockRebuildContainerAsync.Lock()
	mock.calls.RebuildContainerAsync = append(mock.calls.RebuildContainerAsync, callInfo)
	mock.lockRebuildContainerAsync.Unlock()
	return mock.RebuildContainerAsyncFunc(contextMoqParam, rebuildContainerRequest)
}

// RebuildContainerAsyncCalls gets all the calls that were made to RebuildContainerAsync.
// Check the length with:
//
//	len(mockedCodespaceHostServer.RebuildContainerAsyncCalls())
func (mock *CodespaceHostServerMock) RebuildContainerAsyncCalls() []struct {
	ContextMoqParam         context.Context
	RebuildContainerRequest *RebuildContainerRequest
} {
	var calls []struct {
		ContextMoqParam         context.Context
		RebuildContainerRequest *RebuildContainerRequest
	}
	mock.lockRebuildContainerAsync.RLock()
	calls = mock.calls.RebuildContainerAsync
	mock.lockRebuildContainerAsync.RUnlock()
	return calls
}

// mustEmbedUnimplementedCodespaceHostServer calls mustEmbedUnimplementedCodespaceHostServerFunc.
func (mock *CodespaceHostServerMock) mustEmbedUnimplementedCodespaceHostServer() {
	if mock.mustEmbedUnimplementedCodespaceHostServerFunc == nil {
		panic("CodespaceHostServerMock.mustEmbedUnimplementedCodespaceHostServerFunc: method is nil but CodespaceHostServer.mustEmbedUnimplementedCodespaceHostServer was just called")
	}
	callInfo := struct {
	}{}
	mock.lockmustEmbedUnimplementedCodespaceHostServer.Lock()
	mock.calls.mustEmbedUnimplementedCodespaceHostServer = append(mock.calls.mustEmbedUnimplementedCodespaceHostServer, callInfo)
	mock.lockmustEmbedUnimplementedCodespaceHostServer.Unlock()
	mock.mustEmbedUnimplementedCodespaceHostServerFunc()
}

// mustEmbedUnimplementedCodespaceHostServerCalls gets all the calls that were made to mustEmbedUnimplementedCodespaceHostServer.
// Check the length with:
//
//	len(mockedCodespaceHostServer.mustEmbedUnimplementedCodespaceHostServerCalls())
func (mock *CodespaceHostServerMock) mustEmbedUnimplementedCodespaceHostServerCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockmustEmbedUnimplementedCodespaceHostServer.RLock()
	calls = mock.calls.mustEmbedUnimplementedCodespaceHostServer
	mock.lockmustEmbedUnimplementedCodespaceHostServer.RUnlock()
	return calls
}