diff --git a/internal/api/model/zbox.go b/internal/api/model/zbox.go index 95e397c98d..dfc0ad471f 100644 --- a/internal/api/model/zbox.go +++ b/internal/api/model/zbox.go @@ -1,6 +1,8 @@ package model import ( + "time" + "github.com/0chain/gosdk/core/common" "github.com/0chain/system_test/internal/api/util/test" resty "github.com/go-resty/resty/v2" @@ -16,6 +18,11 @@ type ZboxMessageResponse struct { Message string `json:"message"` } +type ZboxMessageDataResponse[T any] struct { + Message string `json:"message"` + Data T `json:"data"` +} + type ZboxMessageDataShareinfoResponse struct { Message string `json:"message"` Data []ZboxShareInfo `json:"data"` @@ -142,6 +149,19 @@ type ZboxShareInfo struct { UpdatedAt string `json:"UpdatedAt"` } +type ZboxShareRequest struct { + ID int64 + OwnerID string + ClientID string + LookupHash string + AuthTicket string + Message *string + Status uint8 + AppType int64 + CreatedAt time.Time + UpdatedAt time.Time +} + type ZboxNftCollection struct { AllocationId string `json:"allocation_id"` CollectionId string `json:"collection_id"` diff --git a/internal/api/util/client/zbox_client.go b/internal/api/util/client/zbox_client.go index c65f0155d5..bfa08a723c 100644 --- a/internal/api/util/client/zbox_client.go +++ b/internal/api/util/client/zbox_client.go @@ -23,6 +23,18 @@ const ( X_APP_CLIENT_ID_R = "bcf5f517be521e0ffdb22d1fc26a35abdec8556bcb9ed075244a358df7337cd0" X_APP_CLIENT_KEY_R = "de9351bbf460c761ea979764831759369ced3c6de38b856e7921eee9cc034323cce23c562c74a0629867fbea33d5009b9f473bc3b766871b65e7cf864ba4301d" X_APP_CLIENT_SIGNATURE_R = "43fa947257ae0b5da8b073f0efeaa2570c4faf66fcabd93407e3597bc34e440b" + + X_APP_USER_ID_B = "test_user_id_B" + X_APP_CLIENT_ID_B = "fc6ed0246c8bb4f7251acf521c81d7fdb3f042a7bb2234a032723c9bba8dda9b" + X_APP_CLIENT_KEY_B = "92843dc9dafc041e88b778356bf39533606911828d50f420fb24e0cc2dcc4b06a8ed6dc0f083c988bc8cc64c7525f943dff8d1ece4955e456c450d34faf8da12" + X_APP_CLIENT_SIGNATURE_B = "11648e1f79b90419166c13f09d9bdf15e32105591c1f94d461aa82c569480f17" + + X_APP_USER_ID_C = "test_user_id_C" + X_APP_CLIENT_ID_C = "d143d173905a34df21c9574511088af1498cc3bd25a19522dab4adc2b381247f" + X_APP_CLIENT_KEY_C = "081bcbb448e31be94d88325bbf89b03b1fffd95c9fc40d3da6826f6b86ad760e6db8726f801911595a029b9e63b81bba5df2b520c419ecaea610fe6e47f0688b" + X_APP_CLIENT_SIGNATURE_C = "e354bfef838ddf039dbe5d1570d721748ec2958ab70d7670a8e99bbd3c5a1309" + + X_APP_ID_TOKEN = "test_firebase_token" X_APP_TIMESTAMP = "123456789" X_APP_CSRF = "test_csrf_token" @@ -550,6 +562,25 @@ func (c *ZboxClient) GetShareInfoReceived(t *test.SystemTest, headers map[string return ZboxShareInfoList, resp, err } +func (c *ZboxClient) GetShareInfoReceivedWithParams(t *test.SystemTest, headers map[string]string, queryParams map[string]string) (*model.ZboxMessageDataShareinfoResponse, *resty.Response, error) { + t.Logf("Getting share Info for [%v] using 0box...", headers["X-App-User-ID"]) + var ZboxShareInfoList *model.ZboxMessageDataShareinfoResponse + + urlBuilder := NewURLBuilder() + err := urlBuilder.MustShiftParse(c.zboxEntrypoint) + require.NoError(t, err, "URL parse error") + urlBuilder.SetPath("/v2/shareinfo/received") + + resp, err := c.executeForServiceProvider(t, urlBuilder.String(), model.ExecutionRequest{ + Dst: &ZboxShareInfoList, + QueryParams: queryParams, + Headers: headers, + RequiredStatusCode: 200, + }, HttpGETMethod) + + return ZboxShareInfoList, resp, err +} + func (c *ZboxClient) CreateShareInfo(t *test.SystemTest, headers, shareinfoData map[string]string) (*model.ZboxMessageResponse, *resty.Response, error) { t.Logf("Posting ShareInfo using 0box...") var message *model.ZboxMessageResponse @@ -588,6 +619,98 @@ func (c *ZboxClient) DeleteShareinfo(t *test.SystemTest, headers map[string]stri return message, resp, err } +func (c *ZboxClient) CreateShareRequest(t *test.SystemTest, headers, shareRequestData map[string]string) (*model.ZboxMessageDataResponse[int64], *resty.Response, error) { + t.Logf("Posting ShareRequest using 0box...") + var out model.ZboxMessageDataResponse[int64] + + urlBuilder := NewURLBuilder() + err := urlBuilder.MustShiftParse(c.zboxEntrypoint) + require.NoError(t, err, "URL parse error") + urlBuilder.SetPath("/v2/sharereq") + + resp, err := c.executeForServiceProvider(t, urlBuilder.String(), model.ExecutionRequest{ + Dst: &out, + Body: shareRequestData, + Headers: headers, + RequiredStatusCode: 201, + }, HttpPOSTMethod) + return &out, resp, err +} + +func (c *ZboxClient) GetReceivedShareReq(t *test.SystemTest, headers map[string]string, queryParams map[string]string) (*model.ZboxMessageDataResponse[[]model.ZboxShareRequest], *resty.Response, error) { + t.Logf("Getting received share requests for [%v] using 0box...", headers["X-App-User-ID"]) + var out model.ZboxMessageDataResponse[[]model.ZboxShareRequest] + + urlBuilder := NewURLBuilder() + err := urlBuilder.MustShiftParse(c.zboxEntrypoint) + require.NoError(t, err, "URL parse error") + urlBuilder.SetPath("/v2/sharereq/received") + + resp, err := c.executeForServiceProvider(t, urlBuilder.String(), model.ExecutionRequest{ + Dst: &out, + QueryParams: queryParams, + Headers: headers, + RequiredStatusCode: 200, + }, HttpGETMethod) + + return &out, resp, err +} + +func (c *ZboxClient) GetRequestedShareReq(t *test.SystemTest, headers map[string]string, queryParams map[string]string) (*model.ZboxMessageDataResponse[[]model.ZboxShareRequest], *resty.Response, error) { + t.Logf("Getting requested share requests for [%v] using 0box...", headers["X-App-User-ID"]) + var out model.ZboxMessageDataResponse[[]model.ZboxShareRequest] + + urlBuilder := NewURLBuilder() + err := urlBuilder.MustShiftParse(c.zboxEntrypoint) + require.NoError(t, err, "URL parse error") + urlBuilder.SetPath("/v2/sharereq/requested") + + resp, err := c.executeForServiceProvider(t, urlBuilder.String(), model.ExecutionRequest{ + Dst: &out, + QueryParams: queryParams, + Headers: headers, + RequiredStatusCode: 200, + }, HttpGETMethod) + + return &out, resp, err +} + +func (c *ZboxClient) UpdateShareReq(t *test.SystemTest, headers, updateShareReqData map[string]string) (*model.ZboxMessageDataResponse[model.ZboxShareRequest], *resty.Response, error) { + t.Logf("Updating ShareRequest using 0box...") + var out model.ZboxMessageDataResponse[model.ZboxShareRequest] + + urlBuilder := NewURLBuilder() + err := urlBuilder.MustShiftParse(c.zboxEntrypoint) + require.NoError(t, err, "URL parse error") + urlBuilder.SetPath("/v2/sharereq") + + resp, err := c.executeForServiceProvider(t, urlBuilder.String(), model.ExecutionRequest{ + Dst: &out, + FormData: updateShareReqData, + Headers: headers, + RequiredStatusCode: 201, + }, HttpPUTMethod) + return &out, resp, err +} + +func (c *ZboxClient) DeleteShareReq(t *test.SystemTest, headers, queryParams map[string]string) (*model.ZboxMessageDataResponse[int64], *resty.Response, error) { + t.Logf("Deleting ShareRequest using 0box...") + var out model.ZboxMessageDataResponse[int64] + + urlBuilder := NewURLBuilder() + err := urlBuilder.MustShiftParse(c.zboxEntrypoint) + require.NoError(t, err, "URL parse error") + urlBuilder.SetPath("/v2/sharereq") + + resp, err := c.executeForServiceProvider(t, urlBuilder.String(), model.ExecutionRequest{ + Dst: &out, + QueryParams: queryParams, + Headers: headers, + RequiredStatusCode: 200, + }, HttpDELETEMethod) + return &out, resp, err +} + func (c *ZboxClient) CreateNftCollection(t *test.SystemTest, headers, nfCollectionData map[string]string) (*model.ZboxNftCollection, *resty.Response, error) { t.Logf("Creating nft collection using 0box...") var ZboxNftCollection *model.ZboxNftCollection diff --git a/tests/api_tests/0box_share_request_test.go b/tests/api_tests/0box_share_request_test.go new file mode 100644 index 0000000000..2adf59efcb --- /dev/null +++ b/tests/api_tests/0box_share_request_test.go @@ -0,0 +1,458 @@ +package api_tests + +import ( + "encoding/base64" + "encoding/json" + "strconv" + "testing" + + "github.com/0chain/system_test/internal/api/util/client" + "github.com/0chain/system_test/internal/api/util/test" + "github.com/stretchr/testify/require" +) + +func TestShareRequest(testSetup *testing.T) { + w := test.NewSystemTest(testSetup) + + // create receivedUserHeaders, receivedUserHeaders2, requestedUserHeaders, requestedUserHeaders2 + receivedUserHeaders := map[string]string{ + "X-App-Client-ID": client.X_APP_CLIENT_ID_A, + "X-App-Client-Key": client.X_APP_CLIENT_KEY_A, + "X-App-Timestamp": client.X_APP_TIMESTAMP, + "X-App-ID-TOKEN": client.X_APP_ID_TOKEN, + "X-App-User-ID": client.X_APP_USER_ID_A, + "X-CSRF-TOKEN": client.X_APP_CSRF, + "X-App-Client-Signature": client.X_APP_CLIENT_SIGNATURE_A, + "X-APP-TYPE": client.X_APP_VULT, + } + receivedOwnerInfo := map[string]string{ + "username": "test_owner_received", + "email": "test_email_received", + "phone_number": "+919876543211", + "otp": "123456", + "firebase_token": "test_firebase_token", + "user_id": client.X_APP_USER_ID_A, + } + receivedClientID := client.X_APP_CLIENT_ID_A + + receivedUser2Headers := map[string]string{ + "X-App-Client-ID": client.X_APP_CLIENT_ID_B, + "X-App-Client-Key": client.X_APP_CLIENT_KEY_B, + "X-App-Timestamp": client.X_APP_TIMESTAMP, + "X-App-ID-TOKEN": client.X_APP_ID_TOKEN, + "X-App-User-ID": client.X_APP_USER_ID_B, + "X-CSRF-TOKEN": client.X_APP_CSRF, + "X-App-Client-Signature": client.X_APP_CLIENT_SIGNATURE_B, + "X-APP-TYPE": client.X_APP_VULT, + } + receivedOwner2Info := map[string]string{ + "username": "test_owner2_received", + "email": "test_email2_received", + "phone_number": "+919876543212", + "otp": "123456", + "firebase_token": "test_firebase_token", + "user_id": client.X_APP_USER_ID_B, + } + receivedClientID2 := client.X_APP_CLIENT_ID_B + + requestedUserHeaders := map[string]string{ + "X-App-Client-ID": client.X_APP_CLIENT_ID, + "X-App-Client-Key": client.X_APP_CLIENT_KEY, + "X-App-Timestamp": client.X_APP_TIMESTAMP, + "X-App-ID-TOKEN": client.X_APP_ID_TOKEN, + "X-App-User-ID": client.X_APP_USER_ID, + "X-CSRF-TOKEN": client.X_APP_CSRF, + "X-App-Client-Signature": client.X_APP_CLIENT_SIGNATURE, + "X-APP-TYPE": client.X_APP_VULT, + } + requestedOwnerInfo := map[string]string{ + "username": "test_owner_requested", + "email": "test_email_requested", + "phone_number": "+919876543213", + "otp": "123456", + "firebase_token": "test_firebase_token", + "user_id": client.X_APP_USER_ID, + } + requestedClientID := client.X_APP_CLIENT_ID + + requestedUser2Headers := map[string]string{ + "X-App-Client-ID": client.X_APP_CLIENT_ID_R, + "X-App-Client-Key": client.X_APP_CLIENT_KEY_R, + "X-App-Timestamp": client.X_APP_TIMESTAMP, + "X-App-ID-TOKEN": client.X_APP_ID_TOKEN, + "X-App-User-ID": client.X_APP_USER_ID_R, + "X-CSRF-TOKEN": client.X_APP_CSRF, + "X-App-Client-Signature": client.X_APP_CLIENT_SIGNATURE_R, + "X-APP-TYPE": client.X_APP_VULT, + } + requestedOwner2Info := map[string]string{ + "username": "test_owner2_requested", + "email": "test_email2_requested", + "phone_number": "+919876543214", + "otp": "123456", + "firebase_token": "test_firebase_token", + "user_id": client.X_APP_USER_ID_R, + } + requestedClientID2 := client.X_APP_CLIENT_ID_R + + prevSharedUserHeaders := map[string]string{ + "X-App-Client-ID": client.X_APP_CLIENT_ID_C, + "X-App-Client-Key": client.X_APP_CLIENT_KEY_C, + "X-App-Timestamp": client.X_APP_TIMESTAMP, + "X-App-ID-TOKEN": client.X_APP_ID_TOKEN, + "X-App-User-ID": client.X_APP_USER_ID_C, + "X-CSRF-TOKEN": client.X_APP_CSRF, + "X-App-Client-Signature": client.X_APP_CLIENT_SIGNATURE_C, + "X-APP-TYPE": client.X_APP_VULT, + } + prevUserInfo := map[string]string{ + "username": "random_user", + "email": "random_email", + "phone_number": "+919876543215", + "otp": "123456", + "firebase_token": "test_firebase_token", + "user_id": client.X_APP_USER_ID_C, + } + prevSharedClientID := client.X_APP_CLIENT_ID_C + + // create wallet for receivedClientID, requestedClientID, requestedClientID2 + Teardown(w, receivedUserHeaders) + Teardown(w, receivedUser2Headers) + Teardown(w, requestedUserHeaders) + Teardown(w, requestedUser2Headers) + Teardown(w, prevSharedUserHeaders) + err := Create0boxTestWalletCustom(w, receivedUserHeaders, receivedOwnerInfo, NewTestWallet()) + require.NoError(w, err) + err = Create0boxTestWalletCustom(w, receivedUser2Headers, receivedOwner2Info, NewTestWallet()) + require.NoError(w, err) + err = Create0boxTestWalletCustom(w, requestedUserHeaders, requestedOwnerInfo, NewTestWallet()) + require.NoError(w, err) + err = Create0boxTestWalletCustom(w, requestedUser2Headers, requestedOwner2Info, NewTestWallet()) + require.NoError(w, err) + err = Create0boxTestWalletCustom(w, prevSharedUserHeaders, prevUserInfo, NewTestWallet()) + require.NoError(w, err) + + // reqId1: requestedClientID --> receivedClientID (file1) + // reqId2: requestedClientID --> receivedClientID (file2) + // reqId3: requestedClientID2 --> receivedClientID + // reqId4: requestedClientID2 --> receivedClientID2 + + + // data + authTicket1, err := convertToAuthTicket(map[string]string{ + "client_id": prevSharedClientID, + "owner_id": receivedClientID, + "file_name": "file1.png", + "file_path_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0a", + }) + require.NoError(w, err, "error creating authTicket1") + shareRequestData1 := map[string]string{ + "auth_ticket": authTicket1, + "message": "provide access!", + "owner_id": receivedClientID, + "lookup_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0a", + } + approvalAuthTicket1, err := convertToAuthTicket(map[string]string{ + "client_id": requestedClientID, + "owner_id": receivedClientID, + "file_name": "file1.png", + "file_path_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0a", + }) + require.NoError(w, err, "error creating approvalAuthTicket1") + authTicket2, err := convertToAuthTicket(map[string]string{ + "client_id": prevSharedClientID, + "owner_id": receivedClientID, + "file_name": "file2.png", + "file_path_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0b", + }) + require.NoError(w, err, "error creating authTicket2") + shareRequestData2 := map[string]string{ + "auth_ticket": authTicket2, + "owner_id": receivedClientID, + "lookup_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0b", + } + authTicket3, err := convertToAuthTicket(map[string]string{ + "client_id": prevSharedClientID, + "owner_id": receivedClientID, + "file_name": "file3.png", + "file_path_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0a", + }) + require.NoError(w, err, "error creating authTicket3") + shareRequestData3 := map[string]string{ + "auth_ticket": authTicket3, + "owner_id": receivedClientID, + "lookup_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0a", + } + authTicket4, err := convertToAuthTicket(map[string]string{ + "client_id": prevSharedClientID, + "owner_id": receivedClientID2, + "file_name": "file4.png", + "file_path_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0c", + }) + require.NoError(w, err, "error creating authTicket3") + approvalAuthTicket4, err := convertToAuthTicket(map[string]string{ + "client_id": prevSharedClientID, + "owner_id": receivedClientID2, + "file_name": "file4.png", + "file_path_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0c", + }) + require.NoError(w, err, "error creating approvalAuthTicket4") + + shareRequestData4 := map[string]string{ + "auth_ticket": authTicket4, + "owner_id": receivedClientID2, + "lookup_hash": "16a55237cfd477cca9f87cb51d14b1e64c6e87592429e9e471470ad177ddbe0c", + } + randomLink := "randomLink" + + // api response + var ( + reqId1, reqId2, reqId3, reqId4, reReqId int64 + toDeleteIds []int64 + ) + + w.Cleanup(func() { + for _, deleteId := range toDeleteIds { + dataResp, restyResp, err := zboxClient.DeleteShareReq(w, requestedUserHeaders, map[string]string{ + "id": strconv.FormatInt(deleteId, 10), + }) + if err != nil { + w.Errorf("error deleting ID %v : %v ", deleteId, restyResp.String()) + continue + } + w.Logf("deleted ID = %v ; count = %v", deleteId, dataResp.Data) + } + + Teardown(w, receivedUserHeaders) + Teardown(w, receivedUser2Headers) + Teardown(w, requestedUserHeaders) + Teardown(w, requestedUser2Headers) + }) + + w.RunSequentially("verify empty requests", func(t *test.SystemTest) { + dataResp, _, err := zboxClient.GetReceivedShareReq(t, receivedUserHeaders, map[string]string{}) + require.NoError(t, err, "error empty received shareReq") + require.Empty(t, dataResp.Data, "data list should be empty") + + dataResp, _, err = zboxClient.GetRequestedShareReq(t, requestedUserHeaders, map[string]string{}) + require.NoError(t, err, "error empty requested shareReq") + require.Empty(t, dataResp.Data, "data list should be empty") + }) + + w.RunSequentially("verify create requests", func(t *test.SystemTest) { + // create request by requestedClientID to receivedClientID + dataResp, _, err := zboxClient.CreateShareRequest(t, requestedUserHeaders, shareRequestData1) + require.NoError(t, err, "error creating shareRequestData1") + reqId1 = dataResp.Data + toDeleteIds = append(toDeleteIds, reqId1) + + // re-request with same data + _, restyResp, _ := zboxClient.CreateShareRequest(t, requestedUserHeaders, shareRequestData1) + require.Equal(t, 400, restyResp.StatusCode()) + require.Contains(t, restyResp.String(), "request_already_created") + + // create request by requestedClientID to receivedClientID for different file + dataResp, _, err = zboxClient.CreateShareRequest(t, requestedUserHeaders, shareRequestData2) + require.NoError(t, err, "error creating shareRequestData2") + reqId2 = dataResp.Data + toDeleteIds = append(toDeleteIds, reqId2) + + // create request by requestedClientID2 to receivedClientID + dataResp, _, err = zboxClient.CreateShareRequest(t, requestedUser2Headers, shareRequestData3) + require.NoError(t, err, "error creating shareRequestData3") + reqId3 = dataResp.Data + toDeleteIds = append(toDeleteIds, reqId3) + + // create request by requestedClientID2 to receivedClientID2 + dataResp, _, err = zboxClient.CreateShareRequest(t, requestedUser2Headers, shareRequestData4) + require.NoError(t, err, "error creating shareRequestData4") + reqId4 = dataResp.Data + toDeleteIds = append(toDeleteIds, reqId4) + }) + + w.RunSequentially("verify get all requests", func(t *test.SystemTest) { + // verify get all received requests + dataResp, _, err := zboxClient.GetReceivedShareReq(t, receivedUserHeaders, map[string]string{ + "all": "true", + }) + require.NoError(t, err, "error getting received shareReq") + require.Len(t, dataResp.Data, 3) + require.Equal(t, []int64{reqId3, reqId2, reqId1}, []int64{dataResp.Data[0].ID, dataResp.Data[1].ID, dataResp.Data[2].ID}) + + // verify get all received requests by requestedClientID + dataResp, _, err = zboxClient.GetReceivedShareReq(t, receivedUserHeaders, map[string]string{ + "all": "true", + "client_id": requestedClientID, + }) + require.NoError(t, err, "error getting received shareReq") + require.Len(t, dataResp.Data, 2) + require.Equal(t, []int64{reqId2, reqId1}, []int64{dataResp.Data[0].ID, dataResp.Data[1].ID}) + + // verify get all received requests by requestedClientID2 + dataResp, _, err = zboxClient.GetReceivedShareReq(t, receivedUserHeaders, map[string]string{ + "all": "true", + "client_id": requestedClientID2, + }) + require.NoError(t, err, "error getting received shareReq") + require.Len(t, dataResp.Data, 1) + require.Equal(t, []int64{reqId3}, []int64{dataResp.Data[0].ID}) + + // verify get all received requests by requestedClientID and LookupHash + dataResp, _, err = zboxClient.GetReceivedShareReq(t, receivedUserHeaders, map[string]string{ + "all": "true", + "client_id": requestedClientID, + "lookup_hash": shareRequestData1["lookup_hash"], + }) + require.NoError(t, err, "error getting received shareReq") + require.Len(t, dataResp.Data, 1) + require.Equal(t, []int64{reqId1}, []int64{dataResp.Data[0].ID}) + + // verify get all share requested by requestedClientID + dataResp, _, err = zboxClient.GetRequestedShareReq(t, requestedUserHeaders, map[string]string{ + "all": "true", + }) + require.NoError(t, err, "error getting requested shareReq") + require.Len(t, dataResp.Data, 2) + require.Equal(t, []int64{reqId2, reqId1}, []int64{dataResp.Data[0].ID, dataResp.Data[1].ID}) + + // verify get all share requested by requestedClientID with LookupHash filter + dataResp, _, err = zboxClient.GetRequestedShareReq(t, requestedUserHeaders, map[string]string{ + "all": "true", + "lookup_hash": shareRequestData1["lookup_hash"], + }) + require.NoError(t, err, "error getting requested shareReq") + require.Len(t, dataResp.Data, 1) + require.Equal(t, []int64{reqId1}, []int64{dataResp.Data[0].ID}) + + // verify get all share requested by requestedClientID2 + dataResp, _, err = zboxClient.GetRequestedShareReq(t, requestedUser2Headers, map[string]string{ + "all": "true", + }) + require.NoError(t, err, "error getting requested shareReq") + require.Len(t, dataResp.Data, 2) + require.Equal(t, []int64{reqId4, reqId3}, []int64{dataResp.Data[0].ID, dataResp.Data[1].ID}) + + // verify get all share requested by requestedClientID2 with OwnerID filter + dataResp, _, err = zboxClient.GetRequestedShareReq(t, requestedUser2Headers, map[string]string{ + "all": "true", + "owner_id": receivedClientID2, + }) + require.NoError(t, err, "error getting requested shareReq") + require.Len(t, dataResp.Data, 1) + require.Equal(t, []int64{reqId4}, []int64{dataResp.Data[0].ID}) + }) + + w.RunSequentially("update requests", func(t *test.SystemTest) { + // approve reqId1 + dataResp, _, err := zboxClient.UpdateShareReq(t, receivedUserHeaders, map[string]string{ + "id": strconv.FormatInt(reqId1, 10), + "status": "1", + "link": randomLink, + "auth_ticket": approvalAuthTicket1, + }) + require.NoError(t, err, "error updating reqId1") + require.Equal(t, uint8(1), dataResp.Data.Status, "reqId1 should be approved") + + // verify shareinfo gets created + resp, _, err := zboxClient.GetShareInfoReceivedWithParams(t, requestedUserHeaders, map[string]string{ + "share_info_type": "private", + "lookup_hash": shareRequestData1["lookup_hash"], + }) + require.NoError(t, err, "error verifying shareinfo exists") + require.Len(t, resp.Data, 1) + require.Equal(t, resp.Data[0].Receiver, requestedClientID) + require.Equal(t, approvalAuthTicket1, resp.Data[0].AuthTicket, "share_info authticket should be updated") + + // approve or decline reqId1 again should fail + _, restyResp, _ := zboxClient.UpdateShareReq(t, receivedUserHeaders, map[string]string{ + "id": strconv.FormatInt(reqId1, 10), + "status": "2", + }) + require.Equal(t, 400, restyResp.StatusCode()) + require.Contains(t, restyResp.String(), "status is in final state") + + // approve reqId2 by receivedClientID2 should fail authorization + _, restyResp, _ = zboxClient.UpdateShareReq(t, receivedUser2Headers, map[string]string{ + "id": strconv.FormatInt(reqId2, 10), + "status": "1", + }) + require.Equal(t, 400, restyResp.StatusCode()) + require.Contains(t, restyResp.String(), "unauthorized:") + + // status other than 1 or 2 should fail + _, restyResp, _ = zboxClient.UpdateShareReq(t, receivedUser2Headers, map[string]string{ + "id": strconv.FormatInt(reqId2, 10), + "status": "0", + }) + require.Equal(t, 400, restyResp.StatusCode()) + require.Contains(t, restyResp.String(), "invalid status") + + // decline reqId2 + dataResp, _, err = zboxClient.UpdateShareReq(t, receivedUserHeaders, map[string]string{ + "id": strconv.FormatInt(reqId2, 10), + "status": "2", + }) + require.NoError(t, err, "error updating reqId2") + require.Equal(t, uint8(2), dataResp.Data.Status, "reqId2 should be declined") + + // decline reqId3 + dataResp, _, err = zboxClient.UpdateShareReq(t, receivedUserHeaders, map[string]string{ + "id": strconv.FormatInt(reqId3, 10), + "status": "2", + }) + require.NoError(t, err, "error updating reqId3") + require.Equal(t, uint8(2), dataResp.Data.Status, "reqId3 should be declined") + + // approve reqId4 + dataResp, _, err = zboxClient.UpdateShareReq(t, receivedUser2Headers, map[string]string{ + "id": strconv.FormatInt(reqId4, 10), + "status": "1", + "link": randomLink, + "auth_ticket": approvalAuthTicket4, + }) + require.NoError(t, err, "error updating reqId4") + require.Equal(t, uint8(1), dataResp.Data.Status, "reqId4 should be approved") + }) + + w.RunSequentially("verify re-request for approved and declined shareReq", func(t *test.SystemTest) { + // re-request for already approved request should fail + _, restyResp, _ := zboxClient.CreateShareRequest(t, requestedUserHeaders, shareRequestData1) + require.Equal(t, 400, restyResp.StatusCode()) + require.Contains(t, restyResp.String(), "request_already_approved") + + // re-request for declined request should be allowed + dataResp, _, err := zboxClient.CreateShareRequest(t, requestedUserHeaders, shareRequestData2) + require.NoError(t, err, "re-request for declined request should be allowed") + reReqId = dataResp.Data + toDeleteIds = append(toDeleteIds, reReqId) + }) + + w.RunSequentially("verify get latest requests", func(t *test.SystemTest) { + // verify get latest approved request + dataResp, _, err := zboxClient.GetReceivedShareReq(t, receivedUserHeaders, map[string]string{ + "status": "1", + "client_id": requestedClientID, + }) + require.NoError(t, err, "error getting latest approved shareReq") + require.Len(t, dataResp.Data, 1) + require.Equal(t, []int64{reqId1}, []int64{dataResp.Data[0].ID}) + + // verify get latest request + dataResp, _, err = zboxClient.GetReceivedShareReq(t, receivedUserHeaders, map[string]string{ + "client_id": requestedClientID, + }) + require.NoError(t, err, "error getting latest approved shareReq") + require.Len(t, dataResp.Data, 1) + require.Equal(t, []int64{reReqId}, []int64{dataResp.Data[0].ID}) + require.Equal(t, uint8(0), dataResp.Data[0].Status) + }) + +} + +func convertToAuthTicket(data interface{}) (string, error) { + jsonBytes, err := json.Marshal(data) + if err != nil { + return "", err + } + return base64.StdEncoding.EncodeToString(jsonBytes), nil +} diff --git a/tests/api_tests/0box_wallet_test.go b/tests/api_tests/0box_wallet_test.go index 3fafb49a4e..1c92e7ba37 100644 --- a/tests/api_tests/0box_wallet_test.go +++ b/tests/api_tests/0box_wallet_test.go @@ -30,6 +30,18 @@ func Create0boxTestWallet(t *test.SystemTest, headers map[string]string) error { return nil } +func Create0boxTestWalletCustom(t *test.SystemTest, headers, verifyOtpInput, walletInput map[string]string) error { + _, _, err := zboxClient.VerifyOtpDetails(t, headers, verifyOtpInput) + if err != nil { + return err + } + _, _, err = zboxClient.CreateWallet(t, headers, walletInput) + if err != nil { + return err + } + return nil +} + func Test0BoxWallet(testSetup *testing.T) { t := test.NewSystemTest(testSetup)