Implement tests for controller

.mockery.yaml

@@ -9,3 +9,6 @@ packages:
       QuoteService:
       ChallengeGenerator:
       ChallengeVerifier:
+  hash-of-wisdom/internal/controller:
+    interfaces:
+      WisdomService:

docs/IMPLEMENTATION.md

@@ -68,28 +68,32 @@
 - [X] Create message validation and bounds checking
 - [X] Write unit tests for protocol components
 
-## Phase 5: Basic Server Architecture
+## Phase 5: TCP Server & Connection Management
+- [ ] Implement TCP server with connection handling
+- [ ] Add dual timeout protection:
+  - [ ] Connection timeout (max total connection time)
+  - [ ] Read timeout (max idle time between bytes - slowloris protection)
+- [ ] Implement proper connection lifecycle management
+- [ ] Create protocol state machine for request/response flow
+- [ ] Add graceful connection cleanup and error handling
+- [ ] Implement basic client for testing
+- [ ] Write integration tests for client-server communication
+
+## Phase 6: Basic Server Architecture
 - [ ] Set up structured logging (zerolog/logrus)
 - [ ] Set up metrics collection (prometheus)
 - [ ] Create configuration management
 - [ ] Integrate all components into server architecture
 
-## Phase 6: TCP Protocol & Connection Handling
-- [ ] Implement connection handler with proper error handling
-- [ ] Create protocol state machine
-- [ ] Implement connection lifecycle management
-- [ ] Add connection timeout and lifecycle management
-
-## Phase 7: Server Core & Request Handling
-- [ ] Implement TCP server with connection pooling
-- [ ] Create request router and handler dispatcher
-- [ ] Add connection timeout and lifecycle management
+## Phase 7: Advanced Server Features
+- [ ] Add connection pooling and advanced connection management
 - [ ] Implement graceful shutdown mechanism
+- [ ] Add health check endpoints
 - [ ] Add request/response logging middleware
 - [ ] Create health check endpoints
 - [ ] Write integration tests for server core
 
-## Phase 9: DDOS Protection & Rate Limiting
+## Phase 8: DDOS Protection & Rate Limiting
 - [ ] Implement IP-based connection limiting
 - [ ] Create rate limiting service with time windows
 - [ ] Add automatic difficulty adjustment based on load

internal/controller/controller.go

