Merge branch 'development' into patch-1

Author: aryanmehrotra

CONTRIBUTING.md

@@ -3,18 +3,18 @@
   files a PR. This is only suitable for really small changes like: spelling fixes, variable name changes or error string
   change etc. For larger commits, following steps are recommended.
 * (Optional) If you want to discuss your implementation with the users of GoFr, use the GitHub discussions of this repo.
-* Configure your editor to use goimport and golangci-lint on file changes. Any code which is not formatted using these
+* Configure your editor to use goimports and golangci-lint on file changes. Any code which is not formatted using these
   tools, will fail on the pipeline.
 * Contributors should begin working on an issue only after it has been assigned to them. To get an issue assigned, please comment on the GitHub thread
   and request assignment from a maintainer. This helps avoid duplicate or conflicting pull requests from multiple contributors.
 * Issues labeled triage are not open for direct contributions. If you're interested in working on a triage issue, please reach out to the maintainers
-  to discuss it before proceeding in the Github thread.
+  to discuss it before proceeding in the GitHub thread.
 <!-- spellchecker:off "favour" have to be ignored here -->
 * We follow **American English** conventions in this project (e.g., *"favor"* instead of *"favour"*). Please keep this consistent across all code comments, documentation, etc.
 <!-- spellchecker:on -->
-* All code contributions should have associated tests and all new line additions should be covered in those testcases.
+* All code contributions should have associated tests and all new line additions should be covered in those test cases.
   No PR should ever decrease the overall code coverage.
-* Once your code changes are done along with the testcases, submit a PR to development branch. Please note that all PRs
+* Once your code changes are done along with the test cases, submit a PR to development branch. Please note that all PRs
   are merged from feature branches to development first.
 * PR should be raised only when development is complete and the code is ready for review. This approach helps reduce the number of open pull requests and facilitates a more efficient review process for the team.
 * All PRs need to be reviewed by at least 2 GoFr developers. They might reach out to you for any clarification.
