feat(fxelasticsearch): add mock elastic search client with http transport-level mocking capabilities

Author: ghamez-dev

fxelasticsearch/README.md

@@ -2,23 +2,23 @@
 
 [![ci](https://github.com/ankorstore/yokai-contrib/actions/workflows/fxelasticsearch-ci.yml/badge.svg)](https://github.com/ankorstore/yokai-contrib/actions/workflows/fxelasticsearch-ci.yml)
 [![go report](https://goreportcard.com/badge/github.com/ankorstore/yokai-contrib/fxelasticsearch)](https://goreportcard.com/report/github.com/ankorstore/yokai-contrib/fxelasticsearch)
-[![codecov](https://codecov.io/gh/ankorstore/yokai-contrib/graph/badge.svg?token=ghUBlFsjhR&flag=fxelasticsearch)](https://app.codecov.io/gh/ankorstore/yokai-contrib/tree/main/fxelasticsearch)
+[![codecov](https://codecov.io/gh/ankorstore/yokai-contrib/graph/badge.svg?token=ghUBlFsjhR&flag=fxelasticsearch)](https://codecov.io/gh/ankorstore/yokai-contrib/fxelasticsearch)
 [![Deps](https://img.shields.io/badge/osi-deps-blue)](https://deps.dev/go/github.com%2Fankorstore%2Fyokai-contrib%2Ffxelasticsearch)
 [![PkgGoDev](https://pkg.go.dev/badge/github.com/ankorstore/yokai-contrib/fxelasticsearch)](https://pkg.go.dev/github.com/ankorstore/yokai-contrib/fxelasticsearch)
 
-> [Fx](https://uber-go.github.io/fx/) module for [Elasticsearch](https://www.elastic.co/elasticsearch/).
+> [Fx](https://uber-go.github.io/fx/) module for [Elasticsearch](https://github.com/elastic/go-elasticsearch).
 
 <!-- TOC -->
 * [Overview](#overview)
 * [Installation](#installation)
 * [Configuration](#configuration)
-* [Usage](#usage)
+* [Testing](#testing)
 <!-- TOC -->
 
 ## Overview
 
 This module provides to your Fx application an [elasticsearch.Client](https://pkg.go.dev/github.com/elastic/go-elasticsearch/v8),
-that you can `inject` anywhere to interact with [Elasticsearch](https://www.elastic.co/elasticsearch/).
+that you can `inject` anywhere to interact with [Elasticsearch](https://github.com/elastic/go-elasticsearch).
 
 ## Installation
 
@@ -64,33 +64,91 @@ modules:
     password: ${ELASTICSEARCH_PASSWORD}
 ```
 
-## Usage
+Notes:
+- The `modules.elasticsearch.address` configuration key is mandatory
+- The `modules.elasticsearch.username` and `modules.elasticsearch.password` configuration keys are optional
+- See [Elasticsearch configuration](https://pkg.go.dev/github.com/elastic/go-elasticsearch/v8#Config) documentation for more details
 
-Inject the Elasticsearch client in your services:
+## Testing
+
+In `test` mode, an additional mock Elasticsearch client is provided with HTTP transport-level mocking capabilities.
+
+### Automatic Test Environment Support
+
+When `APP_ENV=test`, the module automatically provides a default mock Elasticsearch client that returns empty successful responses. This allows your application to start and run basic tests without any additional setup.
+
+### Custom Mock Clients
+
+For specific test scenarios, you can create custom mock clients with controlled responses:
 
 ```go
-package service
+package service_test
 
 import (
-    "context"
-    "github.com/elastic/go-elasticsearch/v8"
-    "github.com/elastic/go-elasticsearch/v8/esapi"
+	"context"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/ankorstore/yokai-contrib/fxelasticsearch"
+	"github.com/stretchr/testify/assert"
 )
 
-type MyService struct {
-    es *elasticsearch.Client
+func TestMyService_Search(t *testing.T) {
+	// Define mock response
+	mockResponse := `{
+		"took": 5,
+		"timed_out": false,
+		"hits": {
+			"total": {"value": 1},
+			"hits": [
+				{
+					"_source": {"title": "Test Document", "content": "Test content"}
+				}
+			]
+		}
+	}`
+
+	// Create mock Elasticsearch client
+	esClient, err := fxelasticsearch.NewMockESClientWithSingleResponse(mockResponse, 200)
+	assert.NoError(t, err)
+
+	// Use the mock client in your service
+	service := NewMyService(esClient)
+
+	// Test your service methods that use Elasticsearch
+	results, err := service.Search(context.Background(), "test-index", "test query")
+	assert.NoError(t, err)
+	assert.Len(t, results, 1)
+	assert.Equal(t, "Test Document", results[0]["title"])
 }
 
-func NewMyService(es *elasticsearch.Client) *MyService {
-    return &MyService{es: es}
-}
+### Using Injected Mock Client in Tests
+
+You can also use the automatically provided mock client in Fx-based tests:
 
-func (s *MyService) SearchDocuments(ctx context.Context, index string, query string) (*esapi.Response, error) {
-    // Use the Elasticsearch client to search for documents
-    return s.es.Search(
-        s.es.Search.WithContext(ctx),
-        s.es.Search.WithIndex(index),
-        s.es.Search.WithBody(strings.NewReader(query)),
-    )
+```go
+func TestWithFxInjection(t *testing.T) {
+	t.Setenv("APP_ENV", "test")
+	
+	var esClient *elasticsearch.Client
+	
+	app := fxtest.New(
+		t,
+		fxconfig.FxConfigModule,
+		fxelasticsearch.FxElasticsearchModule,
+		fx.Populate(&esClient),
+	)
+	
+	app.RequireStart()
+	
+	// The injected client is a mock that returns empty successful responses
+	res, err := esClient.Search()
+	assert.NoError(t, err)
+	assert.Equal(t, 200, res.StatusCode)
+	
+	app.RequireStop()
 }
-``` 
+```
+
+See [example](module_test.go).

fxelasticsearch/mock.go

@@ -1,35 +1,105 @@
 package fxelasticsearch
 
 import (
-	"github.com/elastic/go-elasticsearch/v8/esapi"
-	"github.com/stretchr/testify/mock"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/elastic/go-elasticsearch/v8"
 )
 
-// ElasticsearchClientInterface defines the methods for the Elasticsearch client.
-// Extend this interface as needed.
-type ElasticsearchClientInterface interface {
-	Search(indices []string, body interface{}) (*esapi.Response, error)
+// MockResponse represents a single mock HTTP response.
+type MockResponse struct {
+	StatusCode   int
+	ResponseBody string
+	Error        error
+}
+
+// MockTransport provides HTTP transport mock for testing Elasticsearch client.
+// This allows testing with the real elasticsearch.Client API without interface constraints.
+type MockTransport struct {
+	responses []MockResponse
+	index     int
 }
 
-// ElasticsearchClientMock implements ElasticsearchClientInterface.
-// Add methods as needed for testing.
-type ElasticsearchClientMock struct {
-	mock.Mock
+// NewMockTransport creates a new MockTransport with the given responses.
+// Responses are returned in order. If more requests are made than responses provided,
+// the last response is repeated.
+func NewMockTransport(responses []MockResponse) *MockTransport {
+	if len(responses) == 0 {
+		responses = []MockResponse{{StatusCode: 200, ResponseBody: "{}"}}
+	}
+
+	return &MockTransport{
+		responses: responses,
+		index:     0,
+	}
+}
+
+// RoundTrip implements the http.RoundTripper interface.
+func (t *MockTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	// Get current response (or last one if we've exceeded the list)
+	responseIndex := t.index
+	if responseIndex >= len(t.responses) {
+		responseIndex = len(t.responses) - 1
+	} else {
+		t.index++
+	}
+
+	mockResp := t.responses[responseIndex]
+
+	if mockResp.Error != nil {
+		return nil, mockResp.Error
+	}
+
+	// Create HTTP response
+	response := &http.Response{
+		StatusCode: mockResp.StatusCode,
+		Body:       io.NopCloser(strings.NewReader(mockResp.ResponseBody)),
+		Header:     make(http.Header),
+		Request:    req,
+	}
+
+	// Add Elasticsearch-specific headers that the client expects
+	response.Header.Set("Content-Type", "application/json")
+	response.Header.Set("X-Elastic-Product", "Elasticsearch") // Critical header for client validation
+
+	return response, nil
 }
 
-func (m *ElasticsearchClientMock) Search(indices []string, body interface{}) (*esapi.Response, error) {
-	args := m.Called(indices, body)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
+// NewMockESClient creates an Elasticsearch client with mocked HTTP transport.
+// This allows you to test with the real elasticsearch.Client API while controlling responses.
+func NewMockESClient(responses []MockResponse) (*elasticsearch.Client, error) {
+	transport := NewMockTransport(responses)
+
+	cfg := elasticsearch.Config{
+		Transport: transport,
 	}
 
-	resp, ok := args.Get(0).(*esapi.Response)
-	if !ok {
-		return nil, args.Error(1)
+	return elasticsearch.NewClient(cfg)
+}
+
+// NewMockESClientWithSingleResponse creates an Elasticsearch client with a single mock response.
+// This is a convenience function for simple test cases.
+func NewMockESClientWithSingleResponse(responseBody string, statusCode int) (*elasticsearch.Client, error) {
+	responses := []MockResponse{
+		{
+			StatusCode:   statusCode,
+			ResponseBody: responseBody,
+		},
 	}
 
-	return resp, args.Error(1)
+	return NewMockESClient(responses)
 }
 
-// Ensure ElasticsearchClientMock implements ElasticsearchClientInterface.
-var _ ElasticsearchClientInterface = (*ElasticsearchClientMock)(nil)
+// NewMockESClientWithError creates an Elasticsearch client that returns an error on requests.
+// This is useful for testing error handling.
+func NewMockESClientWithError(err error) (*elasticsearch.Client, error) {
+	responses := []MockResponse{
+		{
+			Error: err,
+		},
+	}
+
+	return NewMockESClient(responses)
+}