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

     1  package cloudlets
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"testing"
     9  
    10  	"github.com/akamai/AkamaiOPEN-edgegrid-golang/v8/pkg/tools"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestGetLoadBalancerActivations(t *testing.T) {
    17  	tests := map[string]struct {
    18  		params           ListLoadBalancerActivationsRequest
    19  		originID         string
    20  		responseStatus   int
    21  		responseBody     string
    22  		expectedPath     string
    23  		expectedResponse []LoadBalancerActivation
    24  		withError        func(*testing.T, error)
    25  	}{
    26  		"200 OK": {
    27  			params: ListLoadBalancerActivationsRequest{
    28  				OriginID: "clorigin1",
    29  			},
    30  			responseStatus: http.StatusOK,
    31  			responseBody: `
    32  				[
    33  					{
    34  						"activatedBy": "jjones",
    35  						"activatedDate": "2016-05-03T18:41:34.251Z",
    36  						"network": "PRODUCTION",
    37  						"originId": "clorigin1",
    38  						"status": "active",
    39  						"version": 1
    40  					},
    41  					{
    42  						"activatedBy": "ejnovak",
    43  						"activatedDate": "2016-04-07T18:41:34.461Z",
    44  						"network": "STAGING",
    45  						"originId": "clorigin1",
    46  						"status": "active",
    47  						"version": 2
    48  					}
    49  				]
    50  			`,
    51  			expectedPath: "/cloudlets/api/v2/origins/clorigin1/activations",
    52  			expectedResponse: []LoadBalancerActivation{
    53  				{
    54  					ActivatedBy:   "jjones",
    55  					ActivatedDate: "2016-05-03T18:41:34.251Z",
    56  					Network:       LoadBalancerActivationNetworkProduction,
    57  					OriginID:      "clorigin1",
    58  					Status:        LoadBalancerActivationStatusActive,
    59  					Version:       1,
    60  				},
    61  				{
    62  					ActivatedBy:   "ejnovak",
    63  					ActivatedDate: "2016-04-07T18:41:34.461Z",
    64  					Network:       LoadBalancerActivationNetworkStaging,
    65  					OriginID:      "clorigin1",
    66  					Status:        LoadBalancerActivationStatusActive,
    67  					Version:       2,
    68  				},
    69  			},
    70  		},
    71  		"200 OK with optional params": {
    72  			params: ListLoadBalancerActivationsRequest{
    73  				OriginID:   "clorigin1",
    74  				Network:    "prod",
    75  				LatestOnly: true,
    76  				PageSize:   tools.Int64Ptr(3),
    77  				Page:       tools.Int64Ptr(1),
    78  			},
    79  			responseStatus: http.StatusOK,
    80  			responseBody: `
    81  				[
    82  					{
    83  						"activatedBy": "jjones",
    84  						"activatedDate": "2016-05-03T18:41:34.251Z",
    85  						"network": "PRODUCTION",
    86  						"originId": "clorigin1",
    87  						"status": "active",
    88  						"version": 1
    89  					},
    90  					{
    91  						"activatedBy": "ejnovak",
    92  						"activatedDate": "2016-05-07T18:41:34.461Z",
    93  						"network": "PRODUCTION",
    94  						"originId": "clorigin1",
    95  						"status": "deactivated",
    96  						"version": 2
    97  					}
    98  				]
    99  			`,
   100  			expectedPath: "/cloudlets/api/v2/origins/clorigin1/activations?latestOnly=true&network=prod&page=1&pageSize=3",
   101  			expectedResponse: []LoadBalancerActivation{
   102  				{
   103  					ActivatedBy:   "jjones",
   104  					ActivatedDate: "2016-05-03T18:41:34.251Z",
   105  					Network:       LoadBalancerActivationNetworkProduction,
   106  					OriginID:      "clorigin1",
   107  					Status:        LoadBalancerActivationStatusActive,
   108  					Version:       1,
   109  				},
   110  				{
   111  					ActivatedBy:   "ejnovak",
   112  					ActivatedDate: "2016-05-07T18:41:34.461Z",
   113  					Network:       LoadBalancerActivationNetworkProduction,
   114  					OriginID:      "clorigin1",
   115  					Status:        LoadBalancerActivationStatusDeactivated,
   116  					Version:       2,
   117  				},
   118  			},
   119  		},
   120  		"500 Internal Server Error": {
   121  			params: ListLoadBalancerActivationsRequest{
   122  				OriginID: "clorigin1",
   123  			},
   124  			responseStatus: http.StatusInternalServerError,
   125  			responseBody: `
   126  				{
   127  					"type": "internal_error",
   128  					"title": "Internal Server Error",
   129  					"detail": "Error making request",
   130  					"status": 500
   131  				}
   132  			`,
   133  			expectedPath: "/cloudlets/api/v2/origins/clorigin1/activations",
   134  			withError: func(t *testing.T, err error) {
   135  				want := &Error{
   136  					Type:       "internal_error",
   137  					Title:      "Internal Server Error",
   138  					Detail:     "Error making request",
   139  					StatusCode: http.StatusInternalServerError,
   140  				}
   141  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   142  			},
   143  		},
   144  		"Validation Errors": {
   145  			params: ListLoadBalancerActivationsRequest{
   146  				Network: "PRODUCTION",
   147  			},
   148  			responseStatus: http.StatusInternalServerError,
   149  			withError: func(t *testing.T, err error) {
   150  				assert.Containsf(t, err.Error(), "Network: value 'PRODUCTION' is invalid. Must be one of: 'staging', 'prod' or '' (empty)", "want: %s; got: %s", ErrStructValidation, err)
   151  				assert.Containsf(t, err.Error(), "OriginID: cannot be blank", "want: %s; got: %s", ErrStructValidation, err)
   152  				assert.True(t, errors.Is(err, ErrStructValidation), "want: %s; got: %s", ErrStructValidation, err)
   153  			},
   154  		},
   155  	}
   156  
   157  	for name, test := range tests {
   158  		t.Run(name, func(t *testing.T) {
   159  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   160  				assert.Equal(t, test.expectedPath, r.URL.String())
   161  				assert.Equal(t, http.MethodGet, r.Method)
   162  				w.WriteHeader(test.responseStatus)
   163  				_, err := w.Write([]byte(test.responseBody))
   164  				assert.NoError(t, err)
   165  			}))
   166  			client := mockAPIClient(t, mockServer)
   167  			result, err := client.ListLoadBalancerActivations(context.Background(), test.params)
   168  			if test.withError != nil {
   169  				test.withError(t, err)
   170  				return
   171  			}
   172  			require.NoError(t, err)
   173  			assert.Equal(t, test.expectedResponse, result)
   174  		})
   175  	}
   176  }
   177  
   178  func TestActivateLoadBalancerVersion(t *testing.T) {
   179  	tests := map[string]struct {
   180  		params           ActivateLoadBalancerVersionRequest
   181  		responseStatus   int
   182  		responseBody     string
   183  		expectedPath     string
   184  		expectedResponse *LoadBalancerActivation
   185  		withError        func(*testing.T, error)
   186  	}{
   187  		"200 OK": {
   188  			params: ActivateLoadBalancerVersionRequest{
   189  				OriginID: "clorigin1",
   190  				Async:    false,
   191  				LoadBalancerVersionActivation: LoadBalancerVersionActivation{
   192  					Network: LoadBalancerActivationNetworkProduction,
   193  					DryRun:  false,
   194  					Version: 1,
   195  				},
   196  			},
   197  			responseStatus: http.StatusOK,
   198  			responseBody: `
   199  				{
   200  					"activatedBy": "jjones",
   201  					"activatedDate": "2016-04-07T18:41:34.251Z",
   202  					"network": "PRODUCTION",
   203  					"originId": "clorigin1",
   204  					"status": "active",
   205  					"dryrun": false,
   206  					"version": 1
   207  				}
   208  			`,
   209  			expectedPath: "/cloudlets/api/v2/origins/clorigin1/activations?async=false",
   210  			expectedResponse: &LoadBalancerActivation{
   211  				ActivatedBy:   "jjones",
   212  				ActivatedDate: "2016-04-07T18:41:34.251Z",
   213  				Network:       LoadBalancerActivationNetworkProduction,
   214  				OriginID:      "clorigin1",
   215  				Status:        LoadBalancerActivationStatusActive,
   216  				Version:       1,
   217  				DryRun:        false,
   218  			},
   219  		},
   220  		"500 Internal Server Error": {
   221  			params: ActivateLoadBalancerVersionRequest{
   222  				OriginID: "clorigin1",
   223  				Async:    false,
   224  				LoadBalancerVersionActivation: LoadBalancerVersionActivation{
   225  					Network: LoadBalancerActivationNetworkStaging,
   226  					DryRun:  false,
   227  					Version: 1,
   228  				},
   229  			},
   230  			responseStatus: http.StatusInternalServerError,
   231  			responseBody: `
   232  				{
   233  					"type": "internal_error",
   234  					"title": "Internal Server Error",
   235  					"detail": "Error making request",
   236  					"status": 500
   237  				}
   238  			`,
   239  			expectedPath: "/cloudlets/api/v2/origins/clorigin1/activations?async=false",
   240  			withError: func(t *testing.T, err error) {
   241  				want := &Error{
   242  					Type:       "internal_error",
   243  					Title:      "Internal Server Error",
   244  					Detail:     "Error making request",
   245  					StatusCode: http.StatusInternalServerError,
   246  				}
   247  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   248  			},
   249  		},
   250  		"Validation Errors": {
   251  			params: ActivateLoadBalancerVersionRequest{
   252  				OriginID: "",
   253  				Async:    false,
   254  				LoadBalancerVersionActivation: LoadBalancerVersionActivation{
   255  					Network: "",
   256  					DryRun:  false,
   257  					Version: -1,
   258  				},
   259  			},
   260  			responseStatus: http.StatusInternalServerError,
   261  			withError: func(t *testing.T, err error) {
   262  				assert.Containsf(t, err.Error(), "Network: cannot be blank", "want: %s; got: %s", ErrStructValidation, err)
   263  				assert.Containsf(t, err.Error(), "OriginID: cannot be blank", "want: %s; got: %s", ErrStructValidation, err)
   264  				assert.Containsf(t, err.Error(), "Version: must be no less than 0", "want: %s; got: %s", ErrStructValidation, err)
   265  				assert.True(t, errors.Is(err, ErrStructValidation), "want: %s; got: %s", ErrStructValidation, err)
   266  			},
   267  		},
   268  	}
   269  	for name, test := range tests {
   270  		t.Run(name, func(t *testing.T) {
   271  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   272  				assert.Equal(t, test.expectedPath, r.URL.String())
   273  				assert.Equal(t, http.MethodPost, r.Method)
   274  				w.WriteHeader(test.responseStatus)
   275  				_, err := w.Write([]byte(test.responseBody))
   276  				assert.NoError(t, err)
   277  			}))
   278  			client := mockAPIClient(t, mockServer)
   279  			result, err := client.ActivateLoadBalancerVersion(context.Background(), test.params)
   280  			if test.withError != nil {
   281  				test.withError(t, err)
   282  				return
   283  			}
   284  			require.NoError(t, err)
   285  			assert.Equal(t, test.expectedResponse, result)
   286  		})
   287  	}
   288  }