@@ -0,0 +1,121 @@
+package controller
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"hash-of-wisdom/internal/pow/challenge"
+	"hash-of-wisdom/internal/protocol"
+	"hash-of-wisdom/internal/quotes"
+)
+
+// WisdomService defines the interface for the wisdom service
+type WisdomService interface {
+	GenerateChallenge(ctx context.Context, resource string) (*challenge.Challenge, error)
+	VerifySolution(ctx context.Context, solution *challenge.Solution) error
+	GetQuote(ctx context.Context) (*quotes.Quote, error)
+}
+
+// WisdomController handles the Word of Wisdom protocol flow
+type WisdomController struct {
+	wisdomService WisdomService
+	codec         *protocol.Codec
+}
+
+// NewWisdomController creates a new wisdom protocol controller
+func NewWisdomController(wisdomService WisdomService) *WisdomController {
+	return &WisdomController{
+		wisdomService: wisdomService,
+		codec:         protocol.NewCodec(),
+	}
+}
+
+// HandleMessage processes a protocol message and returns a response
+func (c *WisdomController) HandleMessage(ctx context.Context, msg *protocol.Message) (*protocol.Message, error) {
+	switch msg.Type {
+	case protocol.ChallengeRequest:
+		return c.handleChallengeRequest(ctx, msg)
+	case protocol.SolutionRequest:
+		return c.handleSolutionRequest(ctx, msg)
+	default:
+		return c.createErrorResponse(protocol.ErrMalformedMessage,
+			fmt.Sprintf("unsupported message type: 0x%02x", msg.Type))
+	}
+}
+
+// handleChallengeRequest processes challenge requests
+func (c *WisdomController) handleChallengeRequest(ctx context.Context, _ *protocol.Message) (*protocol.Message, error) {
+	challenge, err := c.wisdomService.GenerateChallenge(ctx, "quotes")
+	if err != nil {
+		return c.createErrorResponse(protocol.ErrServerError, "failed to generate challenge")
+	}
+
+	// Protocol requires direct challenge JSON (not wrapped)
+	payload := (*protocol.ChallengeResponsePayload)(challenge)
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return c.createErrorResponse(protocol.ErrServerError, "failed to marshal challenge")
+	}
+
+	return &protocol.Message{
+		Type:    protocol.ChallengeResponse,
+		Payload: jsonData,
+	}, nil
+}
+
+// handleSolutionRequest processes solution requests
+func (c *WisdomController) handleSolutionRequest(ctx context.Context, msg *protocol.Message) (*protocol.Message, error) {
+	// Parse solution request
+	var solutionReq protocol.SolutionRequestPayload
+	if err := json.Unmarshal(msg.Payload, &solutionReq); err != nil {
+		return c.createErrorResponse(protocol.ErrMalformedMessage, "invalid solution format")
+	}
+
+	// Create solution object
+	solution := &challenge.Solution{
+		Challenge: solutionReq.Challenge,
+		Nonce:     solutionReq.Nonce,
+	}
+
+	// Verify solution
+	if err := c.wisdomService.VerifySolution(ctx, solution); err != nil {
+		return c.createErrorResponse(protocol.ErrInvalidSolution, "solution verification failed")
+	}
+
+	// Get quote
+	quote, err := c.wisdomService.GetQuote(ctx)
+	if err != nil {
+		return c.createErrorResponse(protocol.ErrServerError, "failed to get quote")
+	}
+
+	// Protocol requires direct quote JSON (not wrapped)
+	payload := (*protocol.QuoteResponsePayload)(quote)
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return c.createErrorResponse(protocol.ErrServerError, "failed to marshal quote")
+	}
+
+	return &protocol.Message{
+		Type:    protocol.QuoteResponse,
+		Payload: jsonData,
+	}, nil
+}
+
+// createErrorResponse creates a protocol error response
+func (c *WisdomController) createErrorResponse(code, message string) (*protocol.Message, error) {
+	errorPayload := &protocol.ErrorResponsePayload{
+		Code:    code,
+		Message: message,
+	}
+
+	jsonData, err := json.Marshal(errorPayload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal error: %w", err)
+	}
+
+	return &protocol.Message{
+		Type:    protocol.ErrorResponse,
+		Payload: jsonData,
+	}, nil
+}

internal/controller/controller_test.go

