Merge pull request #344 from gofr-dev/development

Release v1.0.1

Author: Vipul Rawat

examples/http-server-using-redis/main_test.go

@@ -2,11 +2,21 @@ package main
 
 import (
 	"bytes"
+	"context"
+
 	"net/http"
 	"testing"
 	"time"
 
+	"github.com/go-redis/redismock/v9"
 	"github.com/stretchr/testify/assert"
+
+	"gofr.dev/pkg/gofr"
+	"gofr.dev/pkg/gofr/container"
+	"gofr.dev/pkg/gofr/datasource/redis"
+	gofrHTTP "gofr.dev/pkg/gofr/http"
+	"gofr.dev/pkg/gofr/logging"
+	"gofr.dev/pkg/gofr/testutil"
 )
 
 func TestHTTPServerUsingRedis(t *testing.T) {
@@ -41,3 +51,50 @@ func TestHTTPServerUsingRedis(t *testing.T) {
 		assert.Equal(t, tc.statusCode, resp.StatusCode, "TEST[%d], Failed.\n%s", i, tc.desc)
 	}
 }
+
+func TestRedisSetHandler(t *testing.T) {
+	a := gofr.New()
+	logger := logging.NewLogger(logging.DEBUG)
+	redisClient, mock := redismock.NewClientMock()
+
+	rc := redis.NewClient(testutil.NewMockConfig(map[string]string{"REDIS_HOST": "localhost", "REDIS_PORT": "2001"}), logger, a.Metrics())
+	rc.Client = redisClient
+
+	mock.ExpectSet("key", "value", 5*time.Minute).SetErr(testutil.CustomError{ErrorMessage: "redis get error"})
+
+	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://localhost:5000/handle", bytes.NewBuffer([]byte(`{"key":"value"}`)))
+
+	gofrReq := gofrHTTP.NewRequest(req)
+
+	ctx := &gofr.Context{Context: context.Background(),
+		Request: gofrReq, Container: &container.Container{Logger: logger, Redis: rc}}
+
+	resp, err := RedisSetHandler(ctx)
+
+	assert.Nil(t, resp)
+	assert.NotNil(t, err)
+}
+
+func TestRedisPipelineHandler(t *testing.T) {
+	a := gofr.New()
+	logger := logging.NewLogger(logging.DEBUG)
+	redisClient, mock := redismock.NewClientMock()
+
+	rc := redis.NewClient(testutil.NewMockConfig(map[string]string{"REDIS_HOST": "localhost", "REDIS_PORT": "2001"}), logger, a.Metrics())
+	rc.Client = redisClient
+
+	mock.ExpectSet("testKey1", "testValue1", time.Minute*5).SetErr(testutil.CustomError{ErrorMessage: "redis get error"})
+	mock.ClearExpect()
+
+	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://localhost:5000/handle", bytes.NewBuffer([]byte(`{"key":"value"}`)))
+
+	gofrReq := gofrHTTP.NewRequest(req)
+
+	ctx := &gofr.Context{Context: context.Background(),
+		Request: gofrReq, Container: &container.Container{Logger: logger, Redis: rc}}
+
+	resp, err := RedisPipelineHandler(ctx)
+
+	assert.Nil(t, resp)
+	assert.NotNil(t, err)
+}

examples/http-server/README.md

@@ -11,11 +11,9 @@ docker run --name gofr-redis -p 2002:6379 -d redis:7.0.5
 
 - Run the docker image of mysql
 ```console
-docker run --name gofr-mysql -e MYSQL_ROOT_PASSWORD=password -p 2001:3306 -d mysql:8.0.30
+docker run --name gofr-mysql -e MYSQL_ROOT_PASSWORD=password -e MYSQL_DATABASE=test -p 2001:3306 -d mysql:8.0.30
 ```
 
