github.com/akamai/AkamaiOPEN-edgegrid-golang/v8@v8.1.0/pkg/edgeworkers/edgeworker_id_test.go (about)

     1  package edgeworkers
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"io/ioutil"
     7  	"net/http"
     8  	"net/http/httptest"
     9  	"strconv"
    10  	"testing"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestGetEdgeWorkerID(t *testing.T) {
    17  	tests := map[string]struct {
    18  		params           GetEdgeWorkerIDRequest
    19  		responseStatus   int
    20  		responseBody     string
    21  		expectedPath     string
    22  		expectedResponse *EdgeWorkerID
    23  		withError        error
    24  	}{
    25  		"200 OK - get EdgeWorkerID": {
    26  			params:         GetEdgeWorkerIDRequest{EdgeWorkerID: 12345},
    27  			responseStatus: http.StatusOK,
    28  			responseBody: `
    29  {
    30      "edgeWorkerId": 12345,
    31      "name": "EdgeWorkerID",
    32      "accountId": "B-123-WNKA6P",
    33      "groupId": 12345,
    34      "resourceTierId": 123,
    35      "createdBy": "jbond",
    36      "createdTime": "2021-04-19T07:08:37Z",
    37      "lastModifiedBy": "jbond",
    38      "lastModifiedTime": "2021-04-19T07:08:37Z"
    39  }
    40  `,
    41  			expectedPath: "/edgeworkers/v1/ids/12345",
    42  			expectedResponse: &EdgeWorkerID{
    43  				EdgeWorkerID:     12345,
    44  				Name:             "EdgeWorkerID",
    45  				AccountID:        "B-123-WNKA6P",
    46  				GroupID:          12345,
    47  				ResourceTierID:   123,
    48  				CreatedBy:        "jbond",
    49  				CreatedTime:      "2021-04-19T07:08:37Z",
    50  				LastModifiedBy:   "jbond",
    51  				LastModifiedTime: "2021-04-19T07:08:37Z",
    52  			},
    53  		},
    54  		"500 internal server error": {
    55  			params:         GetEdgeWorkerIDRequest{EdgeWorkerID: 12345},
    56  			responseStatus: http.StatusInternalServerError,
    57  			responseBody: `
    58  {
    59    "type": "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
    60    "title": "Server Error",
    61    "status": 500,
    62    "instance": "host_name/edgeworkers/v1/ids/12345",
    63    "method": "GET",
    64    "serverIp": "104.81.220.111",
    65    "clientIp": "89.64.55.111",
    66    "requestId": "a73affa111",
    67    "requestTime": "2021-12-06T10:27:11Z"
    68  }`,
    69  			expectedPath: "/edgeworkers/v1/ids/12345",
    70  			withError: &Error{
    71  				Type:        "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
    72  				Title:       "Server Error",
    73  				Status:      500,
    74  				Instance:    "host_name/edgeworkers/v1/ids/12345",
    75  				Method:      "GET",
    76  				ServerIP:    "104.81.220.111",
    77  				ClientIP:    "89.64.55.111",
    78  				RequestID:   "a73affa111",
    79  				RequestTime: "2021-12-06T10:27:11Z",
    80  			},
    81  		},
    82  		"missing group EdgeWorkerID": {
    83  			params:    GetEdgeWorkerIDRequest{},
    84  			withError: ErrStructValidation,
    85  		},
    86  		"403 Forbidden - incorrect credentials": {
    87  			params:         GetEdgeWorkerIDRequest{EdgeWorkerID: 12345},
    88  			responseStatus: http.StatusForbidden,
    89  			responseBody: `
    90  {
    91      "type": "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
    92      "title": "Forbidden",
    93      "status": 403,
    94      "detail": "The client does not have the grant needed for the request",
    95      "instance": "host_name/edgeworkers/v1/ids/12345",
    96      "authzRealm": "scuomder224df6ct.dkekfr3qqg4dghpj",
    97      "method": "GET",
    98      "serverIp": "104.81.220.111",
    99      "clientIp": "89.64.55.111",
   100      "requestId": "a73affa111",
   101      "requestTime": "2021-12-06T12:45:09Z"
   102  }`,
   103  			expectedPath: "/edgeworkers/v1/ids/12345",
   104  			withError: &Error{
   105  				Type:        "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   106  				Title:       "Forbidden",
   107  				Status:      403,
   108  				Detail:      "The client does not have the grant needed for the request",
   109  				Instance:    "host_name/edgeworkers/v1/ids/12345",
   110  				AuthzRealm:  "scuomder224df6ct.dkekfr3qqg4dghpj",
   111  				Method:      "GET",
   112  				ServerIP:    "104.81.220.111",
   113  				ClientIP:    "89.64.55.111",
   114  				RequestID:   "a73affa111",
   115  				RequestTime: "2021-12-06T12:45:09Z",
   116  			},
   117  		},
   118  		"404 Not Found - EdgeWorkerID doesn't exist": {
   119  			params:         GetEdgeWorkerIDRequest{EdgeWorkerID: 12345},
   120  			responseStatus: http.StatusForbidden,
   121  			responseBody: `
   122  {
   123      "type": "/edgeworkers/error-types/edgeworkers-not-found",
   124      "title": "The given resource could not be found.",
   125      "detail": "Unable to find the requested EdgeWorkerID ID",
   126      "instance": "/edgeworkers/error-instances/86d1cc10-4baf-49e1-b81a-075b72a2f6a4",
   127      "status": 404,
   128      "errorCode": "EW2002"
   129  }`,
   130  			expectedPath: "/edgeworkers/v1/ids/12345",
   131  			withError: &Error{
   132  				Type:      "/edgeworkers/error-types/edgeworkers-not-found",
   133  				Title:     "The given resource could not be found.",
   134  				Detail:    "Unable to find the requested EdgeWorkerID ID",
   135  				Status:    404,
   136  				Instance:  "/edgeworkers/error-instances/86d1cc10-4baf-49e1-b81a-075b72a2f6a4",
   137  				ErrorCode: "EW2002",
   138  			},
   139  		},
   140  	}
   141  
   142  	for name, test := range tests {
   143  		t.Run(name, func(t *testing.T) {
   144  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   145  				assert.Equal(t, test.expectedPath, r.URL.String())
   146  				assert.Equal(t, http.MethodGet, r.Method)
   147  				w.WriteHeader(test.responseStatus)
   148  				_, err := w.Write([]byte(test.responseBody))
   149  				assert.NoError(t, err)
   150  			}))
   151  			client := mockAPIClient(t, mockServer)
   152  			result, err := client.GetEdgeWorkerID(context.Background(), test.params)
   153  			if test.withError != nil {
   154  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   155  				return
   156  			}
   157  			require.NoError(t, err)
   158  			assert.Equal(t, test.expectedResponse, result)
   159  		})
   160  	}
   161  }
   162  
   163  func TestListEdgeWorkersID(t *testing.T) {
   164  	tests := map[string]struct {
   165  		params           ListEdgeWorkersIDRequest
   166  		responseStatus   int
   167  		responseBody     string
   168  		expectedPath     string
   169  		expectedResponse *ListEdgeWorkersIDResponse
   170  		withError        error
   171  	}{
   172  		"200 OK - list permission groups without parameters": {
   173  			responseStatus: http.StatusOK,
   174  			responseBody: `
   175  {
   176      "edgeWorkerIds": [
   177          {
   178              "edgeWorkerId": 12345,
   179              "name": "edgeworker",
   180              "accountId": "B-3-WNK123",
   181              "groupId": 54321,
   182              "resourceTierId": 123,
   183              "createdBy": "jbond",
   184              "createdTime": "2020-05-05T21:55:36Z",
   185              "lastModifiedBy": "jbond",
   186              "lastModifiedTime": "2020-05-05T21:55:36Z"
   187          },
   188  		{
   189              "edgeWorkerId": 12346,
   190              "name": "edgeworker-first",
   191              "accountId": "B-3-WNK123",
   192              "groupId": 54321,
   193              "resourceTierId": 234,
   194              "createdBy": "jbond",
   195              "createdTime": "2021-05-05T21:55:36Z",
   196              "lastModifiedBy": "jbond",
   197              "lastModifiedTime": "2021-05-05T21:55:36Z"
   198          }
   199      ]
   200  }`,
   201  			params:       ListEdgeWorkersIDRequest{},
   202  			expectedPath: "/edgeworkers/v1/ids",
   203  			expectedResponse: &ListEdgeWorkersIDResponse{[]EdgeWorkerID{
   204  				{
   205  					EdgeWorkerID:     12345,
   206  					Name:             "edgeworker",
   207  					AccountID:        "B-3-WNK123",
   208  					GroupID:          54321,
   209  					ResourceTierID:   123,
   210  					CreatedBy:        "jbond",
   211  					CreatedTime:      "2020-05-05T21:55:36Z",
   212  					LastModifiedBy:   "jbond",
   213  					LastModifiedTime: "2020-05-05T21:55:36Z",
   214  				},
   215  				{
   216  					EdgeWorkerID:     12346,
   217  					Name:             "edgeworker-first",
   218  					AccountID:        "B-3-WNK123",
   219  					GroupID:          54321,
   220  					ResourceTierID:   234,
   221  					CreatedBy:        "jbond",
   222  					CreatedTime:      "2021-05-05T21:55:36Z",
   223  					LastModifiedBy:   "jbond",
   224  					LastModifiedTime: "2021-05-05T21:55:36Z",
   225  				},
   226  			}},
   227  		},
   228  		"200 OK - list permission groups with parameters": {
   229  			responseStatus: http.StatusOK,
   230  			responseBody: `
   231  {
   232      "edgeWorkerIds": [
   233          {
   234              "edgeWorkerId": 12345,
   235              "name": "edgeworker",
   236              "accountId": "B-3-WNK123",
   237              "groupId": 54321,
   238              "resourceTierId": 234,
   239              "createdBy": "jbond",
   240              "createdTime": "2020-05-05T21:55:36Z",
   241              "lastModifiedBy": "jbond",
   242              "lastModifiedTime": "2020-05-05T21:55:36Z"
   243          },
   244  		{
   245              "edgeWorkerId": 12346,
   246              "name": "edgeworker-first",
   247              "accountId": "B-3-WNK123",
   248              "groupId": 54321,
   249              "resourceTierId": 234,
   250              "createdBy": "jbond",
   251              "createdTime": "2021-05-05T21:55:36Z",
   252              "lastModifiedBy": "jbond",
   253              "lastModifiedTime": "2021-05-05T21:55:36Z"
   254          }
   255      ]
   256  }`,
   257  			params: ListEdgeWorkersIDRequest{
   258  				GroupID:        54321,
   259  				ResourceTierID: 234,
   260  			},
   261  			expectedPath: "/edgeworkers/v1/ids?groupId=54321&resourceTierId=234",
   262  			expectedResponse: &ListEdgeWorkersIDResponse{[]EdgeWorkerID{
   263  				{
   264  					EdgeWorkerID:     12345,
   265  					Name:             "edgeworker",
   266  					AccountID:        "B-3-WNK123",
   267  					GroupID:          54321,
   268  					ResourceTierID:   234,
   269  					CreatedBy:        "jbond",
   270  					CreatedTime:      "2020-05-05T21:55:36Z",
   271  					LastModifiedBy:   "jbond",
   272  					LastModifiedTime: "2020-05-05T21:55:36Z",
   273  				},
   274  				{
   275  					EdgeWorkerID:     12346,
   276  					Name:             "edgeworker-first",
   277  					AccountID:        "B-3-WNK123",
   278  					GroupID:          54321,
   279  					ResourceTierID:   234,
   280  					CreatedBy:        "jbond",
   281  					CreatedTime:      "2021-05-05T21:55:36Z",
   282  					LastModifiedBy:   "jbond",
   283  					LastModifiedTime: "2021-05-05T21:55:36Z",
   284  				},
   285  			}},
   286  		},
   287  		"200 OK - no EdgeWorkerID under resourceTierId": {
   288  			params: ListEdgeWorkersIDRequest{
   289  				GroupID:        54321,
   290  				ResourceTierID: 123,
   291  			},
   292  			responseStatus: http.StatusOK,
   293  			responseBody: `
   294  {
   295      "edgeWorkerIds": []
   296  }`,
   297  			expectedPath:     "/edgeworkers/v1/ids?groupId=54321&resourceTierId=123",
   298  			expectedResponse: &ListEdgeWorkersIDResponse{[]EdgeWorkerID{}},
   299  		},
   300  		"200 OK - no EdgeWorkerID under groupID": {
   301  			params: ListEdgeWorkersIDRequest{
   302  				GroupID:        46778,
   303  				ResourceTierID: 123,
   304  			},
   305  			responseStatus: http.StatusOK,
   306  			responseBody: `
   307  {
   308      "edgeWorkerIds": []
   309  }`,
   310  			expectedPath:     "/edgeworkers/v1/ids?groupId=46778&resourceTierId=123",
   311  			expectedResponse: &ListEdgeWorkersIDResponse{[]EdgeWorkerID{}},
   312  		},
   313  		"500 internal server error": {
   314  			params:         ListEdgeWorkersIDRequest{},
   315  			responseStatus: http.StatusInternalServerError,
   316  			responseBody: `
   317  {
   318    "type": "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   319    "title": "Server Error",
   320    "status": 500,
   321    "instance": "host_name/edgeworkers/v1/ids",
   322    "method": "GET",
   323    "serverIp": "104.81.220.111",
   324    "clientIp": "89.64.55.111",
   325    "requestId": "a73affa111",
   326    "requestTime": "2021-12-06T10:27:11Z"
   327  }`,
   328  			expectedPath: "/edgeworkers/v1/ids",
   329  			withError: &Error{
   330  				Type:        "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   331  				Title:       "Server Error",
   332  				Status:      500,
   333  				Instance:    "host_name/edgeworkers/v1/ids",
   334  				Method:      "GET",
   335  				ServerIP:    "104.81.220.111",
   336  				ClientIP:    "89.64.55.111",
   337  				RequestID:   "a73affa111",
   338  				RequestTime: "2021-12-06T10:27:11Z",
   339  			},
   340  		},
   341  		"403 Forbidden - incorrect credentials": {
   342  			params:         ListEdgeWorkersIDRequest{},
   343  			responseStatus: http.StatusForbidden,
   344  			responseBody: `
   345  {
   346      "type": "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   347      "title": "Forbidden",
   348      "status": 403,
   349      "detail": "The client does not have the grant needed for the request",
   350      "instance": "host_name/edgeworkers/v1/ids",
   351      "authzRealm": "scuomder224df6ct.dkekfr3qqg4dghpj",
   352      "method": "GET",
   353      "serverIp": "104.81.220.111",
   354      "clientIp": "89.64.55.111",
   355      "requestId": "a73affa111",
   356      "requestTime": "2021-12-13T12:01:17Z"
   357  }`,
   358  			expectedPath: "/edgeworkers/v1/ids",
   359  			withError: &Error{
   360  				Type:        "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   361  				Title:       "Forbidden",
   362  				Status:      403,
   363  				Detail:      "The client does not have the grant needed for the request",
   364  				Instance:    "host_name/edgeworkers/v1/ids",
   365  				AuthzRealm:  "scuomder224df6ct.dkekfr3qqg4dghpj",
   366  				Method:      "GET",
   367  				ServerIP:    "104.81.220.111",
   368  				ClientIP:    "89.64.55.111",
   369  				RequestID:   "a73affa111",
   370  				RequestTime: "2021-12-13T12:01:17Z",
   371  			},
   372  		},
   373  	}
   374  	for name, test := range tests {
   375  		t.Run(name, func(t *testing.T) {
   376  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   377  				assert.Equal(t, test.expectedPath, r.URL.String())
   378  				assert.Equal(t, http.MethodGet, r.Method)
   379  				w.WriteHeader(test.responseStatus)
   380  				_, err := w.Write([]byte(test.responseBody))
   381  				assert.NoError(t, err)
   382  			}))
   383  			client := mockAPIClient(t, mockServer)
   384  			result, err := client.ListEdgeWorkersID(context.Background(), test.params)
   385  			if test.withError != nil {
   386  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   387  				return
   388  			}
   389  			require.NoError(t, err)
   390  			assert.Equal(t, test.expectedResponse, result)
   391  		})
   392  	}
   393  }
   394  
   395  func TestCreateEdgeWorkerID(t *testing.T) {
   396  	tests := map[string]struct {
   397  		params              CreateEdgeWorkerIDRequest
   398  		expectedRequestBody string
   399  		responseStatus      int
   400  		responseBody        string
   401  		expectedPath        string
   402  		expectedResponse    *EdgeWorkerID
   403  		withError           error
   404  	}{
   405  		"201 Created - create EdgeWorkerID": {
   406  			params: CreateEdgeWorkerIDRequest{
   407  				GroupID:        12345,
   408  				Name:           "New EdgeWorkerID",
   409  				ResourceTierID: 123,
   410  			},
   411  			expectedRequestBody: `{"name":"New EdgeWorkerID","groupId":12345,"resourceTierId":123}`,
   412  			responseStatus:      http.StatusCreated,
   413  			responseBody: `
   414  {
   415      "edgeWorkerId": 83969,
   416      "name": "New EdgeWorkerID",
   417      "accountId": "B-123-WNKA6P",
   418      "groupId": 12345,
   419      "resourceTierId": 123,
   420      "createdBy": "jbond",
   421      "createdTime": "2021-12-13T13:32:37Z",
   422      "lastModifiedBy": "jbond",
   423      "lastModifiedTime": "2021-12-13T13:32:37Z"
   424  }`,
   425  			expectedPath: "/edgeworkers/v1/ids",
   426  			expectedResponse: &EdgeWorkerID{
   427  				EdgeWorkerID:     83969,
   428  				Name:             "New EdgeWorkerID",
   429  				AccountID:        "B-123-WNKA6P",
   430  				GroupID:          12345,
   431  				ResourceTierID:   123,
   432  				CreatedBy:        "jbond",
   433  				CreatedTime:      "2021-12-13T13:32:37Z",
   434  				LastModifiedBy:   "jbond",
   435  				LastModifiedTime: "2021-12-13T13:32:37Z",
   436  			},
   437  		},
   438  		"validation error": {
   439  			params:    CreateEdgeWorkerIDRequest{},
   440  			withError: ErrStructValidation,
   441  		},
   442  		"500 internal server error": {
   443  			params: CreateEdgeWorkerIDRequest{
   444  				GroupID:        12345,
   445  				Name:           "New EdgeWorkerID",
   446  				ResourceTierID: 123,
   447  			},
   448  			responseStatus: http.StatusInternalServerError,
   449  			responseBody: `
   450  {
   451    "type": "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   452    "title": "Server Error",
   453    "status": 500,
   454    "instance": "host_name/edgeworkers/v1/ids",
   455    "method": "POST",
   456    "serverIp": "104.81.220.111",
   457    "clientIp": "89.64.55.111",
   458    "requestId": "a73affa111",
   459    "requestTime": "2021-12-13T13:32:37Z"
   460  }`,
   461  			expectedPath: "/edgeworkers/v1/ids",
   462  			withError: &Error{
   463  				Type:        "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   464  				Title:       "Server Error",
   465  				Status:      500,
   466  				Instance:    "host_name/edgeworkers/v1/ids",
   467  				Method:      "POST",
   468  				ServerIP:    "104.81.220.111",
   469  				ClientIP:    "89.64.55.111",
   470  				RequestID:   "a73affa111",
   471  				RequestTime: "2021-12-13T13:32:37Z",
   472  			},
   473  		},
   474  		"403 Forbidden - incorrect credentials": {
   475  			params: CreateEdgeWorkerIDRequest{
   476  				GroupID:        12345,
   477  				Name:           "New EdgeWorkerID",
   478  				ResourceTierID: 123,
   479  			},
   480  			responseStatus: http.StatusForbidden,
   481  			responseBody: `
   482  {
   483      "type": "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   484      "title": "Forbidden",
   485      "status": 403,
   486      "detail": "The client does not have the grant needed for the request",
   487      "instance": "host_name/edgeworkers/v1/ids",
   488      "authzRealm": "scuomder224df6ct.dkekfr3qqg4dghpj",
   489      "method": "POST",
   490      "serverIp": "104.81.220.111",
   491      "clientIp": "89.64.55.111",
   492      "requestId": "a73affa111",
   493      "requestTime": "2021-12-13T13:32:37Z"
   494  }`,
   495  			expectedPath: "/edgeworkers/v1/ids",
   496  			withError: &Error{
   497  				Type:        "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   498  				Title:       "Forbidden",
   499  				Status:      403,
   500  				Detail:      "The client does not have the grant needed for the request",
   501  				Instance:    "host_name/edgeworkers/v1/ids",
   502  				AuthzRealm:  "scuomder224df6ct.dkekfr3qqg4dghpj",
   503  				Method:      "POST",
   504  				ServerIP:    "104.81.220.111",
   505  				ClientIP:    "89.64.55.111",
   506  				RequestID:   "a73affa111",
   507  				RequestTime: "2021-12-13T13:32:37Z",
   508  			},
   509  		},
   510  	}
   511  	for name, test := range tests {
   512  		t.Run(name, func(t *testing.T) {
   513  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   514  				assert.Equal(t, test.expectedPath, r.URL.String())
   515  				assert.Equal(t, http.MethodPost, r.Method)
   516  				w.WriteHeader(test.responseStatus)
   517  				_, err := w.Write([]byte(test.responseBody))
   518  				assert.NoError(t, err)
   519  
   520  				if len(test.expectedRequestBody) > 0 {
   521  					body, err := ioutil.ReadAll(r.Body)
   522  					require.NoError(t, err)
   523  					assert.Equal(t, test.expectedRequestBody, string(body))
   524  				}
   525  			}))
   526  			client := mockAPIClient(t, mockServer)
   527  			result, err := client.CreateEdgeWorkerID(context.Background(), test.params)
   528  			if test.withError != nil {
   529  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   530  				return
   531  			}
   532  			require.NoError(t, err)
   533  			assert.Equal(t, test.expectedResponse, result)
   534  		})
   535  	}
   536  }
   537  
   538  func TestUpdateEdgeWorkerID(t *testing.T) {
   539  	tests := map[string]struct {
   540  		params              UpdateEdgeWorkerIDRequest
   541  		expectedRequestBody string
   542  		responseStatus      int
   543  		responseBody        string
   544  		expectedPath        string
   545  		expectedResponse    *EdgeWorkerID
   546  		withError           error
   547  	}{
   548  		"200 OK - update EdgeWorkerID": {
   549  			params: UpdateEdgeWorkerIDRequest{
   550  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   551  					GroupID:        12345,
   552  					Name:           "Update EdgeWorkerID",
   553  					ResourceTierID: 123,
   554  				},
   555  				EdgeWorkerID: 54321,
   556  			},
   557  			expectedRequestBody: `{"name":"Update EdgeWorkerID","groupId":12345,"resourceTierId":123}`,
   558  			responseStatus:      http.StatusOK,
   559  			responseBody: `
   560  {
   561      "edgeWorkerId": 54321,
   562      "name": "Update EdgeWorkerID",
   563      "accountId": "B-123-WNKA6P",
   564      "groupId": 12345,
   565      "resourceTierId": 123,
   566      "createdBy": "jbond",
   567      "createdTime": "2021-12-14T09:51:54Z",
   568      "lastModifiedBy": "jbond",
   569      "lastModifiedTime": "2021-12-14T09:51:54Z"
   570  }`,
   571  			expectedPath: "/edgeworkers/v1/ids/54321",
   572  			expectedResponse: &EdgeWorkerID{
   573  				EdgeWorkerID:     54321,
   574  				Name:             "Update EdgeWorkerID",
   575  				AccountID:        "B-123-WNKA6P",
   576  				GroupID:          12345,
   577  				ResourceTierID:   123,
   578  				CreatedBy:        "jbond",
   579  				CreatedTime:      "2021-12-14T09:51:54Z",
   580  				LastModifiedBy:   "jbond",
   581  				LastModifiedTime: "2021-12-14T09:51:54Z",
   582  			},
   583  		},
   584  		"validation error - empty body parameters": {
   585  			params: UpdateEdgeWorkerIDRequest{
   586  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{},
   587  				EdgeWorkerID:            54321,
   588  			},
   589  			withError: ErrStructValidation,
   590  		},
   591  		"validation error - empty edgeworker id": {
   592  			params: UpdateEdgeWorkerIDRequest{
   593  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   594  					GroupID:        12345,
   595  					Name:           "Update EdgeWorkerID",
   596  					ResourceTierID: 123,
   597  				},
   598  			},
   599  			withError: ErrStructValidation,
   600  		},
   601  		"500 internal server error": {
   602  			params: UpdateEdgeWorkerIDRequest{
   603  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   604  					GroupID:        12345,
   605  					Name:           "Update EdgeWorkerID",
   606  					ResourceTierID: 123,
   607  				},
   608  				EdgeWorkerID: 54321,
   609  			},
   610  			responseStatus: http.StatusInternalServerError,
   611  			responseBody: `
   612  {
   613   "type": "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   614   "title": "Server Error",
   615   "status": 500,
   616   "instance": "host_name/edgeworkers/v1/ids/54321",
   617   "method": "PUT",
   618   "serverIp": "104.81.220.111",
   619   "clientIp": "89.64.55.111",
   620   "requestId": "a73affa111",
   621   "requestTime": "2021-12-13T13:32:37Z"
   622  }`,
   623  			expectedPath: "/edgeworkers/v1/ids/54321",
   624  			withError: &Error{
   625  				Type:        "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   626  				Title:       "Server Error",
   627  				Status:      500,
   628  				Instance:    "host_name/edgeworkers/v1/ids/54321",
   629  				Method:      "PUT",
   630  				ServerIP:    "104.81.220.111",
   631  				ClientIP:    "89.64.55.111",
   632  				RequestID:   "a73affa111",
   633  				RequestTime: "2021-12-13T13:32:37Z",
   634  			},
   635  		},
   636  		"403 Forbidden - incorrect credentials": {
   637  			params: UpdateEdgeWorkerIDRequest{
   638  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   639  					GroupID:        12345,
   640  					Name:           "Update EdgeWorkerID",
   641  					ResourceTierID: 123,
   642  				},
   643  				EdgeWorkerID: 54321,
   644  			},
   645  			responseStatus: http.StatusForbidden,
   646  			responseBody: `
   647  {
   648      "type": "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   649      "title": "Forbidden",
   650      "status": 403,
   651      "detail": "The client does not have the grant needed for the request",
   652      "instance": "host_name/edgeworkers/v1/ids/54321",
   653      "authzRealm": "scuomder224df6ct.dkekfr3qqg4dghpj",
   654      "method": "PUT",
   655      "serverIp": "104.81.220.111",
   656      "clientIp": "89.64.55.111",
   657      "requestId": "a73affa111",
   658      "requestTime": "2021-12-14T10:26:37Z"
   659  }`,
   660  			expectedPath: "/edgeworkers/v1/ids/54321",
   661  			withError: &Error{
   662  				Type:        "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   663  				Title:       "Forbidden",
   664  				Status:      403,
   665  				Detail:      "The client does not have the grant needed for the request",
   666  				Instance:    "host_name/edgeworkers/v1/ids/54321",
   667  				AuthzRealm:  "scuomder224df6ct.dkekfr3qqg4dghpj",
   668  				Method:      "PUT",
   669  				ServerIP:    "104.81.220.111",
   670  				ClientIP:    "89.64.55.111",
   671  				RequestID:   "a73affa111",
   672  				RequestTime: "2021-12-14T10:26:37Z",
   673  			},
   674  		},
   675  	}
   676  	for name, test := range tests {
   677  		t.Run(name, func(t *testing.T) {
   678  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   679  				assert.Equal(t, test.expectedPath, r.URL.String())
   680  				assert.Equal(t, http.MethodPut, r.Method)
   681  				w.WriteHeader(test.responseStatus)
   682  				_, err := w.Write([]byte(test.responseBody))
   683  				assert.NoError(t, err)
   684  
   685  				if len(test.expectedRequestBody) > 0 {
   686  					body, err := ioutil.ReadAll(r.Body)
   687  					require.NoError(t, err)
   688  					assert.Equal(t, test.expectedRequestBody, string(body))
   689  				}
   690  			}))
   691  			client := mockAPIClient(t, mockServer)
   692  			result, err := client.UpdateEdgeWorkerID(context.Background(), test.params)
   693  			if test.withError != nil {
   694  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   695  				return
   696  			}
   697  			require.NoError(t, err)
   698  			assert.Equal(t, test.expectedResponse, result)
   699  		})
   700  	}
   701  }
   702  
   703  func TestCloneEdgeWorkerID(t *testing.T) {
   704  	tests := map[string]struct {
   705  		params              CloneEdgeWorkerIDRequest
   706  		expectedRequestBody string
   707  		responseStatus      int
   708  		responseBody        string
   709  		expectedPath        string
   710  		expectedResponse    *EdgeWorkerID
   711  		withError           error
   712  	}{
   713  		"200 OK - clone EdgeWorkerID with different resourceTierId": {
   714  			params: CloneEdgeWorkerIDRequest{
   715  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   716  					GroupID:        12345,
   717  					Name:           "Clone EdgeWorkerID",
   718  					ResourceTierID: 123,
   719  				},
   720  				EdgeWorkerID: 54321,
   721  			},
   722  			expectedRequestBody: `{"name":"Clone EdgeWorkerID","groupId":12345,"resourceTierId":123}`,
   723  			responseStatus:      http.StatusOK,
   724  			responseBody: `
   725  {
   726      "edgeWorkerId": 54322,
   727      "name": "Clone EdgeWorkerID",
   728      "accountId": "B-123-WNKA6P",
   729      "groupId": 12345,
   730      "resourceTierId": 123,
   731      "sourceEdgeWorkerId": 54321,
   732      "createdBy": "jbond",
   733      "createdTime": "2021-12-14T11:23:02Z",
   734      "lastModifiedBy": "jbond",
   735      "lastModifiedTime": "2021-12-14T11:23:02Z"
   736  }`,
   737  			expectedPath: "/edgeworkers/v1/ids/54321/clone",
   738  			expectedResponse: &EdgeWorkerID{
   739  				EdgeWorkerID:       54322,
   740  				Name:               "Clone EdgeWorkerID",
   741  				AccountID:          "B-123-WNKA6P",
   742  				GroupID:            12345,
   743  				ResourceTierID:     123,
   744  				SourceEdgeWorkerID: 54321,
   745  				CreatedBy:          "jbond",
   746  				CreatedTime:        "2021-12-14T11:23:02Z",
   747  				LastModifiedBy:     "jbond",
   748  				LastModifiedTime:   "2021-12-14T11:23:02Z",
   749  			},
   750  		},
   751  		"validation error - empty body parameters": {
   752  			params:    CloneEdgeWorkerIDRequest{EdgeWorkerID: 54321},
   753  			withError: ErrStructValidation,
   754  		},
   755  		"validation error - empty edgeworker id": {
   756  			params: CloneEdgeWorkerIDRequest{
   757  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   758  					GroupID:        12345,
   759  					Name:           "Update EdgeWorkerID",
   760  					ResourceTierID: 123,
   761  				},
   762  			},
   763  			withError: ErrStructValidation,
   764  		},
   765  		"500 internal server error": {
   766  			params: CloneEdgeWorkerIDRequest{
   767  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   768  					GroupID:        12345,
   769  					Name:           "Clone EdgeWorkerID",
   770  					ResourceTierID: 123,
   771  				},
   772  				EdgeWorkerID: 54321,
   773  			},
   774  			responseStatus: http.StatusInternalServerError,
   775  			responseBody: `
   776  {
   777  "type": "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   778  "title": "Server Error",
   779  "status": 500,
   780  "instance": "host_name/edgeworkers/v1/ids/54321/clone",
   781  "method": "POST",
   782  "serverIp": "104.81.220.111",
   783  "clientIp": "89.64.55.111",
   784  "requestId": "a73affa111",
   785  "requestTime": "2021-12-13T13:32:37Z"
   786  }`,
   787  			expectedPath: "/edgeworkers/v1/ids/54321/clone",
   788  			withError: &Error{
   789  				Type:        "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   790  				Title:       "Server Error",
   791  				Status:      500,
   792  				Instance:    "host_name/edgeworkers/v1/ids/54321/clone",
   793  				Method:      "POST",
   794  				ServerIP:    "104.81.220.111",
   795  				ClientIP:    "89.64.55.111",
   796  				RequestID:   "a73affa111",
   797  				RequestTime: "2021-12-13T13:32:37Z",
   798  			},
   799  		},
   800  		"403 Forbidden - incorrect credentials": {
   801  			params: CloneEdgeWorkerIDRequest{
   802  				EdgeWorkerIDBodyRequest: EdgeWorkerIDBodyRequest{
   803  					GroupID:        12345,
   804  					Name:           "Update EdgeWorkerID",
   805  					ResourceTierID: 123,
   806  				},
   807  				EdgeWorkerID: 54321,
   808  			},
   809  			responseStatus: http.StatusForbidden,
   810  			responseBody: `
   811  {
   812     "type": "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   813     "title": "Forbidden",
   814     "status": 403,
   815     "detail": "The client does not have the grant needed for the request",
   816     "instance": "host_name/edgeworkers/v1/ids/54321/clone",
   817     "authzRealm": "scuomder224df6ct.dkekfr3qqg4dghpj",
   818     "method": "PUT",
   819     "serverIp": "104.81.220.111",
   820     "clientIp": "89.64.55.111",
   821     "requestId": "a73affa111",
   822     "requestTime": "2021-12-14T10:26:37Z"
   823  }`,
   824  			expectedPath: "/edgeworkers/v1/ids/54321/clone",
   825  			withError: &Error{
   826  				Type:        "https://problems.luna-dev.akamaiapis.net/-/pep-authz/deny",
   827  				Title:       "Forbidden",
   828  				Status:      403,
   829  				Detail:      "The client does not have the grant needed for the request",
   830  				Instance:    "host_name/edgeworkers/v1/ids/54321/clone",
   831  				AuthzRealm:  "scuomder224df6ct.dkekfr3qqg4dghpj",
   832  				Method:      "PUT",
   833  				ServerIP:    "104.81.220.111",
   834  				ClientIP:    "89.64.55.111",
   835  				RequestID:   "a73affa111",
   836  				RequestTime: "2021-12-14T10:26:37Z",
   837  			},
   838  		},
   839  	}
   840  	for name, test := range tests {
   841  		t.Run(name, func(t *testing.T) {
   842  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   843  				assert.Equal(t, test.expectedPath, r.URL.String())
   844  				assert.Equal(t, http.MethodPost, r.Method)
   845  				w.WriteHeader(test.responseStatus)
   846  				_, err := w.Write([]byte(test.responseBody))
   847  				assert.NoError(t, err)
   848  
   849  				if len(test.expectedRequestBody) > 0 {
   850  					body, err := ioutil.ReadAll(r.Body)
   851  					require.NoError(t, err)
   852  					assert.Equal(t, test.expectedRequestBody, string(body))
   853  				}
   854  			}))
   855  			client := mockAPIClient(t, mockServer)
   856  			result, err := client.CloneEdgeWorkerID(context.Background(), test.params)
   857  			if test.withError != nil {
   858  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   859  				return
   860  			}
   861  			require.NoError(t, err)
   862  			assert.Equal(t, test.expectedResponse, result)
   863  		})
   864  	}
   865  }
   866  
   867  func TestDeleteEdgeWorkerIDRequest_Validate(t *testing.T) {
   868  	tests := map[string]struct {
   869  		request   DeleteEdgeWorkerIDRequest
   870  		withError bool
   871  	}{
   872  		"empty id": {
   873  			request:   DeleteEdgeWorkerIDRequest{},
   874  			withError: true,
   875  		},
   876  		"ok": {
   877  			request: DeleteEdgeWorkerIDRequest{EdgeWorkerID: 1},
   878  		},
   879  	}
   880  	for name, test := range tests {
   881  		t.Run(name, func(t *testing.T) {
   882  			err := test.request.Validate()
   883  			if test.withError {
   884  				require.Error(t, err)
   885  				return
   886  			}
   887  			require.NoError(t, err)
   888  		})
   889  	}
   890  }
   891  
   892  func TestEdgeworkers_DeleteEdgeWorkerID(t *testing.T) {
   893  	tests := map[string]struct {
   894  		params         DeleteEdgeWorkerIDRequest
   895  		withError      error
   896  		expectedPath   string
   897  		responseStatus int
   898  		responseBody   string
   899  	}{
   900  		"204 Deleted": {
   901  			params:         DeleteEdgeWorkerIDRequest{EdgeWorkerID: 1},
   902  			expectedPath:   "/edgeworkers/v1/ids/1",
   903  			responseStatus: http.StatusNoContent,
   904  		},
   905  		"404 Not Found": {
   906  			params:         DeleteEdgeWorkerIDRequest{EdgeWorkerID: 1},
   907  			expectedPath:   "/edgeworkers/v1/ids/1",
   908  			responseStatus: http.StatusNotFound,
   909  			responseBody: `
   910  {
   911      "type": "/edgeworkers/error-types/edgeworkers-not-found",
   912      "title": "The given resource could not be found.",
   913      "detail": "Unable to delete this EdgeWorker ID",
   914      "instance": "/edgeworkers/error-instances/da246328-ed4a-4e5f-bed3-44e57f9ba7ef",
   915      "status": 404,
   916      "errorCode": "EW2002"
   917  }`,
   918  			withError: &Error{
   919  				Type:      "/edgeworkers/error-types/edgeworkers-not-found",
   920  				Title:     "The given resource could not be found.",
   921  				Detail:    "Unable to delete this EdgeWorker ID",
   922  				Instance:  "/edgeworkers/error-instances/da246328-ed4a-4e5f-bed3-44e57f9ba7ef",
   923  				Status:    404,
   924  				ErrorCode: "EW2002",
   925  			},
   926  		},
   927  		"500 internal server error": {
   928  			params:         DeleteEdgeWorkerIDRequest{EdgeWorkerID: 1},
   929  			expectedPath:   "/edgeworkers/v1/ids/1",
   930  			responseStatus: http.StatusInternalServerError,
   931  			responseBody: `
   932  {
   933    "type": "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   934    "title": "Server Error",
   935    "status": 500,
   936    "instance": "host_name/edgeworkers/v1/ids/1",
   937    "method": "DELETE",
   938    "serverIp": "104.81.220.111",
   939    "clientIp": "89.64.55.111",
   940    "requestId": "a73affa111",
   941    "requestTime": "2021-12-17T16:32:37Z"
   942  }`,
   943  			withError: &Error{
   944  				Type:        "https://problems.luna-dev.akamaiapis.net/-/resource-impl/forward-origin-error",
   945  				Title:       "Server Error",
   946  				Status:      500,
   947  				Instance:    "host_name/edgeworkers/v1/ids/1",
   948  				Method:      "DELETE",
   949  				ServerIP:    "104.81.220.111",
   950  				ClientIP:    "89.64.55.111",
   951  				RequestID:   "a73affa111",
   952  				RequestTime: "2021-12-17T16:32:37Z",
   953  			},
   954  		},
   955  	}
   956  	for name, test := range tests {
   957  		t.Run(name, func(t *testing.T) {
   958  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   959  				assert.Equal(t, test.expectedPath, r.URL.String())
   960  				assert.Equal(t, http.MethodDelete, r.Method)
   961  				w.WriteHeader(test.responseStatus)
   962  				_, err := w.Write([]byte(test.responseBody))
   963  				assert.NoError(t, err)
   964  			}))
   965  			client := mockAPIClient(t, mockServer)
   966  			err := client.DeleteEdgeWorkerID(context.Background(), test.params)
   967  			if test.withError != nil {
   968  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   969  				assert.Contains(t, err.Error(), strconv.FormatInt(int64(test.responseStatus), 10))
   970  				return
   971  			}
   972  			require.NoError(t, err)
   973  		})
   974  	}
   975  }