@@ -0,0 +1,314 @@
+package controller
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"hash-of-wisdom/internal/controller/mocks"
+	"hash-of-wisdom/internal/pow/challenge"
+	"hash-of-wisdom/internal/protocol"
+	"hash-of-wisdom/internal/quotes"
+	"hash-of-wisdom/internal/service"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewWisdomController(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	assert.NotNil(t, controller)
+	assert.Equal(t, mockService, controller.wisdomService)
+	assert.NotNil(t, controller.codec)
+}
+
+func TestWisdomController_HandleMessage_UnsupportedType(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	ctx := context.Background()
+	msg := &protocol.Message{
+		Type:    protocol.MessageType(0xFF), // Invalid type
+		Payload: []byte{},
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrorResponse, response.Type)
+
+	var errorPayload protocol.ErrorResponsePayload
+	err = json.Unmarshal(response.Payload, &errorPayload)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrMalformedMessage, errorPayload.Code)
+	assert.Contains(t, errorPayload.Message, "unsupported message type: 0xff")
+}
+
+func TestWisdomController_HandleChallengeRequest_Success(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	// Mock successful challenge generation
+	testChallenge := &challenge.Challenge{
+		Resource:   "quotes",
+		Timestamp:  12345,
+		Difficulty: 4,
+		Random:     []byte("test"),
+		HMAC:       []byte("signature"),
+	}
+
+	mockService.On("GenerateChallenge", mock.Anything, "quotes").Return(testChallenge, nil)
+
+	ctx := context.Background()
+	msg := &protocol.Message{
+		Type:    protocol.ChallengeRequest,
+		Payload: []byte{},
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ChallengeResponse, response.Type)
+
+	// Verify the challenge is properly marshaled
+	var challengePayload challenge.Challenge
+	err = json.Unmarshal(response.Payload, &challengePayload)
+	require.NoError(t, err)
+	assert.Equal(t, testChallenge.Resource, challengePayload.Resource)
+	assert.Equal(t, testChallenge.Difficulty, challengePayload.Difficulty)
+
+	mockService.AssertExpectations(t)
+}
+
+func TestWisdomController_HandleChallengeRequest_ServiceError(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	// Mock service error
+	mockService.On("GenerateChallenge", mock.Anything, "quotes").Return(nil, errors.New("service error"))
+
+	ctx := context.Background()
+	msg := &protocol.Message{
+		Type:    protocol.ChallengeRequest,
+		Payload: []byte{},
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrorResponse, response.Type)
+
+	var errorPayload protocol.ErrorResponsePayload
+	err = json.Unmarshal(response.Payload, &errorPayload)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrServerError, errorPayload.Code)
+	assert.Equal(t, "failed to generate challenge", errorPayload.Message)
+
+	mockService.AssertExpectations(t)
+}
+
+func TestWisdomController_HandleSolutionRequest_Success(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	// Create test solution request
+	testChallenge := challenge.Challenge{
+		Resource:   "quotes",
+		Timestamp:  12345,
+		Difficulty: 4,
+		Random:     []byte("test"),
+		HMAC:       []byte("signature"),
+	}
+
+	solutionPayload := protocol.SolutionRequestPayload{
+		Challenge: testChallenge,
+		Nonce:     12345,
+	}
+
+	payloadJSON, err := json.Marshal(solutionPayload)
+	require.NoError(t, err)
+
+	testQuote := &quotes.Quote{
+		Text:   "Test quote",
+		Author: "Test Author",
+	}
+
+	// Mock successful verification and quote retrieval
+	mockService.On("VerifySolution", mock.Anything, mock.AnythingOfType("*challenge.Solution")).Return(nil)
+	mockService.On("GetQuote", mock.Anything).Return(testQuote, nil)
+
+	ctx := context.Background()
+	msg := &protocol.Message{
+		Type:    protocol.SolutionRequest,
+		Payload: payloadJSON,
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.QuoteResponse, response.Type)
+
+	// Verify the quote is properly marshaled
+	var quotePayload quotes.Quote
+	err = json.Unmarshal(response.Payload, &quotePayload)
+	require.NoError(t, err)
+	assert.Equal(t, testQuote.Text, quotePayload.Text)
+	assert.Equal(t, testQuote.Author, quotePayload.Author)
+
+	mockService.AssertExpectations(t)
+}
+
+func TestWisdomController_HandleSolutionRequest_InvalidJSON(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	ctx := context.Background()
+	msg := &protocol.Message{
+		Type:    protocol.SolutionRequest,
+		Payload: []byte("invalid json"),
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrorResponse, response.Type)
+
+	var errorPayload protocol.ErrorResponsePayload
+	err = json.Unmarshal(response.Payload, &errorPayload)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrMalformedMessage, errorPayload.Code)
+	assert.Equal(t, "invalid solution format", errorPayload.Message)
+
+	mockService.AssertNotCalled(t, "VerifySolution")
+	mockService.AssertNotCalled(t, "GetQuote")
+}
+
+func TestWisdomController_HandleSolutionRequest_VerificationFailed(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	// Create test solution request
+	testChallenge := challenge.Challenge{
+		Resource:   "quotes",
+		Timestamp:  12345,
+		Difficulty: 4,
+		Random:     []byte("test"),
+		HMAC:       []byte("signature"),
+	}
+
+	solutionPayload := protocol.SolutionRequestPayload{
+		Challenge: testChallenge,
+		Nonce:     12345,
+	}
+
+	payloadJSON, err := json.Marshal(solutionPayload)
+	require.NoError(t, err)
+
+	// Mock verification failure
+	mockService.On("VerifySolution", mock.Anything, mock.AnythingOfType("*challenge.Solution")).Return(service.ErrInvalidSolution)
+
+	ctx := context.Background()
+	msg := &protocol.Message{
+		Type:    protocol.SolutionRequest,
+		Payload: payloadJSON,
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrorResponse, response.Type)
+
+	var errorPayload protocol.ErrorResponsePayload
+	err = json.Unmarshal(response.Payload, &errorPayload)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrInvalidSolution, errorPayload.Code)
+	assert.Equal(t, "solution verification failed", errorPayload.Message)
+
+	mockService.AssertExpectations(t)
+	mockService.AssertNotCalled(t, "GetQuote")
+}
+
+func TestWisdomController_HandleSolutionRequest_QuoteServiceError(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	// Create test solution request
+	testChallenge := challenge.Challenge{
+		Resource:   "quotes",
+		Timestamp:  12345,
+		Difficulty: 4,
+		Random:     []byte("test"),
+		HMAC:       []byte("signature"),
+	}
+
+	solutionPayload := protocol.SolutionRequestPayload{
+		Challenge: testChallenge,
+		Nonce:     12345,
+	}
+
+	payloadJSON, err := json.Marshal(solutionPayload)
+	require.NoError(t, err)
+
+	// Mock successful verification but quote service error
+	mockService.On("VerifySolution", mock.Anything, mock.AnythingOfType("*challenge.Solution")).Return(nil)
+	mockService.On("GetQuote", mock.Anything).Return(nil, errors.New("quote service error"))
+
+	ctx := context.Background()
+	msg := &protocol.Message{
+		Type:    protocol.SolutionRequest,
+		Payload: payloadJSON,
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrorResponse, response.Type)
+
+	var errorPayload protocol.ErrorResponsePayload
+	err = json.Unmarshal(response.Payload, &errorPayload)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrServerError, errorPayload.Code)
+	assert.Equal(t, "failed to get quote", errorPayload.Message)
+
+	mockService.AssertExpectations(t)
+}
+
+func TestWisdomController_CreateErrorResponse_MarshalError(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	// This test verifies the internal error handling
+	// In practice, json.Marshal on ErrorResponsePayload should never fail
+	// But we test the error path for completeness
+	response, err := controller.createErrorResponse(protocol.ErrServerError, "test message")
+
+	// Should not fail with normal inputs
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrorResponse, response.Type)
+	assert.NotEmpty(t, response.Payload)
+}
+
+func TestWisdomController_HandleMessage_ContextCancellation(t *testing.T) {
+	mockService := mocks.NewMockWisdomService(t)
+	controller := NewWisdomController(mockService)
+
+	// Create cancelled context
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	// Mock service to respect context cancellation
+	mockService.On("GenerateChallenge", mock.Anything, "quotes").Return(nil, context.Canceled)
+
+	msg := &protocol.Message{
+		Type:    protocol.ChallengeRequest,
+		Payload: []byte{},
+	}
+
+	response, err := controller.HandleMessage(ctx, msg)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrorResponse, response.Type)
+
+	var errorPayload protocol.ErrorResponsePayload
+	err = json.Unmarshal(response.Payload, &errorPayload)
+	require.NoError(t, err)
+	assert.Equal(t, protocol.ErrServerError, errorPayload.Code)
+
+	mockService.AssertExpectations(t)
+}