-NOTE: Please create a DB named `test` as mentioned in `DB_NAME` using above mysql image.
-
 - Now run the example
 ```console
 go run main.go

examples/http-server/main_test.go

@@ -1,14 +1,22 @@
 package main
 
 import (
+	"context"
 	"net/http"
 	"testing"
 	"time"
 
+	"github.com/go-redis/redismock/v9"
 	"github.com/stretchr/testify/assert"
+
+	"gofr.dev/pkg/gofr"
+	"gofr.dev/pkg/gofr/container"
+	"gofr.dev/pkg/gofr/datasource/redis"
+	"gofr.dev/pkg/gofr/logging"
+	"gofr.dev/pkg/gofr/testutil"
 )
 
-func TestSimpleAPIServer(t *testing.T) {
+func TestIntegration_SimpleAPIServer(t *testing.T) {
 	const host = "http://localhost:9000"
 	go main()
 	time.Sleep(time.Second * 3) // Giving some time to start the server
@@ -39,3 +47,22 @@ func TestSimpleAPIServer(t *testing.T) {
 		assert.Equal(t, tc.statusCode, resp.StatusCode, "TEST[%d], Failed.\n%s", i, tc.desc)
 	}
 }
+
+func TestRedisHandler(t *testing.T) {
+	a := gofr.New()
+	logger := logging.NewLogger(logging.DEBUG)
+	redisClient, mock := redismock.NewClientMock()
+
+	rc := redis.NewClient(testutil.NewMockConfig(map[string]string{"REDIS_HOST": "localhost", "REDIS_PORT": "2001"}), logger, a.Metrics())
+	rc.Client = redisClient
+
+	mock.ExpectGet("test").SetErr(testutil.CustomError{ErrorMessage: "redis get error"})
+
+	ctx := &gofr.Context{Context: context.Background(),
+		Request: nil, Container: &container.Container{Logger: logger, Redis: rc}}
+
+	resp, err := RedisHandler(ctx)
+
+	assert.Nil(t, resp)
+	assert.NotNil(t, err)
+}

examples/using-custom-metrics/configs/.env

@@ -1,4 +1,6 @@
+HTTP_PORT=9011
+
 APP_NAME=using-metrics
 APP_VERSION=v0.1.0
 
-METRICS_PORT=2121
+METRICS_PORT=2120

examples/using-custom-metrics/main_test.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"io"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIntegration(t *testing.T) {
+	const host = "http://localhost:9011"
+	go main()
+	time.Sleep(time.Second * 1) // Giving some time to start the server
+
+	c := http.Client{}
+
+	req, _ := http.NewRequest("POST", host+"/transaction", nil)
+
+	_, err := c.Do(req)
+	if err != nil {
+		t.Fatalf("request to /transaction failed %v", err)
+	}
+
+	req, _ = http.NewRequest("POST", host+"/return", nil)
+
+	_, err = c.Do(req)
+	if err != nil {
+		t.Fatalf("request to /transaction failed %v", err)
+	}
+
+	req, _ = http.NewRequest("GET", "http://localhost:2120/metrics", nil)
+
+	resp, err := c.Do(req)
+	if err != nil {
+		t.Fatalf("request to localhost:2120/metrics failed %v", err)
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+
+	strBody := string(body)
+
+	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, "transaction_time")
+}

examples/using-http-service/main_test.go

@@ -1,12 +1,21 @@
 package main
 
 import (
+	"bytes"
+	"context"
 	"io"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+
+	"gofr.dev/pkg/gofr"
+	"gofr.dev/pkg/gofr/container"
+	gofrHTTP "gofr.dev/pkg/gofr/http"
+	"gofr.dev/pkg/gofr/logging"
+	"gofr.dev/pkg/gofr/service"
 )
 
 func Test_main(t *testing.T) {
@@ -54,3 +63,46 @@ func Test_main(t *testing.T) {
 		resp.Body.Close()
 	}
 }
+
+func TestHTTPHandlerURLError(t *testing.T) {
+	logger := logging.NewLogger(logging.DEBUG)
+
+	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://localhost:5000/handle", bytes.NewBuffer([]byte(`{"key":"value"}`)))
+
+	gofrReq := gofrHTTP.NewRequest(req)
+
+	ctx := &gofr.Context{Context: context.Background(),
+		Request: gofrReq, Container: &container.Container{Logger: logger}}
+
+	ctx.Container.Services = map[string]service.HTTP{"cat-facts": service.NewHTTPService("http://invalid", ctx.Logger, nil)}
+
+	resp, err := Handler(ctx)
+
+	assert.Nil(t, resp)
+	assert.NotNil(t, err)
+}
+
+func TestHTTPHandlerResponseUnmarshalError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// read request body
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(`{invalid body}`))
+	}))
+	defer server.Close()
+
+	logger := logging.NewLogger(logging.DEBUG)
+
+	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://localhost:5000/handle", bytes.NewBuffer([]byte(`{"key":"value"}`)))
+
+	gofrReq := gofrHTTP.NewRequest(req)
+
+	ctx := &gofr.Context{Context: context.Background(),
+		Request: gofrReq, Container: &container.Container{Logger: logger}}
+
+	ctx.Container.Services = map[string]service.HTTP{"cat-facts": service.NewHTTPService(server.URL, ctx.Logger, nil)}
+
+	resp, err := Handler(ctx)
+
+	assert.Nil(t, resp)
+	assert.NotNil(t, err)
+}

examples/using-migrations/main.go

@@ -43,14 +43,10 @@ func GetHandler(c *gofr.Context) (interface{}, error) {
 		return nil, errors.New("name can't be empty")
 	}
 
-	row := c.SQL.QueryRowContext(c, queryGetEmployee, name)
-	if row.Err() != nil {
-		return nil, errors.New(fmt.Sprintf("DB Error : %v", row.Err()))
-	}
-
 	var emp Employee
 
-	err := row.Scan(&emp.ID, &emp.Name, &emp.Gender, &emp.Phone, &emp.DOB)
+	err := c.SQL.QueryRowContext(c, queryGetEmployee, name).
+		Scan(&emp.ID, &emp.Name, &emp.Gender, &emp.Phone, &emp.DOB)
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("DB Error : %v", err))
 	}
@@ -68,10 +64,9 @@ func PostHandler(c *gofr.Context) (interface{}, error) {
 
 	// Execute the INSERT query
 	_, err := c.SQL.ExecContext(c, queryInsertEmployee, emp.ID, emp.Name, emp.Gender, emp.Phone, emp.DOB)
-
 	if err != nil {
 		return Employee{}, errors.New(fmt.Sprintf("DB Error : %v", err))
 	}
 
-	return fmt.Sprintf("succesfully posted entity : %v", emp.Name), nil
+	return fmt.Sprintf("successfully posted entity : %v", emp.Name), nil
 }

examples/using-migrations/main_test.go

@@ -24,9 +24,12 @@ func TestExampleMigration(t *testing.T) {
 		{"post new employee with valid data", http.MethodPost, "/employee",
 			[]byte(`{"id":2,"name":"John","gender":"Male","contact_number":1234567890,"dob":"2000-01-01"}`), 200},
 		{"get employee with valid name", http.MethodGet, "/employee?name=John", nil, 200},
+		{"get employee does not exist", http.MethodGet, "/employee?name=Invalid", nil, 500},
 		{"get employee with empty name", http.MethodGet, "/employee", nil, http.StatusInternalServerError},
 		{"post new employee with invalid data", http.MethodPost, "/employee", []byte(`{"id":2"}`),
 			http.StatusInternalServerError},
