github.com/akamai/AkamaiOPEN-edgegrid-golang/v2@v2.17.0/pkg/edgeworkers/activations_test.go (about)

     1  package edgeworkers
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"regexp"
     9  	"testing"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestListActivations(t *testing.T) {
    16  	tests := map[string]struct {
    17  		params           ListActivationsRequest
    18  		responseStatus   int
    19  		responseBody     string
    20  		expectedPath     string
    21  		expectedResponse *ListActivationsResponse
    22  		withError        error
    23  	}{
    24  		"200 OK": {
    25  			params: ListActivationsRequest{
    26  				EdgeWorkerID: 42,
    27  			},
    28  			responseStatus: http.StatusOK,
    29  			responseBody: `
    30  {
    31      "activations": [
    32          {
    33              "edgeWorkerId": 42,
    34              "version": "2",
    35              "activationId": 3,
    36              "accountId": "B-M-1KQK3WU",
    37              "status": "PENDING",
    38              "network": "PRODUCTION",
    39              "createdBy": "jdoe",
    40              "createdTime": "2018-07-09T09:03:28Z",
    41              "lastModifiedTime": "2018-07-09T09:04:42Z"
    42          },
    43          {
    44              "edgeWorkerId": 42,
    45              "version": "1",
    46              "activationId": 1,
    47              "accountId": "B-M-1KQK3WU",
    48              "status": "IN_PROGRESS",
    49              "network": "STAGING",
    50              "createdBy": "jsmith",
    51              "createdTime": "2018-07-09T08:13:54Z",
    52              "lastModifiedTime": "2018-07-09T08:35:02Z"
    53          }
    54      ]
    55  }`,
    56  			expectedPath: "/edgeworkers/v1/ids/42/activations",
    57  			expectedResponse: &ListActivationsResponse{
    58  				Activations: []Activation{
    59  					{
    60  						AccountID:        "B-M-1KQK3WU",
    61  						ActivationID:     3,
    62  						CreatedBy:        "jdoe",
    63  						CreatedTime:      "2018-07-09T09:03:28Z",
    64  						EdgeWorkerID:     42,
    65  						LastModifiedTime: "2018-07-09T09:04:42Z",
    66  						Network:          "PRODUCTION",
    67  						Status:           "PENDING",
    68  						Version:          "2",
    69  					},
    70  					{
    71  						AccountID:        "B-M-1KQK3WU",
    72  						ActivationID:     1,
    73  						CreatedBy:        "jsmith",
    74  						CreatedTime:      "2018-07-09T08:13:54Z",
    75  						EdgeWorkerID:     42,
    76  						LastModifiedTime: "2018-07-09T08:35:02Z",
    77  						Network:          "STAGING",
    78  						Status:           "IN_PROGRESS",
    79  						Version:          "1",
    80  					},
    81  				},
    82  			},
    83  		},
    84  		"200 OK with version query": {
    85  			params: ListActivationsRequest{
    86  				EdgeWorkerID: 42,
    87  				Version:      "1",
    88  			},
    89  			responseStatus: http.StatusOK,
    90  			responseBody: `
    91  {
    92      "activations": [
    93          {
    94              "edgeWorkerId": 42,
    95              "version": "1",
    96              "activationId": 1,
    97              "accountId": "B-M-1KQK3WU",
    98              "status": "IN_PROGRESS",
    99              "network": "STAGING",
   100              "createdBy": "jsmith",
   101              "createdTime": "2018-07-09T08:13:54Z",
   102              "lastModifiedTime": "2018-07-09T08:35:02Z"
   103          }
   104      ]
   105  }`,
   106  			expectedPath: "/edgeworkers/v1/ids/42/activations?version=1",
   107  			expectedResponse: &ListActivationsResponse{
   108  				Activations: []Activation{
   109  					{
   110  						AccountID:        "B-M-1KQK3WU",
   111  						ActivationID:     1,
   112  						CreatedBy:        "jsmith",
   113  						CreatedTime:      "2018-07-09T08:13:54Z",
   114  						EdgeWorkerID:     42,
   115  						LastModifiedTime: "2018-07-09T08:35:02Z",
   116  						Network:          "STAGING",
   117  						Status:           "IN_PROGRESS",
   118  						Version:          "1",
   119  					},
   120  				},
   121  			},
   122  		},
   123  		"500 internal server error": {
   124  			params: ListActivationsRequest{
   125  				EdgeWorkerID: 42,
   126  			},
   127  			responseStatus: http.StatusInternalServerError,
   128  			responseBody: `
   129  {
   130      "type": "/edgeworkers/error-types/edgeworkers-server-error",
   131      "title": "An unexpected error has occurred.",
   132      "detail": "Error processing request",
   133      "instance": "/edgeworkers/error-instances/abc",
   134      "status": 500,
   135      "errorCode": "EW4303"
   136  }`,
   137  			expectedPath: "/edgeworkers/v1/ids/42/activations",
   138  			withError: &Error{
   139  				Type:      "/edgeworkers/error-types/edgeworkers-server-error",
   140  				Title:     "An unexpected error has occurred.",
   141  				Detail:    "Error processing request",
   142  				Instance:  "/edgeworkers/error-instances/abc",
   143  				Status:    500,
   144  				ErrorCode: "EW4303",
   145  			},
   146  		},
   147  		"missing edge worker id": {
   148  			params:    ListActivationsRequest{},
   149  			withError: ErrStructValidation,
   150  		},
   151  	}
   152  
   153  	for name, test := range tests {
   154  		t.Run(name, func(t *testing.T) {
   155  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   156  				assert.Equal(t, test.expectedPath, r.URL.String())
   157  				assert.Equal(t, http.MethodGet, r.Method)
   158  				w.WriteHeader(test.responseStatus)
   159  				_, err := w.Write([]byte(test.responseBody))
   160  				assert.NoError(t, err)
   161  			}))
   162  			client := mockAPIClient(t, mockServer)
   163  			result, err := client.ListActivations(context.Background(), test.params)
   164  			if test.withError != nil {
   165  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   166  				return
   167  			}
   168  			require.NoError(t, err)
   169  			assert.Equal(t, test.expectedResponse, result)
   170  		})
   171  	}
   172  }
   173  
   174  func TestGetActivation(t *testing.T) {
   175  	tests := map[string]struct {
   176  		params           GetActivationRequest
   177  		responseStatus   int
   178  		responseBody     string
   179  		expectedPath     string
   180  		expectedResponse *Activation
   181  		withError        error
   182  	}{
   183  		"200 OK": {
   184  			params: GetActivationRequest{
   185  				EdgeWorkerID: 42,
   186  				ActivationID: 1,
   187  			},
   188  			responseStatus: http.StatusOK,
   189  			responseBody: `
   190  {
   191  	"edgeWorkerId": 42,
   192  	"version": "1",
   193  	"activationId": 1,
   194  	"accountId": "B-M-1KQK3WU",
   195  	"status": "IN_PROGRESS",
   196  	"network": "STAGING",
   197  	"createdBy": "jsmith",
   198  	"createdTime": "2018-07-09T08:13:54Z",
   199  	"lastModifiedTime": "2018-07-09T08:35:02Z"
   200  }`,
   201  			expectedPath: "/edgeworkers/v1/ids/42/activations/1",
   202  			expectedResponse: &Activation{
   203  				AccountID:        "B-M-1KQK3WU",
   204  				ActivationID:     1,
   205  				CreatedBy:        "jsmith",
   206  				CreatedTime:      "2018-07-09T08:13:54Z",
   207  				EdgeWorkerID:     42,
   208  				LastModifiedTime: "2018-07-09T08:35:02Z",
   209  				Network:          "STAGING",
   210  				Status:           "IN_PROGRESS",
   211  				Version:          "1",
   212  			},
   213  		},
   214  		"500 internal server error": {
   215  			params: GetActivationRequest{
   216  				EdgeWorkerID: 42,
   217  				ActivationID: 1,
   218  			},
   219  			responseStatus: http.StatusInternalServerError,
   220  			responseBody: `
   221  {
   222      "type": "/edgeworkers/error-types/edgeworkers-server-error",
   223      "title": "An unexpected error has occurred.",
   224      "detail": "Error processing request",
   225      "instance": "/edgeworkers/error-instances/abc",
   226      "status": 500,
   227      "errorCode": "EW4303"
   228  }`,
   229  			expectedPath: "/edgeworkers/v1/ids/42/activations/1",
   230  			withError: &Error{
   231  				Type:      "/edgeworkers/error-types/edgeworkers-server-error",
   232  				Title:     "An unexpected error has occurred.",
   233  				Detail:    "Error processing request",
   234  				Instance:  "/edgeworkers/error-instances/abc",
   235  				Status:    500,
   236  				ErrorCode: "EW4303",
   237  			},
   238  		},
   239  		"missing activation id": {
   240  			params: GetActivationRequest{
   241  				EdgeWorkerID: 42,
   242  			},
   243  			withError: ErrStructValidation,
   244  		},
   245  	}
   246  
   247  	for name, test := range tests {
   248  		t.Run(name, func(t *testing.T) {
   249  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   250  				assert.Equal(t, test.expectedPath, r.URL.String())
   251  				assert.Equal(t, http.MethodGet, r.Method)
   252  				w.WriteHeader(test.responseStatus)
   253  				_, err := w.Write([]byte(test.responseBody))
   254  				assert.NoError(t, err)
   255  			}))
   256  			client := mockAPIClient(t, mockServer)
   257  			result, err := client.GetActivation(context.Background(), test.params)
   258  			if test.withError != nil {
   259  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   260  				return
   261  			}
   262  			require.NoError(t, err)
   263  			assert.Equal(t, test.expectedResponse, result)
   264  		})
   265  	}
   266  }
   267  
   268  func TestActivateVersion(t *testing.T) {
   269  	tests := map[string]struct {
   270  		params           ActivateVersionRequest
   271  		responseStatus   int
   272  		responseBody     string
   273  		expectedPath     string
   274  		expectedResponse *Activation
   275  		withError        error
   276  	}{
   277  		"200 OK": {
   278  			params: ActivateVersionRequest{
   279  				EdgeWorkerID: 42,
   280  				ActivateVersion: ActivateVersion{
   281  					Network: "STAGING",
   282  					Version: "1",
   283  				},
   284  			},
   285  			responseStatus: http.StatusCreated,
   286  			responseBody: `
   287  {
   288  	"edgeWorkerId": 42,
   289  	"version": "1",
   290  	"activationId": 1,
   291  	"accountId": "B-M-1KQK3WU",
   292  	"status": "PRESUBMIT",
   293  	"network": "STAGING",
   294  	"createdBy": "jsmith",
   295  	"createdTime": "2018-07-09T08:13:54Z",
   296  	"lastModifiedTime": "2018-07-09T08:35:02Z"
   297  }`,
   298  			expectedPath: "/edgeworkers/v1/ids/42/activations",
   299  			expectedResponse: &Activation{
   300  				AccountID:        "B-M-1KQK3WU",
   301  				ActivationID:     1,
   302  				CreatedBy:        "jsmith",
   303  				CreatedTime:      "2018-07-09T08:13:54Z",
   304  				EdgeWorkerID:     42,
   305  				LastModifiedTime: "2018-07-09T08:35:02Z",
   306  				Network:          "STAGING",
   307  				Status:           "PRESUBMIT",
   308  				Version:          "1",
   309  			},
   310  		},
   311  		"500 internal server error": {
   312  			params: ActivateVersionRequest{
   313  				EdgeWorkerID: 42,
   314  				ActivateVersion: ActivateVersion{
   315  					Network: "STAGING",
   316  					Version: "1",
   317  				},
   318  			},
   319  			responseStatus: http.StatusInternalServerError,
   320  			responseBody: `
   321  {
   322      "type": "/edgeworkers/error-types/edgeworkers-server-error",
   323      "title": "An unexpected error has occurred.",
   324      "detail": "Error processing request",
   325      "instance": "/edgeworkers/error-instances/abc",
   326      "status": 500,
   327      "errorCode": "EW4303"
   328  }`,
   329  			expectedPath: "/edgeworkers/v1/ids/42/activations",
   330  			withError: &Error{
   331  				Type:      "/edgeworkers/error-types/edgeworkers-server-error",
   332  				Title:     "An unexpected error has occurred.",
   333  				Detail:    "Error processing request",
   334  				Instance:  "/edgeworkers/error-instances/abc",
   335  				Status:    500,
   336  				ErrorCode: "EW4303",
   337  			},
   338  		},
   339  		"missing edge worker id": {
   340  			params: ActivateVersionRequest{
   341  				ActivateVersion: ActivateVersion{
   342  					Network: ActivationNetworkStaging,
   343  					Version: "1",
   344  				},
   345  			},
   346  			withError: ErrStructValidation,
   347  		},
   348  		"invalid network": {
   349  			params: ActivateVersionRequest{
   350  				ActivateVersion: ActivateVersion{
   351  					Network: "invalid",
   352  					Version: "1",
   353  				},
   354  			},
   355  			withError: ErrStructValidation,
   356  		},
   357  	}
   358  
   359  	for name, test := range tests {
   360  		t.Run(name, func(t *testing.T) {
   361  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   362  				assert.Equal(t, test.expectedPath, r.URL.String())
   363  				assert.Equal(t, http.MethodPost, r.Method)
   364  				w.WriteHeader(test.responseStatus)
   365  				_, err := w.Write([]byte(test.responseBody))
   366  				assert.NoError(t, err)
   367  			}))
   368  			client := mockAPIClient(t, mockServer)
   369  			result, err := client.ActivateVersion(context.Background(), test.params)
   370  			if test.withError != nil {
   371  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   372  				return
   373  			}
   374  			require.NoError(t, err)
   375  			assert.Equal(t, test.expectedResponse, result)
   376  		})
   377  	}
   378  }
   379  
   380  func TestEdgeWorkerActivateVersionRequest_Validate(t *testing.T) {
   381  	tests := map[string]struct {
   382  		params ActivateVersionRequest
   383  		errors *regexp.Regexp
   384  	}{
   385  		"no EW ID": {
   386  			params: ActivateVersionRequest{
   387  				ActivateVersion: ActivateVersion{
   388  					Version: "--",
   389  					Network: ActivationNetworkProduction,
   390  				},
   391  			},
   392  			errors: regexp.MustCompile(`EdgeWorkerID.+cannot be blank.+`),
   393  		},
   394  		"no version": {
   395  			params: ActivateVersionRequest{
   396  				EdgeWorkerID: 1,
   397  				ActivateVersion: ActivateVersion{
   398  					Network: ActivationNetworkProduction,
   399  				},
   400  			},
   401  			errors: regexp.MustCompile(`ActivateVersion:.+Version:.+cannot be blank.+`),
   402  		},
   403  		"bad network": {
   404  			params: ActivateVersionRequest{
   405  				EdgeWorkerID: 1,
   406  				ActivateVersion: ActivateVersion{
   407  					Network: "-asdfa",
   408  					Version: "a",
   409  				},
   410  			},
   411  			errors: regexp.MustCompile(`ActivateVersion:.+Network:.+value '-asdfa' is invalid. Must be one of: 'STAGING' or 'PRODUCTION'.+`),
   412  		},
   413  		"no network": {
   414  			params: ActivateVersionRequest{
   415  				EdgeWorkerID: 1,
   416  				ActivateVersion: ActivateVersion{
   417  					Version: "a",
   418  				},
   419  			},
   420  			errors: regexp.MustCompile(`ActivateVersion:.+Network:.+cannot be blank.+`),
   421  		},
   422  		"ok": {
   423  			params: ActivateVersionRequest{
   424  				EdgeWorkerID: 1,
   425  				ActivateVersion: ActivateVersion{
   426  					Version: "asdf",
   427  					Network: ActivationNetworkStaging,
   428  				},
   429  			},
   430  		},
   431  	}
   432  	for name, test := range tests {
   433  		t.Run(name, func(t *testing.T) {
   434  			err := test.params.Validate()
   435  			if test.errors != nil {
   436  				require.Error(t, err)
   437  				assert.Regexp(t, test.errors, err.Error())
   438  				return
   439  			}
   440  			require.NoError(t, err)
   441  		})
   442  	}
   443  }
   444  
   445  func TestCancelActivation(t *testing.T) {
   446  	tests := map[string]struct {
   447  		params           CancelActivationRequest
   448  		responseStatus   int
   449  		responseBody     string
   450  		expectedPath     string
   451  		expectedResponse *Activation
   452  		withError        error
   453  	}{
   454  		"200 OK": {
   455  			params: CancelActivationRequest{
   456  				EdgeWorkerID: 42,
   457  				ActivationID: 1,
   458  			},
   459  			responseStatus: http.StatusOK,
   460  			responseBody: `
   461  {
   462  	"edgeWorkerId": 42,
   463  	"version": "1",
   464  	"activationId": 1,
   465  	"accountId": "B-M-1KQK3WU",
   466  	"status": "CANCELED",
   467  	"network": "STAGING",
   468  	"createdBy": "jsmith",
   469  	"createdTime": "2018-07-09T08:13:54Z",
   470  	"lastModifiedTime": "2018-07-09T08:35:02Z"
   471  }`,
   472  			expectedPath: "/edgeworkers/v1/ids/42/activations/1",
   473  			expectedResponse: &Activation{
   474  				AccountID:        "B-M-1KQK3WU",
   475  				ActivationID:     1,
   476  				CreatedBy:        "jsmith",
   477  				CreatedTime:      "2018-07-09T08:13:54Z",
   478  				EdgeWorkerID:     42,
   479  				LastModifiedTime: "2018-07-09T08:35:02Z",
   480  				Network:          "STAGING",
   481  				Status:           "CANCELED",
   482  				Version:          "1",
   483  			},
   484  		},
   485  		"500 internal server error": {
   486  			params: CancelActivationRequest{
   487  				EdgeWorkerID: 42,
   488  				ActivationID: 1,
   489  			},
   490  			responseStatus: http.StatusInternalServerError,
   491  			responseBody: `
   492  {
   493      "type": "/edgeworkers/error-types/edgeworkers-server-error",
   494      "title": "An unexpected error has occurred.",
   495      "detail": "Error processing request",
   496      "instance": "/edgeworkers/error-instances/abc",
   497      "status": 500,
   498      "errorCode": "EW4303"
   499  }`,
   500  			expectedPath: "/edgeworkers/v1/ids/42/activations/1",
   501  			withError: &Error{
   502  				Type:      "/edgeworkers/error-types/edgeworkers-server-error",
   503  				Title:     "An unexpected error has occurred.",
   504  				Detail:    "Error processing request",
   505  				Instance:  "/edgeworkers/error-instances/abc",
   506  				Status:    500,
   507  				ErrorCode: "EW4303",
   508  			},
   509  		},
   510  		"missing activation id": {
   511  			params: CancelActivationRequest{
   512  				EdgeWorkerID: 42,
   513  			},
   514  			withError: ErrStructValidation,
   515  		},
   516  	}
   517  
   518  	for name, test := range tests {
   519  		t.Run(name, func(t *testing.T) {
   520  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   521  				assert.Equal(t, test.expectedPath, r.URL.String())
   522  				assert.Equal(t, http.MethodDelete, r.Method)
   523  				w.WriteHeader(test.responseStatus)
   524  				_, err := w.Write([]byte(test.responseBody))
   525  				assert.NoError(t, err)
   526  			}))
   527  			client := mockAPIClient(t, mockServer)
   528  			result, err := client.CancelPendingActivation(context.Background(), test.params)
   529  			if test.withError != nil {
   530  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   531  				return
   532  			}
   533  			require.NoError(t, err)
   534  			assert.Equal(t, test.expectedResponse, result)
   535  		})
   536  	}
   537  }