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

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