@@ -50,7 +50,6 @@ func TestFunctionName(t *testing.T) {
 ```
 
 
-
 4. **Table-Driven Tests:**
 
 -   Consider using table-driven tests for testing multiple scenarios.
@@ -61,6 +60,8 @@ func TestFunctionName(t *testing.T) {
 ```console
 docker run --name mongodb -d -p 27017:27017 -e MONGO_INITDB_ROOT_USERNAME=user -e MONGO_INITDB_ROOT_PASSWORD=password mongodb/mongodb-community-server:latest
 docker run -d -p 21:21 -p 21000-21010:21000-21010 -e USERS='user|password' delfer/alpine-ftp-server
+```
+
 # the docker image is relatively unstable. Alternatively, refer to official guide of OpenTSDB to locally setup OpenTSDB env.
 # http://opentsdb.net/docs/build/html/installation.html#id1
 docker run -d --name gofr-opentsdb -p 4242:4242 petergrace/opentsdb-docker:latest

examples/http-server/main_test.go

@@ -5,20 +5,24 @@ import (
 	"encoding/json"
 	"io"
 	"net/http"
+	"net/http/httptest"
 	"os"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/go-redis/redismock/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 
 	"gofr.dev/pkg/gofr"
 	"gofr.dev/pkg/gofr/config"
 	"gofr.dev/pkg/gofr/container"
 	"gofr.dev/pkg/gofr/datasource/redis"
 	"gofr.dev/pkg/gofr/logging"
+	"gofr.dev/pkg/gofr/service"
 	"gofr.dev/pkg/gofr/testutil"
 )
 
@@ -140,7 +144,7 @@ func TestIntegration_SimpleAPIServer_Health(t *testing.T) {
 		statusCode int
 	}{
 		{"health handler", "/.well-known/health", http.StatusOK}, // Health check should be added by the framework.
-		{"favicon handler", "/favicon.ico", http.StatusOK},       //Favicon should be added by the framework.
+		{"favicon handler", "/favicon.ico", http.StatusOK},       // Favicon should be added by the framework.
 	}
 
 	for i, tc := range tests {
@@ -180,3 +184,140 @@ func TestRedisHandler(t *testing.T) {
 	assert.Nil(t, resp)
 	require.Error(t, err)
 }
+
+// MockRequest implements the Request interface for testing
+type MockRequest struct {
+	*http.Request
+	params map[string]string
+}
+
+func (m *MockRequest) HostName() string {
+	if m.Request != nil {
+		return m.Request.Host
+	}
+
+	return ""
+}
+
+func (m *MockRequest) Params(s string) []string {
+	if m.Request != nil {
+		return m.Request.URL.Query()[s]
+	}
+
+	return nil
+}
+
+func NewMockRequest(req *http.Request) *MockRequest {
+	// Parse query parameters
+	queryParams := make(map[string]string)
+	for k, v := range req.URL.Query() {
+		if len(v) > 0 {
+			queryParams[k] = v[0]
+		}
+	}
+
+	return &MockRequest{
+		Request: req,
+		params:  queryParams,
+	}
+}
+
+// Param returns URL query parameters
+func (m *MockRequest) Param(key string) string {
+	return m.params[key]
+}
+
+// PathParam returns URL path parameters
+func (m *MockRequest) PathParam(key string) string {
+	return ""
+}
+
+// Bind implements the Bind method required by the Request interface
+func (m *MockRequest) Bind(i any) error {
+	return nil
+}
+
+// createTestContext sets up a GoFr context for unit tests with a given URL and optional mock container.
+func createTestContext(method, url string, mockContainer *container.Container) *gofr.Context {
+	req := httptest.NewRequest(method, url, nil)
+	mockReq := NewMockRequest(req)
+
+	var c *container.Container
+	if mockContainer != nil {
+		c = mockContainer
+	} else {
+		c = &container.Container{Logger: logging.NewLogger(logging.DEBUG)}
+	}
+
+	logger := c.Logger
+
+	return &gofr.Context{
+		Context:       req.Context(),
+		Request:       mockReq,
+		Container:     c,
+		ContextLogger: *logging.NewContextLogger(req.Context(), logger),
+	}
+}
+
+func TestHelloHandler(t *testing.T) {
+	// With name parameter
+	ctx := createTestContext(http.MethodGet, "/hello?name=test", nil)
+	resp, err := HelloHandler(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, "Hello test!", resp)
+
+	// Without name parameter
+	ctx = createTestContext(http.MethodGet, "/hello", nil)
+	resp, err = HelloHandler(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, "Hello World!", resp)
+}
+
+func TestErrorHandler(t *testing.T) {
+	ctx := createTestContext(http.MethodGet, "/error", nil)
+
+	resp, err := ErrorHandler(ctx)
+	assert.Nil(t, resp)
+	assert.Error(t, err)
+	assert.Equal(t, "some error occurred", err.Error())
+}
+
+func TestMysqlHandler(t *testing.T) {
+	mockContainer, mocks := container.NewMockContainer(t)
+
+	// Setup SQL mock to return 4
+	mocks.SQL.ExpectQuery("select 2+2").
+		WillReturnRows(mocks.SQL.NewRows([]string{"value"}).AddRow(4))
+
+	ctx := createTestContext(http.MethodGet, "/mysql", mockContainer)
+
+	resp, err := MysqlHandler(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, 4, resp)
+}
+
+func TestTraceHandler(t *testing.T) {
+	mockContainer, mocks := container.NewMockContainer(t, container.WithMockHTTPService())
+
+	// Redis expectations
+	mocks.Redis.EXPECT().Ping(gomock.Any()).Return(nil).Times(5)
+
+	// HTTP service mock
+	httpService := mocks.HTTPService
+	mockResp := &http.Response{
+		StatusCode: http.StatusOK,
+		Body:       io.NopCloser(strings.NewReader(`{"data":"mock data"}`)),
+	}
+	httpService.EXPECT().Get(gomock.Any(), "redis", gomock.Any()).Return(mockResp, nil)
+
+	// Attach service to container
+	mockContainer.Services = map[string]service.HTTP{
+		"anotherService": httpService,
+	}
+
+	ctx := createTestContext(http.MethodGet, "/trace", mockContainer)
+
+	resp, err := TraceHandler(ctx)
+	assert.NoError(t, err)
+	assert.Equal(t, "mock data", resp)
+}

examples/sample-cmd/main_test.go

@@ -98,16 +98,76 @@ func TestCMDRun_ProgressContextCancelled(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
 
-	// add an already canceled context
+	// Create a proper context with logger to avoid nil pointer dereference
+	container := &container.Container{
+		Logger: logging.NewMockLogger(logging.ERROR),
+	}
+	
 	res, err := progress(&gofr.Context{
-		Context: ctx,
-		Request: cmd.NewRequest([]string{"command", "spinner"}),
-		Container: &container.Container{
-			Logger: logging.NewMockLogger(logging.ERROR),
-		},
-		Out: terminal.New(),
+		Context:       ctx,
+		Request:       cmd.NewRequest([]string{"command", "progress"}),
+		Container:     container,
+		Out:           terminal.New(),
+		ContextLogger: *logging.NewContextLogger(ctx, container.Logger),
 	})
 
 	assert.Empty(t, res)
 	assert.ErrorIs(t, err, context.Canceled)
 }
+
+// TestCMDRunWithInvalidCommand tests that invalid commands return appropriate error
+func TestCMDRunWithInvalidCommand(t *testing.T) {
+	expErr := "No Command Found!\n"
+	os.Args = []string{"command", "invalid"}
+	output := testutil.StderrOutputForFunc(main)
+
+	assert.Equal(t, expErr, output, "TEST Failed.\n")
+}
+
+// TestCMDRunWithEmptyParams tests the params command with empty name parameter
+func TestCMDRunWithEmptyParams(t *testing.T) {
+	expResp := "Hello !\n"
+	os.Args = []string{"command", "params", "-name="}
+	output := testutil.StdoutOutputForFunc(main)
+
+	assert.Contains(t, output, expResp, "TEST Failed.\n")
+}
+
+// TestCMDRunHelpCommand tests the help functionality
+func TestCMDRunHelpCommand(t *testing.T) {
+	testCases := []struct {
+		args     []string
+		expected []string
+	}{
+		{[]string{"command", "help"}, []string{"Available commands:", "hello", "params", "spinner", "progress"}},
+		{[]string{"command", "-h"}, []string{"Available commands:", "hello", "params", "spinner", "progress"}},
+		{[]string{"command", "--help"}, []string{"Available commands:", "hello", "params", "spinner", "progress"}},
+	}
+
+	for i, tc := range testCases {
+		os.Args = tc.args
+		output := testutil.StdoutOutputForFunc(main)
+
+		for _, expected := range tc.expected {
+			assert.Contains(t, output, expected, "TEST[%d] Failed. Expected to contain: %s\n", i, expected)
+		}
+	}
+}
+
+// TestCMDRunHelpForSpecificCommand tests help for specific commands
+func TestCMDRunHelpForSpecificCommand(t *testing.T) {
+	testCases := []struct {
+		args     []string
+		expected string
+	}{
+		{[]string{"command", "hello", "-h"}, "hello world option"},
+		{[]string{"command", "hello", "--help"}, "hello world option"},
+	}
+
+	for i, tc := range testCases {
+		os.Args = tc.args
+		output := testutil.StdoutOutputForFunc(main)
+
+		assert.Contains(t, output, tc.expected, "TEST[%d] Failed.\n", i)
+	}
+}

examples/using-custom-metrics/main_test.go

@@ -54,9 +54,9 @@ func TestIntegration(t *testing.T) {
 
 	assert.Equal(t, http.StatusOK, resp.StatusCode, "TEST[%d], Failed.\n%s")
 
-	assert.Contains(t, strBody, `product_stock{otel_scope_name="using-metrics",otel_scope_version="v0.1.0"} 50`)
-	assert.Contains(t, strBody, `total_credit_day_sale{otel_scope_name="using-metrics",otel_scope_version="v0.1.0",sale_type="credit"} 1000`)
-	assert.Contains(t, strBody, `total_credit_day_sale{otel_scope_name="using-metrics",otel_scope_version="v0.1.0",sale_type="credit_return"} -1000`)
-	assert.Contains(t, strBody, `transaction_success_total{otel_scope_name="using-metrics",otel_scope_version="v0.1.0"} 1`)
+	assert.Contains(t, strBody, `product_stock{otel_scope_name="using-metrics",otel_scope_schema_url="",otel_scope_version="v0.1.0"} 50`)
+	assert.Contains(t, strBody, `total_credit_day_sale{otel_scope_name="using-metrics",otel_scope_schema_url="",otel_scope_version="v0.1.0",sale_type="credit"} 1000`)
+	assert.Contains(t, strBody, `total_credit_day_sale{otel_scope_name="using-metrics",otel_scope_schema_url="",otel_scope_version="v0.1.0",sale_type="credit_return"} -1000`)
+	assert.Contains(t, strBody, `transaction_success{otel_scope_name="using-metrics",otel_scope_schema_url="",otel_scope_version="v0.1.0"} 1`)
 	assert.Contains(t, strBody, "transaction_time")
 }

examples/using-http-service/main_test.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 
 	"gofr.dev/pkg/gofr"
 	"gofr.dev/pkg/gofr/container"
@@ -82,12 +83,15 @@ func TestHTTPHandlerURLError(t *testing.T) {
 		fmt.Sprint("http://localhost:", port, "/handle"), bytes.NewBuffer([]byte(`{"key":"value"}`)))
 	gofrReq := gofrHTTP.NewRequest(req)
 
-	mockContainer, _ := container.NewMockContainer(t)
+	mockContainer, mocks := container.NewMockContainer(t)
 
 	ctx := &gofr.Context{Context: context.Background(), Request: gofrReq, Container: mockContainer}
 
 	ctx.Container.Services = map[string]service.HTTP{"cat-facts": service.NewHTTPService("http://invalid", ctx.Logger, mockContainer.Metrics())}
 
+	mocks.Metrics.EXPECT().RecordHistogram(gomock.Any(), "app_http_service_response", gomock.Any(), gomock.Any(),
+		"http://invalid", "method", "GET", "status", gomock.Any())
+
 	resp, err := Handler(ctx)
 
 	assert.Nil(t, resp)