Added consume usecase unit tests

Mainly testing the handlemessage method with different input messages.

internal/usecases/consume/consume.go

@@ -17,11 +17,11 @@ type Service struct {
 }
 
 // NewService creates a new service
-func NewService(broker brokerdriver.Broker, produceService produce.UseCase, converQueryService convertquery.UseCase, requestSenderService request.UseCase) *Service {
+func NewService(broker brokerdriver.Broker, produceService produce.UseCase, convertQueryService convertquery.UseCase, requestSenderService request.UseCase) *Service {
 	return &Service{
 		broker:         broker,
 		producer:       produceService,
-		queryConverter: converQueryService,
+		queryConverter: convertQueryService,
 		requestSender:  requestSenderService,
 	}
 }

internal/usecases/consume/consume_test.go

+package consume
+
+import (
+	"encoding/json"
+	"query-service/internal/adapters/brokeradapter"
+	mockbrokerdriver "query-service/internal/drivers/brokerdriver/mock"
+	mockkeyvaluedriver "query-service/internal/drivers/keyvaluedriver/mock"
+	mockconvertquery "query-service/internal/usecases/convertquery/mock"
+	"query-service/internal/usecases/produce"
+	mockrequest "query-service/internal/usecases/request/mock"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStart(t *testing.T) {
+	// // Create broker adapter
+	// brokerAdapter := brokeradapter.CreateGateway()
+	// // Create a mock broker
+	// mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
+	// // Create mock key value store
+	// keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
+	// // Create new producer service
+	// producerService := produce.NewService(mockBroker, keyValueStore)
+	// // Create new convert query service
+	// convertQueryService := convertquery.NewService()
+	// // Create new request sender service
+	// requestSenderService := request.NewService()
+	// // Create new service
+	// service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)
+}
+
+func TestHandleCorrectMessage(t *testing.T) {
+	// Create broker adapter
+	brokerAdapter := brokeradapter.CreateGateway()
+	// Create a mock broker
+	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
+	// Create mock key value store
+	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
+	// Create new producer service
+	producerService := produce.NewService(mockBroker, keyValueStore)
+	producerService.Start()
+	// Create new convert query service
+	convertQueryService := mockconvertquery.NewService()
+	// Create new request sender service
+	requestSenderService := mockrequest.NewService()
+	// Create new service
+	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)
+
+	// Create mock session and mock queue
+	mockSession := "mock-session"
+	mockQueue := "mock-queue"
+
+	// Set the test-session sessionID queue to mock-queue in key value store
+	keyValueStore.Set(&mockSession, &mockQueue)
+
+	// Create headers containing a sessionID
+	headers := make(map[string]interface{})
+	headers["sessionID"] = mockSession
+	mockMessage := brokeradapter.Message{
+		Headers: headers,
+		Body:    []byte("test message"),
+	}
+
+	// Assert that there have not been any messages sent yet
+	assert.Empty(t, mockBroker.Messages)
+
+	// Send the mock message
+	service.HandleMessage(&mockMessage)
+
+	// Assert that there now are two messages that have been sent with routing key mock-queue
+	assert.Len(t, mockBroker.Messages[mockQueue], 2)
+
+	// Assert that the first message is of type 'query_translation_result' and has 'Query converted' as value
+	var translationMessage map[string]interface{}
+	json.Unmarshal(mockBroker.Messages[mockQueue][0].Body, &translationMessage)
+	assert.Equal(t, "query_translation_result", translationMessage["type"])
+	assert.Equal(t, "Query converted", translationMessage["values"])
+
+	// Assert that the second message is of type 'query_result' and contains no values
+	var resultMessage map[string]interface{}
+	json.Unmarshal(mockBroker.Messages[mockQueue][1].Body, &resultMessage)
+	assert.Equal(t, "query_result", resultMessage["type"])
+	assert.Empty(t, resultMessage["values"])
+}
+
+// Unit test message received with no session ID
+func TestHandleMessageNoSessionID(t *testing.T) {
+	// Create broker adapter
+	brokerAdapter := brokeradapter.CreateGateway()
+	// Create a mock broker
+	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
+	// Create mock key value store
+	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
+	// Create new producer service
+	producerService := produce.NewService(mockBroker, keyValueStore)
+	// Create new convert query service
+	convertQueryService := mockconvertquery.NewService()
+	// Create new request sender service
+	requestSenderService := mockrequest.NewService()
+	// Create new service
+	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)
+
+	// Create headers containing a sessionID
+	headers := make(map[string]interface{})
+	mockMessage := brokeradapter.Message{
+		Headers: headers,
+		Body:    []byte("test message"),
+	}
+
+	// Assert that there have not been any messages sent yet
+	assert.Empty(t, mockBroker.Messages)
+
+	// Send the mock message
+	service.HandleMessage(&mockMessage)
+
+	// Assert that there was no message published
+	assert.Empty(t, mockBroker.Messages)
+}
+
+// Unit test receival of message and not being able to parse it
+func TestFailToConvertQuery(t *testing.T) {
+	// Create broker adapter
+	brokerAdapter := brokeradapter.CreateGateway()
+	// Create a mock broker
+	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
+	// Create mock key value store
+	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
+	// Create new producer service
+	producerService := produce.NewService(mockBroker, keyValueStore)
+	producerService.Start()
+	// Create new convert query service
+	convertQueryService := mockconvertquery.NewService()
+	// Create new request sender service
+	requestSenderService := mockrequest.NewService()
+	// Create new service
+	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)
+
+	// Create mock session and mock queue
+	mockSession := "mock-session"
+	mockQueue := "mock-queue"
+
+	// Set the test-session sessionID queue to mock-queue in key value store
+	keyValueStore.Set(&mockSession, &mockQueue)
+
+	// Create headers containing a sessionID
+	headers := make(map[string]interface{})
+	headers["sessionID"] = mockSession
+	mockMessage := brokeradapter.Message{
+		Headers: headers,
+		Body:    []byte("test message"),
+	}
+
+	// Make it so that the conversion service throws an error
+	convertQueryService.ToggleError()
+
+	// Assert that there have not been any messages sent yet
+	assert.Empty(t, mockBroker.Messages)
+
+	// Send the mock message
+	service.HandleMessage(&mockMessage)
+
+	// Assert that there was an error message published
+	var errorMsg map[string]interface{}
+	json.Unmarshal(mockBroker.Messages[mockQueue][0].Body, &errorMsg)
+	assert.Equal(t, "query_translation_error", errorMsg["type"])
+}
+
+// Test AQL querying error handling
+func TestArangoError(t *testing.T) {
+	// Create broker adapter
+	brokerAdapter := brokeradapter.CreateGateway()
+	// Create a mock broker
+	mockBroker := mockbrokerdriver.CreateBroker(brokerAdapter)
+	// Create mock key value store
+	keyValueStore := mockkeyvaluedriver.CreateKeyValueStore()
+	// Create new producer service
+	producerService := produce.NewService(mockBroker, keyValueStore)
+	producerService.Start()
+	// Create new convert query service
+	convertQueryService := mockconvertquery.NewService()
+	// Create new request sender service
+	requestSenderService := mockrequest.NewService()
+	// Create new service
+	service := NewService(mockBroker, producerService, convertQueryService, requestSenderService)
+
+	// Create mock session and mock queue
+	mockSession := "mock-session"
+	mockQueue := "mock-queue"
+
+	// Set the test-session sessionID queue to mock-queue in key value store
+	keyValueStore.Set(&mockSession, &mockQueue)
+
+	// Create headers containing a sessionID
+	headers := make(map[string]interface{})
+	headers["sessionID"] = mockSession
+	mockMessage := brokeradapter.Message{
+		Headers: headers,
+		Body:    []byte("test message"),
+	}
+
+	// Make it so that the request sender service throws an error
+	requestSenderService.ToggleError()
+
+	// Assert that there have not been any messages sent yet
+	assert.Empty(t, mockBroker.Messages)
+
+	// Send the mock message
+	service.HandleMessage(&mockMessage)
+
+	// Assert that there was an error message published
+	var errorMsg map[string]interface{}
+	json.Unmarshal(mockBroker.Messages[mockQueue][1].Body, &errorMsg)
+	assert.Equal(t, "query_database_error", errorMsg["type"])
+}