internal/controller/mocks/mock_wisdom_service.go

@@ -0,0 +1,203 @@
+// Code generated by mockery v2.53.5. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+	challenge "hash-of-wisdom/internal/pow/challenge"
+
+	mock "github.com/stretchr/testify/mock"
+
+	quotes "hash-of-wisdom/internal/quotes"
+)
+
+// MockWisdomService is an autogenerated mock type for the WisdomService type
+type MockWisdomService struct {
+	mock.Mock
+}
+
+type MockWisdomService_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockWisdomService) EXPECT() *MockWisdomService_Expecter {
+	return &MockWisdomService_Expecter{mock: &_m.Mock}
+}
+
+// GenerateChallenge provides a mock function with given fields: ctx, resource
+func (_m *MockWisdomService) GenerateChallenge(ctx context.Context, resource string) (*challenge.Challenge, error) {
+	ret := _m.Called(ctx, resource)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GenerateChallenge")
+	}
+
+	var r0 *challenge.Challenge
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string) (*challenge.Challenge, error)); ok {
+		return rf(ctx, resource)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string) *challenge.Challenge); ok {
+		r0 = rf(ctx, resource)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*challenge.Challenge)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+		r1 = rf(ctx, resource)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockWisdomService_GenerateChallenge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenerateChallenge'
+type MockWisdomService_GenerateChallenge_Call struct {
+	*mock.Call
+}
+
+// GenerateChallenge is a helper method to define mock.On call
+//   - ctx context.Context
+//   - resource string
+func (_e *MockWisdomService_Expecter) GenerateChallenge(ctx interface{}, resource interface{}) *MockWisdomService_GenerateChallenge_Call {
+	return &MockWisdomService_GenerateChallenge_Call{Call: _e.mock.On("GenerateChallenge", ctx, resource)}
+}
+
+func (_c *MockWisdomService_GenerateChallenge_Call) Run(run func(ctx context.Context, resource string)) *MockWisdomService_GenerateChallenge_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(string))
+	})
+	return _c
+}
+
+func (_c *MockWisdomService_GenerateChallenge_Call) Return(_a0 *challenge.Challenge, _a1 error) *MockWisdomService_GenerateChallenge_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockWisdomService_GenerateChallenge_Call) RunAndReturn(run func(context.Context, string) (*challenge.Challenge, error)) *MockWisdomService_GenerateChallenge_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// GetQuote provides a mock function with given fields: ctx
+func (_m *MockWisdomService) GetQuote(ctx context.Context) (*quotes.Quote, error) {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GetQuote")
+	}
+
+	var r0 *quotes.Quote
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context) (*quotes.Quote, error)); ok {
+		return rf(ctx)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context) *quotes.Quote); ok {
+		r0 = rf(ctx)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*quotes.Quote)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(ctx)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockWisdomService_GetQuote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQuote'
+type MockWisdomService_GetQuote_Call struct {
+	*mock.Call
+}
+
+// GetQuote is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *MockWisdomService_Expecter) GetQuote(ctx interface{}) *MockWisdomService_GetQuote_Call {
+	return &MockWisdomService_GetQuote_Call{Call: _e.mock.On("GetQuote", ctx)}
+}
+
+func (_c *MockWisdomService_GetQuote_Call) Run(run func(ctx context.Context)) *MockWisdomService_GetQuote_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *MockWisdomService_GetQuote_Call) Return(_a0 *quotes.Quote, _a1 error) *MockWisdomService_GetQuote_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockWisdomService_GetQuote_Call) RunAndReturn(run func(context.Context) (*quotes.Quote, error)) *MockWisdomService_GetQuote_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// VerifySolution provides a mock function with given fields: ctx, solution
+func (_m *MockWisdomService) VerifySolution(ctx context.Context, solution *challenge.Solution) error {
+	ret := _m.Called(ctx, solution)
+
+	if len(ret) == 0 {
+		panic("no return value specified for VerifySolution")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context, *challenge.Solution) error); ok {
+		r0 = rf(ctx, solution)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// MockWisdomService_VerifySolution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifySolution'
+type MockWisdomService_VerifySolution_Call struct {
+	*mock.Call
+}
+
+// VerifySolution is a helper method to define mock.On call
+//   - ctx context.Context
+//   - solution *challenge.Solution
+func (_e *MockWisdomService_Expecter) VerifySolution(ctx interface{}, solution interface{}) *MockWisdomService_VerifySolution_Call {
+	return &MockWisdomService_VerifySolution_Call{Call: _e.mock.On("VerifySolution", ctx, solution)}
+}
+
+func (_c *MockWisdomService_VerifySolution_Call) Run(run func(ctx context.Context, solution *challenge.Solution)) *MockWisdomService_VerifySolution_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*challenge.Solution))
+	})
+	return _c
+}
+
+func (_c *MockWisdomService_VerifySolution_Call) Return(_a0 error) *MockWisdomService_VerifySolution_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *MockWisdomService_VerifySolution_Call) RunAndReturn(run func(context.Context, *challenge.Solution) error) *MockWisdomService_VerifySolution_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockWisdomService creates a new instance of MockWisdomService. 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 NewMockWisdomService(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockWisdomService {
+	mock := &MockWisdomService{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}