Merge pull request 'Benefactor Tests: Address, Kind box requests, benefactor' (#149) from stage/rezoo/e2e-test/benefactor into develop

Reviewed-on: ebhomengo/niki#149

Makefile

@@ -1,7 +1,9 @@
-// TODO: add commands for build and run in dev/produciton mode
+# TODO: add commands for build and run in dev/produciton mode
 
 ROOT=$(realpath $(dir $(lastword $(MAKEFILE_LIST))))
 
+.PHONY: help confirm lint test format build run docker swagger watch migrate/status migrate/new migrate/up migrate/down
+
 confirm:
 	@echo -n 'Are you sure? [y/N] ' && read ans && [ $${ans:-N} = y ]
 

delivery/http_server/end2end/benefactor_address_test.go

@@ -0,0 +1,192 @@
+//go:build end2end
+
+package end2end
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"git.gocasts.ir/ebhomengo/niki/delivery/http_server/end2end/setup"
+	addressparam "git.gocasts.ir/ebhomengo/niki/param/benefactor/address"
+	errmsg "git.gocasts.ir/ebhomengo/niki/pkg/err_msg"
+	httpmsg "git.gocasts.ir/ebhomengo/niki/pkg/http_msg"
+	"github.com/stretchr/testify/suite"
+	"net/http"
+	"testing"
+)
+
+type BenefactorAddressTestSuit struct {
+	suite.Suite
+	benefactorPhone string
+	benefactorID    uint
+	addressID       uint
+	getAllExpected  map[string]interface{}
+	getExpected     addressparam.GetAddressResponse
+	createData      addressparam.BenefactorAddAddressRequest
+	updateData      addressparam.UpdateAddressRequest
+	teardown        func()
+}
+
+func TestBenefactorAddressTestSuit(t *testing.T) {
+	suite.Run(t, new(BenefactorAddressTestSuit))
+}
+
+// SetupTest runs before each test in the suite
+func (suite *BenefactorAddressTestSuit) SetupTest() {
+	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
+	suite.T().Cleanup(teardown)
+	suite.benefactorPhone = "09384664404"
+	suite.benefactorID = 1
+	suite.addressID = 1
+	suite.getAllExpected = map[string]interface{}{
+		"count": 1,
+	}
+
+	suite.createData = addressparam.BenefactorAddAddressRequest{
+		PostalCode: "3719655861",
+		Address:    "create shiraz kaf sharo",
+		Lat:        29.62949,
+		Lon:        52.497287,
+		CityID:     194,
+		Name:       "create shiraz",
+	}
+	suite.updateData = addressparam.UpdateAddressRequest{
+		PostalCode: "3719655861",
+		Address:    "update shiraz kaf sharo",
+		Lat:        29.62949,
+		Lon:        52.497287,
+		CityID:     194,
+		Name:       "update shiraz",
+	}
+}
+
+func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGet() {
+	token := LoginBenefactor(suite.benefactorPhone)
+	url := fmt.Sprintf("/benefactors/addresses/%d", suite.addressID)
+
+	suite.T().Run("Success", func(t *testing.T) {
+		responseRecord := CreateRequest("GET", url, token, nil)
+		suite.Require().Equal(http.StatusOK, responseRecord.Code)
+
+		var response addressparam.GetAddressResponse
+		err := json.NewDecoder(responseRecord.Body).Decode(&response)
+		suite.Require().NoError(err, "could not decode response body")
+		address, sErr := services.BenefactorAddressSvc.Get(context.Background(),
+			addressparam.GetAddressRequest{
+				AddressID:    suite.addressID,
+				BenefactorID: suite.benefactorID,
+			})
+
+		suite.Require().NoError(sErr, "failed to get benefactor address")
+		suite.Require().Equal(address.Data.PostalCode, response.Data.PostalCode)
+		suite.Require().Equal(address.Data.Address, response.Data.Address)
+		suite.Require().Equal(address.Data.Name, response.Data.Name)
+		suite.Require().Equal(address.Data.CityID, response.Data.CityID)
+	})
+
+	suite.T().Run("Failure_Unauthorized", func(t *testing.T) {
+		responseRecord := CreateRequest("GET", url, "", nil) // No token provided
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}
+
+func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGetAll() {
+	token := LoginBenefactor(suite.benefactorPhone)
+	url := fmt.Sprintf("/benefactors/addresses")
+
+	suite.T().Run("Success", func(t *testing.T) {
+		responseRecord := CreateRequest("GET", url, token, nil)
+		suite.Require().Equal(http.StatusOK, responseRecord.Code)
+
+		var response addressparam.GetAllAddressesResponse
+		err := json.NewDecoder(responseRecord.Body).Decode(&response)
+		suite.Require().NoError(err, "could not decode response body")
+
+		suite.Require().Equal(suite.getAllExpected["count"], len(response.Data))
+	})
+
+	suite.T().Run("Failure_Unauthorized", func(t *testing.T) {
+		responseRecord := CreateRequest("GET", url, "", nil) // No token provided
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}
+
+func (suite *BenefactorAddressTestSuit) TestBenefactorAddressCreate() {
+	token := LoginBenefactor(suite.benefactorPhone)
+	url := fmt.Sprintf("/benefactors/addresses")
+
+	suite.T().Run("Success", func(t *testing.T) {
+		responseRecord := CreateRequest("POST", url, token, suite.createData)
+		suite.Require().Equal(http.StatusCreated, responseRecord.Code)
+
+		var response addressparam.BenefactorAddAddressResponse
+		err := json.NewDecoder(responseRecord.Body).Decode(&response)
+		suite.Require().NoError(err, "could not decode response body")
+
+		suite.Require().Equal(suite.benefactorID, response.Data.BenefactorID)
+		suite.Require().Equal(suite.createData.Address, response.Data.Address)
+		suite.Require().Equal(suite.createData.PostalCode, response.Data.PostalCode)
+		suite.Require().Equal(suite.createData.Name, response.Data.Name)
+		suite.Require().Equal(suite.createData.CityID, response.Data.CityID)
+	})
+
+	suite.T().Run("Failure_BadRequest", func(t *testing.T) {
+		responseRecord := CreateRequest("POST", url, token, nil) // No data provided
+		suite.Require().Equal(http.StatusUnprocessableEntity, responseRecord.Code)
+	})
+}
+
+func (suite *BenefactorAddressTestSuit) TestBenefactorAddressUpdate() {
+	token := LoginBenefactor(suite.benefactorPhone)
+	url := fmt.Sprintf("/benefactors/addresses/%d", suite.addressID)
+
+	suite.T().Run("Success", func(t *testing.T) {
+		responseRecord := CreateRequest("PUT", url, token, suite.updateData)
+		suite.Require().Equal(http.StatusNoContent, responseRecord.Code)
+
+		updatedAddress, sErr := services.BenefactorAddressSvc.Get(context.Background(),
+			addressparam.GetAddressRequest{
+				AddressID:    suite.addressID,
+				BenefactorID: suite.benefactorID,
+			})
+		suite.Require().NoError(sErr, "failed to get benefactor address")
+
+		suite.Require().Equal(suite.updateData.PostalCode, updatedAddress.Data.PostalCode)
+		suite.Require().Equal(suite.updateData.Address, updatedAddress.Data.Address)
+		suite.Require().Equal(suite.updateData.Name, updatedAddress.Data.Name)
+		suite.Require().Equal(suite.updateData.CityID, updatedAddress.Data.CityID)
+	})
+
+	suite.T().Run("Failure_Unauthorized", func(t *testing.T) {
+		responseRecord := CreateRequest("PUT", url, "", suite.updateData) // No token provided
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}
+
+// TestBenefactorAddressDelete tests the DELETE /address/:id endpoint
+func (suite *BenefactorAddressTestSuit) TestBenefactorAddressDelete() {
+	token := LoginBenefactor(suite.benefactorPhone)
+	url := fmt.Sprintf("/benefactors/addresses/%d", suite.addressID)
+
+	suite.T().Run("Success", func(t *testing.T) {
+		responseRecord := CreateRequest("DELETE", url, token, nil)
+		suite.Require().Equal(http.StatusNoContent, responseRecord.Code)
+
+		_, err := services.BenefactorAddressSvc.Get(context.Background(),
+			addressparam.GetAddressRequest{
+				AddressID:    suite.addressID,
+				BenefactorID: suite.benefactorID,
+			},
+		)
+		message, code := httpmsg.Error(err)
+		suite.Require().Error(err)
+
+		suite.Equal(http.StatusNotFound, code)
+		suite.Equal(errmsg.ErrorMsgNotFound, message)
+	})
+
+	suite.T().Run("Failure_Unauthorized", func(t *testing.T) {
+		responseRecord := CreateRequest("DELETE", url, "", nil) // No token provided
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}

delivery/http_server/end2end/benefactor_kindboxes_test.go

@@ -0,0 +1,104 @@
+//go:build end2end
+
+package end2end
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"git.gocasts.ir/ebhomengo/niki/delivery/http_server/end2end/setup"
+	benefactorkindboxparam "git.gocasts.ir/ebhomengo/niki/param/benefactor/kind_box"
+	"github.com/stretchr/testify/suite"
+	"net/http"
+	"testing"
+)
+
+type BenefactorKindBoxTestSuite struct {
+	suite.Suite
+	benefactorPhone        string
+	benefactorID           uint
+	kindBoxID              uint
+	kindBboxGetAllExpected map[string]interface{}
+	kindBoxGetExpected     benefactorkindboxparam.KindBoxGetResponse
+}
+
+func TestBenefactorKindBoxTestSuite(t *testing.T) {
+	suite.Run(t, new(BenefactorKindBoxTestSuite))
+}
+
+func (suite *BenefactorKindBoxTestSuite) SetupTest() {
+	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
+	suite.T().Cleanup(teardown)
+	suite.benefactorPhone = "09384664404"
+	suite.benefactorID = 1
+	suite.kindBoxID = 1
+	suite.kindBboxGetAllExpected = map[string]interface{}{
+		"count": 1,
+	}
+}
+
+// Test for GET /benefactor/kindboxes (Get All Kind Boxes)
+func (suite *BenefactorKindBoxTestSuite) TestBenefactorKindBoxGetAll() {
+	suite.Run("Success", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxes")
+		responseRecord := CreateRequest("GET", url, token, nil)
+		suite.Require().Equal(http.StatusOK, responseRecord.Code)
+
+		var response benefactorkindboxparam.KindBoxGetAllResponse
+		err := json.NewDecoder(responseRecord.Body).Decode(&response)
+		suite.Require().NoError(err, "could not decode response")
+		suite.Require().Equal(suite.kindBboxGetAllExpected["count"], len(response.Data))
+	})
+
+	suite.Run("Failure_Unauthorized", func() {
+		url := fmt.Sprintf("/benefactors/kindboxes")
+		responseRecord := CreateRequest("GET", url, "invalid_token", nil)
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}
+
+// Test for GET /benefactor/kindboxes/:id (Get Single Kind Box)
+func (suite *BenefactorKindBoxTestSuite) TestBenefactorKindBoxGet() {
+	suite.Run("Success", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxes/%d", suite.kindBoxID)
+		responseRecord := CreateRequest("GET", url, token, nil)
+		suite.Require().Equal(http.StatusOK, responseRecord.Code)
+
+		var response benefactorkindboxparam.KindBoxGetResponse
+		err := json.NewDecoder(responseRecord.Body).Decode(&response)
+		suite.Require().NoError(err, "could not decode response body")
+
+		kindBox, sErr := services.BenefactorKindBoxSvc.Get(context.Background(),
+			benefactorkindboxparam.KindBoxGetRequest{
+				BenefactorID: suite.benefactorID,
+				KindBoxID:    suite.kindBoxID,
+			})
+		suite.Require().NoError(sErr, "failed to get benefactor kind box")
+
+		suite.Require().Equal(kindBox.Data.ID, response.Data.ID)
+		suite.Require().Equal(kindBox.Data.KindBoxReqID, response.Data.KindBoxReqID)
+		suite.Require().Equal(kindBox.Data.BenefactorID, response.Data.BenefactorID)
+		suite.Require().Equal(kindBox.Data.KindBoxType, response.Data.KindBoxType)
+		suite.Require().Equal(kindBox.Data.Amount, response.Data.Amount)
+		suite.Require().Equal(kindBox.Data.SerialNumber, response.Data.SerialNumber)
+		suite.Require().Equal(kindBox.Data.Status, response.Data.Status)
+		suite.Require().Equal(kindBox.Data.DeliverReferTimeID, response.Data.DeliverReferTimeID)
+		suite.Require().Equal(kindBox.Data.DeliverReferDate, response.Data.DeliverReferDate)
+
+	})
+
+	suite.Run("Failure_NotFound", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxes/%d", 9999) // Non-existent ID
+		responseRecord := CreateRequest("GET", url, token, nil)
+		suite.Require().Equal(http.StatusUnprocessableEntity, responseRecord.Code)
+	})
+
+	suite.Run("Failure_Unauthorized", func() {
+		url := fmt.Sprintf("/benefactors/kindboxes/%d", suite.kindBoxID)
+		responseRecord := CreateRequest("GET", url, "invalid_token", nil)
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}

delivery/http_server/end2end/benefactor_kindboxreqs_test.go

@@ -0,0 +1,206 @@
+//go:build end2end
+
+package end2end
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"git.gocasts.ir/ebhomengo/niki/delivery/http_server/end2end/setup"
+	"git.gocasts.ir/ebhomengo/niki/entity"
+	benefactorkindboxreqparam "git.gocasts.ir/ebhomengo/niki/param/benefactor/kind_box_req"
+	errmsg "git.gocasts.ir/ebhomengo/niki/pkg/err_msg"
+	httpmsg "git.gocasts.ir/ebhomengo/niki/pkg/http_msg"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"net/http"
+	"testing"
+	"time"
+)
+
+type BenefactorKindBoxReqsTestSuite struct {
+	suite.Suite
+	benefactorPhone string
+	benefactorID    uint
+	kindBoxReqID    uint
+	getAllExpected  map[string]interface{}
+	createData      benefactorkindboxreqparam.KindBoxReqAddRequest
+	updateData      benefactorkindboxreqparam.KindBoxReqUpdateRequest
+}
+
+func TestBenefactorKindBoxReqsTestSuite(t *testing.T) {
+	suite.Run(t, new(BenefactorKindBoxReqsTestSuite))
+}
+
+func (suite *BenefactorKindBoxReqsTestSuite) SetupTest() {
+	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
+	suite.T().Cleanup(teardown)
+
+	suite.benefactorPhone = "09384664404"
+	suite.benefactorID = uint(1)
+	suite.kindBoxReqID = uint(1)
+
+	suite.getAllExpected = map[string]interface{}{
+		"count": 5,
+	}
+
+	suite.createData = benefactorkindboxreqparam.KindBoxReqAddRequest{
+		KindBoxType:        entity.KindBoxCylindrical,
+		DeliverAddressID:   uint(1),
+		DeliverReferDate:   time.Now().AddDate(0, 0, 7).UTC(),
+		DeliverReferTimeID: uint(1),
+		CountRequested:     uint(5),
+	}
+
+	suite.updateData = benefactorkindboxreqparam.KindBoxReqUpdateRequest{
+		KindBoxType:        entity.KindBoxCylindrical,
+		CountRequested:     uint(10),
+		Description:        "updated description",
+		DeliverReferTimeID: uint(1),
+		DeliverReferDate:   time.Now().AddDate(0, 0, 7).UTC(),
+		DeliverAddressID:   uint(1),
+	}
+}
+
+func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_GetAll_Success() {
+	suite.Run("Success", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
+		responseRecord := CreateRequest(http.MethodGet, url, token, nil)
+		suite.Require().Equal(http.StatusOK, responseRecord.Code)
+
+		var response benefactorkindboxreqparam.GetAllResponse
+		err := json.NewDecoder(responseRecord.Body).Decode(&response)
+		suite.Require().NoError(err, "failed to decode response body")
+
+		assert.Equal(suite.T(), suite.getAllExpected["count"], len(response.Data))
+	})
+
+	suite.Run("Failure_Unauthorized", func() {
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
+		responseRecord := CreateRequest(http.MethodGet, url, "invalid_token", nil)
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}
+
+func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Get_Success() {
+	suite.Run("Success", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
+		responseRecord := CreateRequest(http.MethodGet, url, token, nil)
+		suite.Require().Equal(http.StatusOK, responseRecord.Code)
+
+		var response benefactorkindboxreqparam.KindBoxReqGetResponse
+		err := json.NewDecoder(responseRecord.Body).Decode(&response)
+		suite.Require().NoError(err, "failed to decode response body")
+
+		kinBoxReq, err := services.BenefactorKindBoxReqSvc.Get(context.Background(),
+			benefactorkindboxreqparam.KindBoxReqGetRequest{
+				BenefactorID: suite.benefactorID,
+				KindBoxReqID: suite.kindBoxReqID,
+			})
+
+		suite.Require().NoError(err, "failed to get kind box request")
+		assert.Equal(suite.T(), kinBoxReq.Data.KindBoxType, response.Data.KindBoxType)
+		assert.Equal(suite.T(), kinBoxReq.Data.CountRequested, response.Data.CountRequested)
+		assert.Equal(suite.T(), kinBoxReq.Data.Description, response.Data.Description)
+		assert.Equal(suite.T(), kinBoxReq.Data.DeliverReferTimeID, response.Data.DeliverReferTimeID)
+
+	})
+
+	suite.Run("Failure_NotFound", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", 9999) // Non-existent ID
+		responseRecord := CreateRequest(http.MethodGet, url, token, nil)
+		suite.Require().Equal(http.StatusNotFound, responseRecord.Code)
+	})
+
+	suite.Run("Failure_Unauthorized", func() {
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
+		responseRecord := CreateRequest(http.MethodGet, url, "invalid_token", nil)
+		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
+	})
+}
+
+func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Create_Success() {
+	suite.Run("Success", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
+		rec := CreateRequest(http.MethodPost, url, token, suite.createData)
+		suite.Require().Equal(http.StatusCreated, rec.Code)
+
+		var response benefactorkindboxreqparam.KindBoxReqAddResponse
+		err := json.NewDecoder(rec.Body).Decode(&response)
+		suite.Require().NoError(err, "failed to decode response body")
+
+		assert.Equal(suite.T(), suite.createData.KindBoxType, response.Data.KindBoxType)
+		assert.Equal(suite.T(), suite.createData.DeliverAddressID, response.Data.DeliverAddressID)
+		assert.Equal(suite.T(), suite.createData.DeliverReferDate, response.Data.DeliverReferDate)
+		assert.Equal(suite.T(), suite.createData.CountRequested, response.Data.CountRequested)
+	})
+
+	suite.Run("Failure_Unauthorized", func() {
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
+		rec := CreateRequest(http.MethodPost, url, "invalid_token", suite.createData)
+		suite.Require().Equal(http.StatusUnauthorized, rec.Code)
+	})
+}
+
+func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Update_Success() {
+	suite.Run("Success", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
+		rec := CreateRequest(http.MethodPut, url, token, suite.updateData)
+		suite.Require().Equal(http.StatusNoContent, rec.Code)
+
+		kindBoxReq, err := services.BenefactorKindBoxReqSvc.Get(context.Background(),
+			benefactorkindboxreqparam.KindBoxReqGetRequest{
+				BenefactorID: suite.benefactorID,
+				KindBoxReqID: suite.kindBoxReqID,
+			},
+		)
+		suite.Require().NoError(err, "failed to get kind box request")
+
+		assert.Equal(suite.T(), suite.updateData.CountRequested, kindBoxReq.Data.CountRequested)
+		assert.Equal(suite.T(), suite.updateData.Description, kindBoxReq.Data.Description)
+		assert.Equal(suite.T(), suite.updateData.DeliverReferTimeID, kindBoxReq.Data.DeliverReferTimeID)
+		assert.Equal(
+			suite.T(),
+			suite.updateData.DeliverReferDate.Format("2006-01-02"),
+			kindBoxReq.Data.DeliverReferDate.Format("2006-01-02"),
+		)
+		assert.Equal(suite.T(), suite.updateData.DeliverAddressID, kindBoxReq.Data.DeliverAddressID)
+	})
+
+	suite.Run("Failure_Unauthorized", func() {
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
+		rec := CreateRequest(http.MethodPut, url, "invalid_token", suite.updateData)
+		suite.Require().Equal(http.StatusUnauthorized, rec.Code)
+	})
+}
+
+func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Delete_Success() {
+	suite.Run("Success", func() {
+		token := LoginBenefactor(suite.benefactorPhone)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
+		rec := CreateRequest(http.MethodDelete, url, token, nil)
+		suite.Require().Equal(http.StatusOK, rec.Code)
+
+		_, err := services.BenefactorKindBoxReqSvc.Get(context.Background(),
+			benefactorkindboxreqparam.KindBoxReqGetRequest{
+				BenefactorID: suite.benefactorID,
+				KindBoxReqID: suite.kindBoxReqID,
+			},
+		)
+		message, code := httpmsg.Error(err)
+		suite.Require().Error(err)
+		assert.Equal(suite.T(), http.StatusNotFound, code)
+		assert.Equal(suite.T(), errmsg.ErrorMsgNotFound, message)
+	})
+
+	suite.Run("Failure_Unauthorized", func() {
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
+		rec := CreateRequest(http.MethodDelete, url, "invalid_token", nil)
+		suite.Require().Equal(http.StatusUnauthorized, rec.Code)
+	})
+}

delivery/http_server/end2end/request_helper_test.go

@@ -0,0 +1,53 @@
+//go:build end2end
+
+package end2end
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	param "git.gocasts.ir/ebhomengo/niki/param/benefactor/benefactor"
+	"github.com/labstack/echo/v4"
+	"log"
+	"net/http/httptest"
+)
+
+// CreateRequest is a utility function to create and send HTTP requests
+func CreateRequest(method, url, token string, body interface{}) *httptest.ResponseRecorder {
+	var buf bytes.Buffer
+	if body != nil {
+		err := json.NewEncoder(&buf).Encode(body)
+		if err != nil {
+			log.Fatalf("could not encode body: %v", err)
+		}
+	}
+
+	req := httptest.NewRequest(method, url, &buf)
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	req.Header.Set(echo.HeaderAuthorization, fmt.Sprintf("Bearer %s", token))
+
+	rec := httptest.NewRecorder()
+	testServer.Serve(rec, req)
+	return rec
+}
+
+// LoginBenefactor is a utility function to login a benefactor and return the access token
+func LoginBenefactor(phoneNumber string) string {
+	sendOTPRes, err := services.BenefactorSvc.SendOtp(context.Background(), param.SendOtpRequest{
+		PhoneNumber: phoneNumber,
+	})
+	if err != nil {
+		log.Fatalf("failed to send OTP: %v", err)
+	}
+
+	registerRes, err := services.BenefactorSvc.LoginOrRegister(context.Background(), param.LoginOrRegisterRequest{
+		PhoneNumber:      phoneNumber,
+		VerificationCode: sendOTPRes.Code,
+	})
+	if err != nil {
+		log.Fatalf("failed to register: %v", err)
+	}
+
+	return registerRes.Tokens.AccessToken
+}

vendor/github.com/stretchr/testify/require/doc.go

@@ -0,0 +1,29 @@
+// Package require implements the same assertions as the `assert` package but
+// stops test execution when a test fails.
+//
+// # Example Usage
+//
+// The following is a complete example using require in a standard test function:
+//
+//	import (
+//	  "testing"
+//	  "github.com/stretchr/testify/require"
+//	)
+//
+//	func TestSomething(t *testing.T) {
+//
+//	  var a string = "Hello"
+//	  var b string = "Hello"
+//
+//	  require.Equal(t, a, b, "The two words should be the same.")
+//
+//	}
+//
+// # Assertions
+//
+// The `require` package have same global functions as in the `assert` package,
+// but instead of returning a boolean result they call `t.FailNow()`.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+package require

vendor/github.com/stretchr/testify/require/forward_requirements.go

@@ -0,0 +1,16 @@
+package require
+
+// Assertions provides assertion methods around the
+// TestingT interface.
+type Assertions struct {
+	t TestingT
+}
+
+// New makes a new Assertions object for the specified TestingT.
+func New(t TestingT) *Assertions {
+	return &Assertions{
+		t: t,
+	}
+}
+
+//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require_forward.go.tmpl -include-format-funcs"

vendor/github.com/stretchr/testify/require/require.go.tmpl

@@ -0,0 +1,6 @@
+{{.Comment}}
+func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
+	if h, ok := t.(tHelper); ok { h.Helper() }
+	if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return }
+	t.FailNow()
+}

vendor/github.com/stretchr/testify/require/require_forward.go.tmpl

@@ -0,0 +1,5 @@
+{{.CommentWithoutT "a"}}
+func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) {
+	if h, ok := a.t.(tHelper); ok { h.Helper() }
+	{{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
+}

vendor/github.com/stretchr/testify/require/requirements.go

@@ -0,0 +1,29 @@
+package require
+
+// TestingT is an interface wrapper around *testing.T
+type TestingT interface {
+	Errorf(format string, args ...interface{})
+	FailNow()
+}
+
+type tHelper interface {
+	Helper()
+}
+
+// ComparisonAssertionFunc is a common function prototype when comparing two values.  Can be useful
+// for table driven tests.
+type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{})
+
+// ValueAssertionFunc is a common function prototype when validating a single value.  Can be useful
+// for table driven tests.
+type ValueAssertionFunc func(TestingT, interface{}, ...interface{})
+
+// BoolAssertionFunc is a common function prototype when validating a bool value.  Can be useful
+// for table driven tests.
+type BoolAssertionFunc func(TestingT, bool, ...interface{})
+
+// ErrorAssertionFunc is a common function prototype when validating an error value.  Can be useful
+// for table driven tests.
+type ErrorAssertionFunc func(TestingT, error, ...interface{})
+
+//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require.go.tmpl -include-format-funcs"

vendor/github.com/stretchr/testify/suite/doc.go

@@ -0,0 +1,66 @@
+// Package suite contains logic for creating testing suite structs
+// and running the methods on those structs as tests.  The most useful
+// piece of this package is that you can create setup/teardown methods
+// on your testing suites, which will run before/after the whole suite
+// or individual tests (depending on which interface(s) you
+// implement).
+//
+// A testing suite is usually built by first extending the built-in
+// suite functionality from suite.Suite in testify.  Alternatively,
+// you could reproduce that logic on your own if you wanted (you
+// just need to implement the TestingSuite interface from
+// suite/interfaces.go).
+//
+// After that, you can implement any of the interfaces in
+// suite/interfaces.go to add setup/teardown functionality to your
+// suite, and add any methods that start with "Test" to add tests.
+// Methods that do not match any suite interfaces and do not begin
+// with "Test" will not be run by testify, and can safely be used as
+// helper methods.
+//
+// Once you've built your testing suite, you need to run the suite
+// (using suite.Run from testify) inside any function that matches the
+// identity that "go test" is already looking for (i.e.
+// func(*testing.T)).
+//
+// Regular expression to select test suites specified command-line
+// argument "-run". Regular expression to select the methods
+// of test suites specified command-line argument "-m".
+// Suite object has assertion methods.
+//
+// A crude example:
+//
+//	// Basic imports
+//	import (
+//	    "testing"
+//	    "github.com/stretchr/testify/assert"
+//	    "github.com/stretchr/testify/suite"
+//	)
+//
+//	// Define the suite, and absorb the built-in basic suite
+//	// functionality from testify - including a T() method which
+//	// returns the current testing context
+//	type ExampleTestSuite struct {
+//	    suite.Suite
+//	    VariableThatShouldStartAtFive int
+//	}
+//
+//	// Make sure that VariableThatShouldStartAtFive is set to five
+//	// before each test
+//	func (suite *ExampleTestSuite) SetupTest() {
+//	    suite.VariableThatShouldStartAtFive = 5
+//	}
+//
+//	// All methods that begin with "Test" are run as tests within a
+//	// suite.
+//	func (suite *ExampleTestSuite) TestExample() {
+//	    assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
+//	    suite.Equal(5, suite.VariableThatShouldStartAtFive)
+//	}
+//
+//	// In order for 'go test' to run this suite, we need to create
+//	// a normal test function and pass our suite to suite.Run
+//	func TestExampleTestSuite(t *testing.T) {
+//	    suite.Run(t, new(ExampleTestSuite))
+//	}
+package suite

vendor/github.com/stretchr/testify/suite/interfaces.go

@@ -0,0 +1,66 @@
+package suite
+
+import "testing"
+
+// TestingSuite can store and return the current *testing.T context
+// generated by 'go test'.
+type TestingSuite interface {
+	T() *testing.T
+	SetT(*testing.T)
+	SetS(suite TestingSuite)
+}
+
+// SetupAllSuite has a SetupSuite method, which will run before the
+// tests in the suite are run.
+type SetupAllSuite interface {
+	SetupSuite()
+}
+
+// SetupTestSuite has a SetupTest method, which will run before each
+// test in the suite.
+type SetupTestSuite interface {
+	SetupTest()
+}
+
+// TearDownAllSuite has a TearDownSuite method, which will run after
+// all the tests in the suite have been run.
+type TearDownAllSuite interface {
+	TearDownSuite()
+}
+
+// TearDownTestSuite has a TearDownTest method, which will run after
+// each test in the suite.
+type TearDownTestSuite interface {
+	TearDownTest()
+}
+
+// BeforeTest has a function to be executed right before the test
+// starts and receives the suite and test names as input
+type BeforeTest interface {
+	BeforeTest(suiteName, testName string)
+}
+
+// AfterTest has a function to be executed right after the test
+// finishes and receives the suite and test names as input
+type AfterTest interface {
+	AfterTest(suiteName, testName string)
+}
+
+// WithStats implements HandleStats, a function that will be executed
+// when a test suite is finished. The stats contain information about
+// the execution of that suite and its tests.
+type WithStats interface {
+	HandleStats(suiteName string, stats *SuiteInformation)
+}
+
+// SetupSubTest has a SetupSubTest method, which will run before each
+// subtest in the suite.
+type SetupSubTest interface {
+	SetupSubTest()
+}
+
+// TearDownSubTest has a TearDownSubTest method, which will run after
+// each subtest in the suite have been run.
+type TearDownSubTest interface {
+	TearDownSubTest()
+}

vendor/github.com/stretchr/testify/suite/stats.go

@@ -0,0 +1,46 @@
+package suite
+
+import "time"
+
+// SuiteInformation stats stores stats for the whole suite execution.
+type SuiteInformation struct {
+	Start, End time.Time
+	TestStats  map[string]*TestInformation
+}
+
+// TestInformation stores information about the execution of each test.
+type TestInformation struct {
+	TestName   string
+	Start, End time.Time
+	Passed     bool
+}
+
+func newSuiteInformation() *SuiteInformation {
+	testStats := make(map[string]*TestInformation)
+
+	return &SuiteInformation{
+		TestStats: testStats,
+	}
+}
+
+func (s SuiteInformation) start(testName string) {
+	s.TestStats[testName] = &TestInformation{
+		TestName: testName,
+		Start:    time.Now(),
+	}
+}
+
+func (s SuiteInformation) end(testName string, passed bool) {
+	s.TestStats[testName].End = time.Now()
+	s.TestStats[testName].Passed = passed
+}
+
+func (s SuiteInformation) Passed() bool {
+	for _, stats := range s.TestStats {
+		if !stats.Passed {
+			return false
+		}
+	}
+
+	return true
+}

vendor/github.com/stretchr/testify/suite/suite.go

@@ -0,0 +1,253 @@
+package suite
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"runtime/debug"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var allTestsFilter = func(_, _ string) (bool, error) { return true, nil }
+var matchMethod = flag.String("testify.m", "", "regular expression to select tests of the testify suite to run")
+
+// Suite is a basic testing suite with methods for storing and
+// retrieving the current *testing.T context.
+type Suite struct {
+	*assert.Assertions
+
+	mu      sync.RWMutex
+	require *require.Assertions
+	t       *testing.T
+
+	// Parent suite to have access to the implemented methods of parent struct
+	s TestingSuite
+}
+
+// T retrieves the current *testing.T context.
+func (suite *Suite) T() *testing.T {
+	suite.mu.RLock()
+	defer suite.mu.RUnlock()
+	return suite.t
+}
+
+// SetT sets the current *testing.T context.
+func (suite *Suite) SetT(t *testing.T) {
+	suite.mu.Lock()
+	defer suite.mu.Unlock()
+	suite.t = t
+	suite.Assertions = assert.New(t)
+	suite.require = require.New(t)
+}
+
+// SetS needs to set the current test suite as parent
+// to get access to the parent methods
+func (suite *Suite) SetS(s TestingSuite) {
+	suite.s = s
+}
+
+// Require returns a require context for suite.
+func (suite *Suite) Require() *require.Assertions {
+	suite.mu.Lock()
+	defer suite.mu.Unlock()
+	if suite.require == nil {
+		panic("'Require' must not be called before 'Run' or 'SetT'")
+	}
+	return suite.require
+}
+
+// Assert returns an assert context for suite.  Normally, you can call
+// `suite.NoError(expected, actual)`, but for situations where the embedded
+// methods are overridden (for example, you might want to override
+// assert.Assertions with require.Assertions), this method is provided so you
+// can call `suite.Assert().NoError()`.
+func (suite *Suite) Assert() *assert.Assertions {
+	suite.mu.Lock()
+	defer suite.mu.Unlock()
+	if suite.Assertions == nil {
+		panic("'Assert' must not be called before 'Run' or 'SetT'")
+	}
+	return suite.Assertions
+}
+
+func recoverAndFailOnPanic(t *testing.T) {
+	t.Helper()
+	r := recover()
+	failOnPanic(t, r)
+}
+
+func failOnPanic(t *testing.T, r interface{}) {
+	t.Helper()
+	if r != nil {
+		t.Errorf("test panicked: %v\n%s", r, debug.Stack())
+		t.FailNow()
+	}
+}
+
+// Run provides suite functionality around golang subtests.  It should be
+// called in place of t.Run(name, func(t *testing.T)) in test suite code.
+// The passed-in func will be executed as a subtest with a fresh instance of t.
+// Provides compatibility with go test pkg -run TestSuite/TestName/SubTestName.
+func (suite *Suite) Run(name string, subtest func()) bool {
+	oldT := suite.T()
+
+	return oldT.Run(name, func(t *testing.T) {
+		suite.SetT(t)
+		defer suite.SetT(oldT)
+
+		defer recoverAndFailOnPanic(t)
+
+		if setupSubTest, ok := suite.s.(SetupSubTest); ok {
+			setupSubTest.SetupSubTest()
+		}
+
+		if tearDownSubTest, ok := suite.s.(TearDownSubTest); ok {
+			defer tearDownSubTest.TearDownSubTest()
+		}
+
+		subtest()
+	})
+}
+
+// Run takes a testing suite and runs all of the tests attached
+// to it.
+func Run(t *testing.T, suite TestingSuite) {
+	defer recoverAndFailOnPanic(t)
+
+	suite.SetT(t)
+	suite.SetS(suite)
+
+	var suiteSetupDone bool
+
+	var stats *SuiteInformation
+	if _, ok := suite.(WithStats); ok {
+		stats = newSuiteInformation()
+	}
+
+	tests := []testing.InternalTest{}
+	methodFinder := reflect.TypeOf(suite)
+	suiteName := methodFinder.Elem().Name()
+
+	for i := 0; i < methodFinder.NumMethod(); i++ {
+		method := methodFinder.Method(i)
+
+		ok, err := methodFilter(method.Name)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "testify: invalid regexp for -m: %s\n", err)
+			os.Exit(1)
+		}
+
+		if !ok {
+			continue
+		}
+
+		if !suiteSetupDone {
+			if stats != nil {
+				stats.Start = time.Now()
+			}
+
+			if setupAllSuite, ok := suite.(SetupAllSuite); ok {
+				setupAllSuite.SetupSuite()
+			}
+
+			suiteSetupDone = true
+		}
+
+		test := testing.InternalTest{
+			Name: method.Name,
+			F: func(t *testing.T) {
+				parentT := suite.T()
+				suite.SetT(t)
+				defer recoverAndFailOnPanic(t)
+				defer func() {
+					t.Helper()
+
+					r := recover()
+
+					if stats != nil {
+						passed := !t.Failed() && r == nil
+						stats.end(method.Name, passed)
+					}
+
+					if afterTestSuite, ok := suite.(AfterTest); ok {
+						afterTestSuite.AfterTest(suiteName, method.Name)
+					}
+
+					if tearDownTestSuite, ok := suite.(TearDownTestSuite); ok {
+						tearDownTestSuite.TearDownTest()
+					}
+
+					suite.SetT(parentT)
+					failOnPanic(t, r)
+				}()
+
+				if setupTestSuite, ok := suite.(SetupTestSuite); ok {
+					setupTestSuite.SetupTest()
+				}
+				if beforeTestSuite, ok := suite.(BeforeTest); ok {
+					beforeTestSuite.BeforeTest(methodFinder.Elem().Name(), method.Name)
+				}
+
+				if stats != nil {
+					stats.start(method.Name)
+				}
+
+				method.Func.Call([]reflect.Value{reflect.ValueOf(suite)})
+			},
+		}
+		tests = append(tests, test)
+	}
+	if suiteSetupDone {
+		defer func() {
+			if tearDownAllSuite, ok := suite.(TearDownAllSuite); ok {
+				tearDownAllSuite.TearDownSuite()
+			}
+
+			if suiteWithStats, measureStats := suite.(WithStats); measureStats {
+				stats.End = time.Now()
+				suiteWithStats.HandleStats(suiteName, stats)
+			}
+		}()
+	}
+
+	runTests(t, tests)
+}
+
+// Filtering method according to set regular expression
+// specified command-line argument -m
+func methodFilter(name string) (bool, error) {
+	if ok, _ := regexp.MatchString("^Test", name); !ok {
+		return false, nil
+	}
+	return regexp.MatchString(*matchMethod, name)
+}
+
+func runTests(t testing.TB, tests []testing.InternalTest) {
+	if len(tests) == 0 {
+		t.Log("warning: no tests to run")
+		return
+	}
+
+	r, ok := t.(runner)
+	if !ok { // backwards compatibility with Go 1.6 and below
+		if !testing.RunTests(allTestsFilter, tests) {
+			t.Fail()
+		}
+		return
+	}
+
+	for _, test := range tests {
+		r.Run(test.Name, test.F)
+	}
+}
+
+type runner interface {
+	Run(name string, f func(t *testing.T)) bool
+}