test(end2end): update tests, remove mock data

Signed-off-by: Reza Mobaraki <rezam578@gmail.com>

delivery/http_server/end2end/benefactor_address_test.go

@@ -7,7 +7,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"git.gocasts.ir/ebhomengo/niki/delivery/http_server/end2end/setup"
-	"git.gocasts.ir/ebhomengo/niki/entity"
 	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"
@@ -42,18 +41,7 @@ func (suite *BenefactorAddressTestSuit) SetupTest() {
 	suite.getAllExpected = map[string]interface{}{
 		"count": 1,
 	}
-	suite.getExpected = addressparam.GetAddressResponse{
+
-		Address: entity.Address{
-			ID:           suite.addressID,
-			PostalCode:   "3719655861",
-			Address:      "tehran sare koche 1",
-			Lat:          35.632508,
-			Lon:          51.452859,
-			Name:         "home1",
-			CityID:       8,
-			BenefactorID: suite.benefactorID,
-		},
-	}
 	suite.createData = addressparam.BenefactorAddAddressRequest{
 		PostalCode: "3719655861",
 		Address:    "create shiraz kaf sharo",
@@ -72,10 +60,9 @@ func (suite *BenefactorAddressTestSuit) SetupTest() {
 	}
 }
 
-// TestBenefactorAddressGet tests the GET /address/:id endpoint
 func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGet() {
 	token := LoginBenefactor(suite.benefactorPhone)
-	url := fmt.Sprintf("/address/%d", suite.addressID)
+	url := fmt.Sprintf("/benefactors/addresses/%d", suite.addressID)
 
 	suite.T().Run("Success", func(t *testing.T) {
 		responseRecord := CreateRequest("GET", url, token, nil)
@@ -84,13 +71,17 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGet() {
 		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().Equal(suite.addressID, response.Address.ID)
+		suite.Require().NoError(sErr, "failed to get benefactor address")
-		suite.Require().Equal(suite.benefactorID, response.Address.BenefactorID)
+		suite.Require().Equal(address.Data.PostalCode, response.Data.PostalCode)
-		suite.Require().Equal(suite.getExpected.Address.PostalCode, response.Address.PostalCode)
+		suite.Require().Equal(address.Data.Address, response.Data.Address)
-		suite.Require().Equal(suite.getExpected.Address.Address, response.Address.Address)
+		suite.Require().Equal(address.Data.Name, response.Data.Name)
-		suite.Require().Equal(suite.getExpected.Address.Name, response.Address.Name)
+		suite.Require().Equal(address.Data.CityID, response.Data.CityID)
-		suite.Require().Equal(suite.getExpected.Address.CityID, response.Address.CityID)
 	})
 
 	suite.T().Run("Failure_Unauthorized", func(t *testing.T) {
@@ -99,10 +90,9 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGet() {
 	})
 }
 
-// TestBenefactorAddressGetAll tests the GET /address/ endpoint
 func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGetAll() {
 	token := LoginBenefactor(suite.benefactorPhone)
-	url := fmt.Sprintf("/address/")
+	url := fmt.Sprintf("/benefactors/addresses")
 
 	suite.T().Run("Success", func(t *testing.T) {
 		responseRecord := CreateRequest("GET", url, token, nil)
@@ -112,7 +102,7 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGetAll() {
 		err := json.NewDecoder(responseRecord.Body).Decode(&response)
 		suite.Require().NoError(err, "could not decode response body")
 
-		suite.Require().Equal(suite.getAllExpected["count"], len(response.AllAddresses))
+		suite.Require().Equal(suite.getAllExpected["count"], len(response.Data))
 	})
 
 	suite.T().Run("Failure_Unauthorized", func(t *testing.T) {
@@ -121,10 +111,9 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressGetAll() {
 	})
 }
 
-// TestBenefactorAddressCreate tests the POST /address/ endpoint
 func (suite *BenefactorAddressTestSuit) TestBenefactorAddressCreate() {
 	token := LoginBenefactor(suite.benefactorPhone)
-	url := fmt.Sprintf("/address/")
+	url := fmt.Sprintf("/benefactors/addresses")
 
 	suite.T().Run("Success", func(t *testing.T) {
 		responseRecord := CreateRequest("POST", url, token, suite.createData)
@@ -134,11 +123,11 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressCreate() {
 		err := json.NewDecoder(responseRecord.Body).Decode(&response)
 		suite.Require().NoError(err, "could not decode response body")
 
-		suite.Require().Equal(suite.benefactorID, response.Address.BenefactorID)
+		suite.Require().Equal(suite.benefactorID, response.Data.BenefactorID)
-		suite.Require().Equal(suite.createData.Address, response.Address.Address)
+		suite.Require().Equal(suite.createData.Address, response.Data.Address)
-		suite.Require().Equal(suite.createData.PostalCode, response.Address.PostalCode)
+		suite.Require().Equal(suite.createData.PostalCode, response.Data.PostalCode)
-		suite.Require().Equal(suite.createData.Name, response.Address.Name)
+		suite.Require().Equal(suite.createData.Name, response.Data.Name)
-		suite.Require().Equal(suite.createData.CityID, response.Address.CityID)
+		suite.Require().Equal(suite.createData.CityID, response.Data.CityID)
 	})
 
 	suite.T().Run("Failure_BadRequest", func(t *testing.T) {
@@ -147,13 +136,12 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressCreate() {
 	})
 }
 
-// TestBenefactorAddressUpdate tests the PATCH /address/:id endpoint
 func (suite *BenefactorAddressTestSuit) TestBenefactorAddressUpdate() {
 	token := LoginBenefactor(suite.benefactorPhone)
-	url := fmt.Sprintf("/address/%d", suite.addressID)
+	url := fmt.Sprintf("/benefactors/addresses/%d", suite.addressID)
 
 	suite.T().Run("Success", func(t *testing.T) {
-		responseRecord := CreateRequest("PATCH", url, token, suite.updateData)
+		responseRecord := CreateRequest("PUT", url, token, suite.updateData)
 		suite.Require().Equal(http.StatusNoContent, responseRecord.Code)
 
 		updatedAddress, sErr := services.BenefactorAddressSvc.Get(context.Background(),
@@ -163,14 +151,14 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressUpdate() {
 			})
 		suite.Require().NoError(sErr, "failed to get benefactor address")
 
-		suite.Require().Equal(suite.updateData.PostalCode, updatedAddress.Address.PostalCode)
+		suite.Require().Equal(suite.updateData.PostalCode, updatedAddress.Data.PostalCode)
-		suite.Require().Equal(suite.updateData.Address, updatedAddress.Address.Address)
+		suite.Require().Equal(suite.updateData.Address, updatedAddress.Data.Address)
-		suite.Require().Equal(suite.updateData.Name, updatedAddress.Address.Name)
+		suite.Require().Equal(suite.updateData.Name, updatedAddress.Data.Name)
-		suite.Require().Equal(suite.updateData.CityID, updatedAddress.Address.CityID)
+		suite.Require().Equal(suite.updateData.CityID, updatedAddress.Data.CityID)
 	})
 
 	suite.T().Run("Failure_Unauthorized", func(t *testing.T) {
-		responseRecord := CreateRequest("PATCH", url, "", suite.updateData) // No token provided
+		responseRecord := CreateRequest("PUT", url, "", suite.updateData) // No token provided
 		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
 	})
 }
@@ -178,7 +166,7 @@ func (suite *BenefactorAddressTestSuit) TestBenefactorAddressUpdate() {
 // TestBenefactorAddressDelete tests the DELETE /address/:id endpoint
 func (suite *BenefactorAddressTestSuit) TestBenefactorAddressDelete() {
 	token := LoginBenefactor(suite.benefactorPhone)
-	url := fmt.Sprintf("/address/%d", suite.addressID)
+	url := fmt.Sprintf("/benefactors/addresses/%d", suite.addressID)
 
 	suite.T().Run("Success", func(t *testing.T) {
 		responseRecord := CreateRequest("DELETE", url, token, nil)

delivery/http_server/end2end/benefactor_kindboxes_test.go

@@ -3,15 +3,14 @@
 package end2end
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"git.gocasts.ir/ebhomengo/niki/delivery/http_server/end2end/setup"
-	"git.gocasts.ir/ebhomengo/niki/entity"
 	benefactorkindboxparam "git.gocasts.ir/ebhomengo/niki/param/benefactor/kind_box"
 	"github.com/stretchr/testify/suite"
 	"net/http"
 	"testing"
-	"time"
 )
 
 type BenefactorKindBoxTestSuite struct {
@@ -31,49 +30,29 @@ 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,
 	}
-	suite.kindBoxGetExpected = benefactorkindboxparam.KindBoxGetResponse{
-		KindBox: entity.KindBox{
-			ID:                 suite.kindBoxID,
-			KindBoxReqID:       1,
-			BenefactorID:       1,
-			KindBoxType:        "on-table",
-			Amount:             0,
-			SerialNumber:       "serial-1",
-			Status:             "delivered",
-			DeliverReferTimeID: 1,
-			DeliverReferDate:   time.Now().AddDate(0, 0, 7).UTC(),
-			DeliverAddressID:   1,
-			SenderAgentID:      1,
-			DeliveredAt:        time.Now().AddDate(0, 0, 7).UTC(),
-			ReturnReferTimeID:  0,
-			ReturnReferDate:    time.Time{},
-			ReturnAddressID:    0,
-			ReceiverAgentID:    0,
-			ReturnedAt:         time.Time{},
-		},
-	}
 }
 
 // Test for GET /benefactor/kindboxes (Get All Kind Boxes)
 func (suite *BenefactorKindBoxTestSuite) TestBenefactorKindBoxGetAll() {
 	suite.Run("Success", func() {
 		token := LoginBenefactor(suite.benefactorPhone)
-		url := fmt.Sprintf("/benefactor/kindboxes")
+		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.AllKindBox))
+		suite.Require().Equal(suite.kindBboxGetAllExpected["count"], len(response.Data))
 	})
 
 	suite.Run("Failure_Unauthorized", func() {
-		url := fmt.Sprintf("/benefactor/kindboxes")
+		url := fmt.Sprintf("/benefactors/kindboxes")
 		responseRecord := CreateRequest("GET", url, "invalid_token", nil)
 		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
 	})
@@ -83,7 +62,7 @@ func (suite *BenefactorKindBoxTestSuite) TestBenefactorKindBoxGetAll() {
 func (suite *BenefactorKindBoxTestSuite) TestBenefactorKindBoxGet() {
 	suite.Run("Success", func() {
 		token := LoginBenefactor(suite.benefactorPhone)
-		url := fmt.Sprintf("/benefactor/kindboxes/%d", suite.kindBoxID)
+		url := fmt.Sprintf("/benefactors/kindboxes/%d", suite.kindBoxID)
 		responseRecord := CreateRequest("GET", url, token, nil)
 		suite.Require().Equal(http.StatusOK, responseRecord.Code)
 
@@ -91,40 +70,35 @@ func (suite *BenefactorKindBoxTestSuite) TestBenefactorKindBoxGet() {
 		err := json.NewDecoder(responseRecord.Body).Decode(&response)
 		suite.Require().NoError(err, "could not decode response body")
 
-		suite.assertKindBoxFields(suite.kindBoxGetExpected.KindBox, response.KindBox)
+		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("/benefactor/kindboxes/%d", 9999) // Non-existent ID
+		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("/benefactor/kindboxes/%d", suite.kindBoxID)
+		url := fmt.Sprintf("/benefactors/kindboxes/%d", suite.kindBoxID)
 		responseRecord := CreateRequest("GET", url, "invalid_token", nil)
 		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
 	})
 }
-
-// Helper method to assert all fields of KindBox
-func (suite *BenefactorKindBoxTestSuite) assertKindBoxFields(expected, actual entity.KindBox) {
-	suite.Require().Equal(expected.ID, actual.ID, "ID should match")
-	suite.Require().Equal(expected.KindBoxReqID, actual.KindBoxReqID, "KindBoxReqID should match")
-	suite.Require().Equal(expected.BenefactorID, actual.BenefactorID, "BenefactorID should match")
-	suite.Require().Equal(expected.KindBoxType, actual.KindBoxType, "KindBoxType should match")
-	suite.Require().Equal(expected.Amount, actual.Amount, "Amount should match")
-	suite.Require().Equal(expected.SerialNumber, actual.SerialNumber, "SerialNumber should match")
-	suite.Require().Equal(expected.Status, actual.Status, "Status should match")
-	suite.Require().Equal(expected.DeliverReferTimeID, actual.DeliverReferTimeID, "DeliverReferTimeID should match")
-	suite.Require().Equal(expected.DeliverReferDate.Format("2006-01-02"), actual.DeliverReferDate.Format("2006-01-02"), "DeliverReferDate should match")
-	suite.Require().Equal(expected.DeliverAddressID, actual.DeliverAddressID, "DeliverAddressID should match")
-	suite.Require().Equal(expected.SenderAgentID, actual.SenderAgentID, "SenderAgentID should match")
-	suite.Require().Equal(expected.DeliveredAt.Format("2006-01-02"), actual.DeliveredAt.Format("2006-01-02"), "DeliveredAt should match")
-	suite.Require().Equal(expected.ReturnReferTimeID, actual.ReturnReferTimeID, "ReturnReferTimeID should match")
-	suite.Require().Equal(expected.ReturnReferDate.Format("2006-01-02"), actual.ReturnReferDate.Format("2006-01-02"), "ReturnReferDate should match")
-	suite.Require().Equal(expected.ReturnAddressID, actual.ReturnAddressID, "ReturnAddressID should match")
-	suite.Require().Equal(expected.ReceiverAgentID, actual.ReceiverAgentID, "ReceiverAgentID should match")
-	suite.Require().Equal(expected.ReturnedAt.Format("2006-01-02"), actual.ReturnedAt.Format("2006-01-02"), "ReturnedAt should match")
-}

delivery/http_server/end2end/benefactor_kindboxreqs_test.go

@@ -24,7 +24,6 @@ type BenefactorKindBoxReqsTestSuite struct {
 	benefactorID    uint
 	kindBoxReqID    uint
 	getAllExpected  map[string]interface{}
-	getExpected     map[string]interface{}
 	createData      benefactorkindboxreqparam.KindBoxReqAddRequest
 	updateData      benefactorkindboxreqparam.KindBoxReqUpdateRequest
 }
@@ -45,13 +44,6 @@ func (suite *BenefactorKindBoxReqsTestSuite) SetupTest() {
 		"count": 5,
 	}
 
-	suite.getExpected = map[string]interface{}{
-		"kind_box_type":      entity.KindBoxOnTable,
-		"deliver_address":    uint(1),
-		"deliver_refer_date": time.Now().AddDate(0, 0, 7).UTC(),
-		"deliver_refer_time": uint(1),
-	}
-
 	suite.createData = benefactorkindboxreqparam.KindBoxReqAddRequest{
 		KindBoxType:        entity.KindBoxCylindrical,
 		DeliverAddressID:   uint(1),
@@ -73,7 +65,7 @@ func (suite *BenefactorKindBoxReqsTestSuite) SetupTest() {
 func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_GetAll_Success() {
 	suite.Run("Success", func() {
 		token := LoginBenefactor(suite.benefactorPhone)
-		url := fmt.Sprintf("/benefactor/kindboxreqs/")
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
 		responseRecord := CreateRequest(http.MethodGet, url, token, nil)
 		suite.Require().Equal(http.StatusOK, responseRecord.Code)
 
@@ -81,11 +73,11 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_GetAll_Su
 		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.AllKindBoxReq))
+		assert.Equal(suite.T(), suite.getAllExpected["count"], len(response.Data))
 	})
 
 	suite.Run("Failure_Unauthorized", func() {
-		url := fmt.Sprintf("/benefactor/kindboxreqs/")
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
 		responseRecord := CreateRequest(http.MethodGet, url, "invalid_token", nil)
 		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
 	})
@@ -94,7 +86,7 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_GetAll_Su
 func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Get_Success() {
 	suite.Run("Success", func() {
 		token := LoginBenefactor(suite.benefactorPhone)
-		url := fmt.Sprintf("/benefactor/kindboxreqs/%d", suite.kindBoxReqID)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
 		responseRecord := CreateRequest(http.MethodGet, url, token, nil)
 		suite.Require().Equal(http.StatusOK, responseRecord.Code)
 
@@ -102,26 +94,29 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Get_Succe
 		err := json.NewDecoder(responseRecord.Body).Decode(&response)
 		suite.Require().NoError(err, "failed to decode response body")
 
-		assert.Equal(suite.T(), suite.kindBoxReqID, response.KindBoxReq.ID)
+		kinBoxReq, err := services.BenefactorKindBoxReqSvc.Get(context.Background(),
-		assert.Equal(suite.T(), suite.getExpected["kind_box_type"], response.KindBoxReq.KindBoxType)
+			benefactorkindboxreqparam.KindBoxReqGetRequest{
-		assert.Equal(suite.T(), suite.getExpected["deliver_address"], response.KindBoxReq.DeliverAddressID)
+				BenefactorID: suite.benefactorID,
-		assert.Equal(
+				KindBoxReqID: suite.kindBoxReqID,
-			suite.T(),
+			})
-			suite.getExpected["deliver_refer_date"].(time.Time).Format("2006-01-02"),
+
-			response.KindBoxReq.DeliverReferDate.Format("2006-01-02"),
+		suite.Require().NoError(err, "failed to get kind box request")
-		)
+		assert.Equal(suite.T(), kinBoxReq.Data.KindBoxType, response.Data.KindBoxType)
-		assert.Equal(suite.T(), suite.getExpected["deliver_refer_time"], response.KindBoxReq.DeliverReferTimeID)
+		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("/benefactor/kindboxreqs/%d", 9999) // Non-existent ID
+		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("/benefactor/kindboxreqs/%d", suite.kindBoxReqID)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
 		responseRecord := CreateRequest(http.MethodGet, url, "invalid_token", nil)
 		suite.Require().Equal(http.StatusUnauthorized, responseRecord.Code)
 	})
@@ -130,7 +125,7 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Get_Succe
 func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Create_Success() {
 	suite.Run("Success", func() {
 		token := LoginBenefactor(suite.benefactorPhone)
-		url := fmt.Sprintf("/benefactor/kindboxreqs/")
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
 		rec := CreateRequest(http.MethodPost, url, token, suite.createData)
 		suite.Require().Equal(http.StatusCreated, rec.Code)
 
@@ -138,14 +133,14 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Create_Su
 		err := json.NewDecoder(rec.Body).Decode(&response)
 		suite.Require().NoError(err, "failed to decode response body")
 
-		assert.Equal(suite.T(), suite.createData.KindBoxType, response.KindBoxReq.KindBoxType)
+		assert.Equal(suite.T(), suite.createData.KindBoxType, response.Data.KindBoxType)
-		assert.Equal(suite.T(), suite.createData.DeliverAddressID, response.KindBoxReq.DeliverAddressID)
+		assert.Equal(suite.T(), suite.createData.DeliverAddressID, response.Data.DeliverAddressID)
-		assert.Equal(suite.T(), suite.createData.DeliverReferDate, response.KindBoxReq.DeliverReferDate)
+		assert.Equal(suite.T(), suite.createData.DeliverReferDate, response.Data.DeliverReferDate)
-		assert.Equal(suite.T(), suite.createData.CountRequested, response.KindBoxReq.CountRequested)
+		assert.Equal(suite.T(), suite.createData.CountRequested, response.Data.CountRequested)
 	})
 
 	suite.Run("Failure_Unauthorized", func() {
-		url := fmt.Sprintf("/benefactor/kindboxreqs/")
+		url := fmt.Sprintf("/benefactors/kindboxreqs")
 		rec := CreateRequest(http.MethodPost, url, "invalid_token", suite.createData)
 		suite.Require().Equal(http.StatusUnauthorized, rec.Code)
 	})
@@ -154,7 +149,7 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Create_Su
 func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Update_Success() {
 	suite.Run("Success", func() {
 		token := LoginBenefactor(suite.benefactorPhone)
-		url := fmt.Sprintf("/benefactor/kindboxreqs/%d", suite.kindBoxReqID)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
 		rec := CreateRequest(http.MethodPut, url, token, suite.updateData)
 		suite.Require().Equal(http.StatusNoContent, rec.Code)
 
@@ -166,20 +161,19 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Update_Su
 		)
 		suite.Require().NoError(err, "failed to get kind box request")
 
-		assert.Equal(suite.T(), suite.updateData.KindBoxType, kindBoxReq.KindBoxType)
+		assert.Equal(suite.T(), suite.updateData.CountRequested, kindBoxReq.Data.CountRequested)
-		assert.Equal(suite.T(), suite.updateData.CountRequested, kindBoxReq.CountRequested)
+		assert.Equal(suite.T(), suite.updateData.Description, kindBoxReq.Data.Description)
-		assert.Equal(suite.T(), suite.updateData.Description, kindBoxReq.Description)
+		assert.Equal(suite.T(), suite.updateData.DeliverReferTimeID, kindBoxReq.Data.DeliverReferTimeID)
-		assert.Equal(suite.T(), suite.updateData.DeliverReferTimeID, kindBoxReq.DeliverReferTimeID)
 		assert.Equal(
 			suite.T(),
 			suite.updateData.DeliverReferDate.Format("2006-01-02"),
-			kindBoxReq.DeliverReferDate.Format("2006-01-02"),
+			kindBoxReq.Data.DeliverReferDate.Format("2006-01-02"),
 		)
-		assert.Equal(suite.T(), suite.updateData.DeliverAddressID, kindBoxReq.DeliverAddressID)
+		assert.Equal(suite.T(), suite.updateData.DeliverAddressID, kindBoxReq.Data.DeliverAddressID)
 	})
 
 	suite.Run("Failure_Unauthorized", func() {
-		url := fmt.Sprintf("/benefactor/kindboxreqs/%d", suite.kindBoxReqID)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
 		rec := CreateRequest(http.MethodPut, url, "invalid_token", suite.updateData)
 		suite.Require().Equal(http.StatusUnauthorized, rec.Code)
 	})
@@ -188,7 +182,7 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Update_Su
 func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Delete_Success() {
 	suite.Run("Success", func() {
 		token := LoginBenefactor(suite.benefactorPhone)
-		url := fmt.Sprintf("/benefactor/kindboxreqs/%d", suite.kindBoxReqID)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
 		rec := CreateRequest(http.MethodDelete, url, token, nil)
 		suite.Require().Equal(http.StatusOK, rec.Code)
 
@@ -205,7 +199,7 @@ func (suite *BenefactorKindBoxReqsTestSuite) TestBenefactorKindBoxReqs_Delete_Su
 	})
 
 	suite.Run("Failure_Unauthorized", func() {
-		url := fmt.Sprintf("/benefactor/kindboxreqs/%d", suite.kindBoxReqID)
+		url := fmt.Sprintf("/benefactors/kindboxreqs/%d", suite.kindBoxReqID)
 		rec := CreateRequest(http.MethodDelete, url, "invalid_token", nil)
 		suite.Require().Equal(http.StatusUnauthorized, rec.Code)
 	})