5 changed files with 12 additions and 657 deletions
--- a/.mockery.yaml
+++ b/.mockery.yaml
@ -9,6 +9,3 @@ packages:
      QuoteService:
      ChallengeGenerator:
      ChallengeVerifier:
-  hash-of-wisdom/internal/controller:
-    interfaces:
-      WisdomService:
--- a/docs/IMPLEMENTATION.md
+++ b/docs/IMPLEMENTATION.md
@ -68,32 +68,28 @@
 - [X] Create message validation and bounds checking
 - [X] Write unit tests for protocol components

-## 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
+## Phase 5: Basic Server Architecture
 - [ ] Set up structured logging (zerolog/logrus)
 - [ ] Set up metrics collection (prometheus)
 - [ ] Create configuration management
 - [ ] Integrate all components into server architecture

-## Phase 7: Advanced Server Features
- [ ] Add connection pooling and advanced connection management
+## 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
 - [ ] Implement graceful shutdown mechanism
- [ ] Add health check endpoints
 - [ ] Add request/response logging middleware
 - [ ] Create health check endpoints
 - [ ] Write integration tests for server core

-## Phase 8: DDOS Protection & Rate Limiting
+## Phase 9: DDOS Protection & Rate Limiting
 - [ ] Implement IP-based connection limiting
 - [ ] Create rate limiting service with time windows
 - [ ] Add automatic difficulty adjustment based on load
--- a/internal/controller/controller.go
+++ b/internal/controller/controller.go
@ -1,121 +0,0 @@
-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
-}
--- a/internal/controller/controller_test.go
+++ b/internal/controller/controller_test.go
@ -1,314 +0,0 @@
-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)
-}
--- a/internal/controller/mocks/mock_wisdom_service.go
+++ b/internal/controller/mocks/mock_wisdom_service.go
@ -1,203 +0,0 @@
-// 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
-}