+		{"post new employee with invalid gender", http.MethodPost, "/employee",
+			[]byte(`{"id":2,"name":"John","gender":"Male123","contact_number":1234567890,"dob":"2000-01-01"}`), 500},
 	}
 
 	for i, tc := range tests {

examples/using-migrations/readme.md

@@ -6,7 +6,7 @@ This GoFr example demonstrates the use of `migrations` through a simple http ser
 - Run the docker image of mysql and redis
 
 ```console
-docker run --name gofr-mysql -e MYSQL_ROOT_PASSWORD=password -p 2001:3306 -d mysql:8.0.30
+docker run --name gofr-mysql -e MYSQL_ROOT_PASSWORD=password -e MYSQL_DATABASE=test -p 2001:3306 -d mysql:8.0.30
 docker run --name gofr-redis -p 2002:6379 -d redis:7.0.5
 ```
 

examples/using-publisher/main.go

@@ -2,13 +2,16 @@ package main
 
 import (
 	"encoding/json"
+	"fmt"
 
 	"gofr.dev/pkg/gofr"
 )
 
 func main() {
 	app := gofr.New()
 
+	fmt.Println(app.Config.Get("PUBSUB_BROKER"))
+
 	app.POST("/publish-order", order)
 
 	app.POST("/publish-product", product)