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

     1  package gtm
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"encoding/json"
     7  	"errors"
     8  	"net/http"
     9  	"net/http/httptest"
    10  	"testing"
    11  
    12  	"github.com/akamai/AkamaiOPEN-edgegrid-golang/v8/pkg/session"
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func TestGTM_ListDatacenters(t *testing.T) {
    18  	var result DatacenterList
    19  
    20  	respData, err := loadTestData("TestGTM_ListDatacenters.resp.json")
    21  	if err != nil {
    22  		t.Fatal(err)
    23  	}
    24  
    25  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
    26  		t.Fatal(err)
    27  	}
    28  
    29  	tests := map[string]struct {
    30  		domainName       string
    31  		responseStatus   int
    32  		responseBody     string
    33  		expectedPath     string
    34  		expectedResponse []*Datacenter
    35  		withError        error
    36  		headers          http.Header
    37  	}{
    38  		"200 OK": {
    39  			domainName: "example.akadns.net",
    40  			headers: http.Header{
    41  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
    42  			},
    43  			responseStatus:   http.StatusOK,
    44  			responseBody:     string(respData),
    45  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters",
    46  			expectedResponse: result.DatacenterItems,
    47  		},
    48  		"500 internal server error": {
    49  			domainName:     "example.akadns.net",
    50  			headers:        http.Header{},
    51  			responseStatus: http.StatusInternalServerError,
    52  			responseBody: `
    53  {
    54      "type": "internal_error",
    55      "title": "Internal Server Error",
    56      "detail": "Error fetching datacenters"
    57  }`,
    58  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters",
    59  			withError: &Error{
    60  				Type:       "internal_error",
    61  				Title:      "Internal Server Error",
    62  				Detail:     "Error fetching datacenters",
    63  				StatusCode: http.StatusInternalServerError,
    64  			},
    65  		},
    66  	}
    67  
    68  	for name, test := range tests {
    69  		t.Run(name, func(t *testing.T) {
    70  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    71  				assert.Equal(t, test.expectedPath, r.URL.String())
    72  				assert.Equal(t, http.MethodGet, r.Method)
    73  				w.WriteHeader(test.responseStatus)
    74  				_, err := w.Write([]byte(test.responseBody))
    75  				assert.NoError(t, err)
    76  			}))
    77  			client := mockAPIClient(t, mockServer)
    78  			result, err := client.ListDatacenters(
    79  				session.ContextWithOptions(
    80  					context.Background(),
    81  					session.WithContextHeaders(test.headers)), test.domainName)
    82  			if test.withError != nil {
    83  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
    84  				return
    85  			}
    86  			require.NoError(t, err)
    87  			assert.Equal(t, test.expectedResponse, result)
    88  		})
    89  	}
    90  }
    91  
    92  func TestGTM_GetDatacenter(t *testing.T) {
    93  	var result Datacenter
    94  
    95  	respData, err := loadTestData("TestGTM_GetDatacenter.resp.json")
    96  	if err != nil {
    97  		t.Fatal(err)
    98  	}
    99  
   100  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   101  		t.Fatal(err)
   102  	}
   103  
   104  	tests := map[string]struct {
   105  		id               int
   106  		domainName       string
   107  		responseStatus   int
   108  		responseBody     string
   109  		expectedPath     string
   110  		expectedResponse *Datacenter
   111  		withError        error
   112  		headers          http.Header
   113  	}{
   114  		"200 OK": {
   115  			id:         1,
   116  			domainName: "example.akadns.net",
   117  			headers: http.Header{
   118  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   119  			},
   120  			responseStatus:   http.StatusOK,
   121  			responseBody:     string(respData),
   122  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/1",
   123  			expectedResponse: &result,
   124  		},
   125  		"500 internal server error": {
   126  			id:             1,
   127  			domainName:     "example.akadns.net",
   128  			headers:        http.Header{},
   129  			responseStatus: http.StatusInternalServerError,
   130  			responseBody: `
   131  {
   132      "type": "internal_error",
   133      "title": "Internal Server Error",
   134      "detail": "Error fetching datacenter"
   135  }`,
   136  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/1",
   137  			withError: &Error{
   138  				Type:       "internal_error",
   139  				Title:      "Internal Server Error",
   140  				Detail:     "Error fetching datacenter",
   141  				StatusCode: http.StatusInternalServerError,
   142  			},
   143  		},
   144  	}
   145  
   146  	for name, test := range tests {
   147  		t.Run(name, func(t *testing.T) {
   148  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   149  				assert.Equal(t, test.expectedPath, r.URL.String())
   150  				assert.Equal(t, http.MethodGet, r.Method)
   151  				w.WriteHeader(test.responseStatus)
   152  				_, err := w.Write([]byte(test.responseBody))
   153  				assert.NoError(t, err)
   154  			}))
   155  			client := mockAPIClient(t, mockServer)
   156  			result, err := client.GetDatacenter(
   157  				session.ContextWithOptions(
   158  					context.Background(),
   159  					session.WithContextHeaders(test.headers)), test.id, test.domainName)
   160  			if test.withError != nil {
   161  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   162  				return
   163  			}
   164  			require.NoError(t, err)
   165  			assert.Equal(t, test.expectedResponse, result)
   166  		})
   167  	}
   168  }
   169  
   170  func TestGTM_CreateDatacenter(t *testing.T) {
   171  	var result DatacenterResponse
   172  	var req Datacenter
   173  
   174  	respData, err := loadTestData("TestGTM_CreateDatacenter.resp.json")
   175  	if err != nil {
   176  		t.Fatal(err)
   177  	}
   178  
   179  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   180  		t.Fatal(err)
   181  	}
   182  
   183  	reqData, err := loadTestData("TestGTM_CreateDatacenter.req.json")
   184  	if err != nil {
   185  		t.Fatal(err)
   186  	}
   187  
   188  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   189  		t.Fatal(err)
   190  	}
   191  
   192  	tests := map[string]struct {
   193  		dc               *Datacenter
   194  		domainName       string
   195  		responseStatus   int
   196  		responseBody     string
   197  		expectedPath     string
   198  		expectedResponse *DatacenterResponse
   199  		withError        error
   200  		headers          http.Header
   201  	}{
   202  		"200 OK": {
   203  			dc:         &req,
   204  			domainName: "example.akadns.net",
   205  			headers: http.Header{
   206  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   207  			},
   208  			responseStatus:   http.StatusCreated,
   209  			responseBody:     string(respData),
   210  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters",
   211  			expectedResponse: &result,
   212  		},
   213  		"500 internal server error": {
   214  			dc:             &req,
   215  			domainName:     "example.akadns.net",
   216  			headers:        http.Header{},
   217  			responseStatus: http.StatusInternalServerError,
   218  			responseBody: `
   219  {
   220      "type": "internal_error",
   221      "title": "Internal Server Error",
   222      "detail": "Error creating dc"
   223  }`,
   224  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters",
   225  			withError: &Error{
   226  				Type:       "internal_error",
   227  				Title:      "Internal Server Error",
   228  				Detail:     "Error creating dc",
   229  				StatusCode: http.StatusInternalServerError,
   230  			},
   231  		},
   232  	}
   233  
   234  	for name, test := range tests {
   235  		t.Run(name, func(t *testing.T) {
   236  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   237  				assert.Equal(t, test.expectedPath, r.URL.String())
   238  				assert.Equal(t, http.MethodPost, r.Method)
   239  				w.WriteHeader(test.responseStatus)
   240  				_, err := w.Write([]byte(test.responseBody))
   241  				assert.NoError(t, err)
   242  			}))
   243  			client := mockAPIClient(t, mockServer)
   244  			result, err := client.CreateDatacenter(
   245  				session.ContextWithOptions(
   246  					context.Background(),
   247  					session.WithContextHeaders(test.headers)), test.dc, test.domainName)
   248  			if test.withError != nil {
   249  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   250  				return
   251  			}
   252  			require.NoError(t, err)
   253  			assert.Equal(t, test.expectedResponse, result)
   254  		})
   255  	}
   256  }
   257  
   258  func TestGTM_CreateMapsDefaultDatacenter(t *testing.T) {
   259  	var result DatacenterResponse
   260  
   261  	respData, err := loadTestData("TestGTM_CreateMapsDefaultDatacenter.resp.json")
   262  	if err != nil {
   263  		t.Fatal(err)
   264  	}
   265  
   266  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   267  		t.Fatal(err)
   268  	}
   269  
   270  	tests := map[string]struct {
   271  		domainName       string
   272  		responseStatus   int
   273  		responseBody     string
   274  		expectedPath     string
   275  		expectedResponse *Datacenter
   276  		withError        error
   277  		headers          http.Header
   278  	}{
   279  		"200 OK": {
   280  			domainName: "example.akadns.net",
   281  			headers: http.Header{
   282  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   283  			},
   284  			responseStatus:   http.StatusCreated,
   285  			responseBody:     string(respData),
   286  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/default-datacenter-for-maps",
   287  			expectedResponse: result.Resource,
   288  		},
   289  		"500 internal server error": {
   290  			domainName:     "example.akadns.net",
   291  			headers:        http.Header{},
   292  			responseStatus: http.StatusInternalServerError,
   293  			responseBody: `
   294  {
   295      "type": "internal_error",
   296      "title": "Internal Server Error",
   297      "detail": "Error creating dc"
   298  }`,
   299  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/default-datacenter-for-maps",
   300  			withError: &Error{
   301  				Type:       "internal_error",
   302  				Title:      "Internal Server Error",
   303  				Detail:     "Error creating dc",
   304  				StatusCode: http.StatusInternalServerError,
   305  			},
   306  		},
   307  	}
   308  
   309  	for name, test := range tests {
   310  		t.Run(name, func(t *testing.T) {
   311  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   312  				if r.Method == http.MethodGet {
   313  					w.WriteHeader(http.StatusNotFound)
   314  					_, err = w.Write([]byte(`
   315                                          {
   316                                              "type": "Datacenter",
   317                                              "title": "not found"
   318                                          }`))
   319  					require.NoError(t, err)
   320  					return
   321  				}
   322  				assert.Equal(t, test.expectedPath, r.URL.String())
   323  				assert.Equal(t, http.MethodPost, r.Method)
   324  				w.WriteHeader(test.responseStatus)
   325  				_, err := w.Write([]byte(test.responseBody))
   326  				assert.NoError(t, err)
   327  			}))
   328  			client := mockAPIClient(t, mockServer)
   329  			result, err := client.CreateMapsDefaultDatacenter(
   330  				session.ContextWithOptions(
   331  					context.Background(),
   332  					session.WithContextHeaders(test.headers)), test.domainName)
   333  			if test.withError != nil {
   334  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   335  				return
   336  			}
   337  			require.NoError(t, err)
   338  			assert.Equal(t, test.expectedResponse, result)
   339  		})
   340  	}
   341  }
   342  
   343  func TestGTM_CreateIPv4DefaultDatacenter(t *testing.T) {
   344  	var result DatacenterResponse
   345  
   346  	respData, err := loadTestData("TestGTM_CreateIPv4DefaultDatacenter.resp.json")
   347  	if err != nil {
   348  		t.Fatal(err)
   349  	}
   350  
   351  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   352  		t.Fatal(err)
   353  	}
   354  
   355  	tests := map[string]struct {
   356  		domainName       string
   357  		responseStatus   int
   358  		responseBody     string
   359  		expectedPath     string
   360  		expectedResponse *Datacenter
   361  		withError        error
   362  		headers          http.Header
   363  	}{
   364  		"200 OK": {
   365  			domainName: "example.akadns.net",
   366  			headers: http.Header{
   367  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   368  			},
   369  			responseStatus:   http.StatusCreated,
   370  			responseBody:     string(respData),
   371  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv4",
   372  			expectedResponse: result.Resource,
   373  		},
   374  		"500 internal server error": {
   375  			domainName:     "example.akadns.net",
   376  			headers:        http.Header{},
   377  			responseStatus: http.StatusInternalServerError,
   378  			responseBody: `
   379  {
   380      "type": "internal_error",
   381      "title": "Internal Server Error",
   382      "detail": "Error creating dc"
   383  }`,
   384  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv4",
   385  			withError: &Error{
   386  				Type:       "internal_error",
   387  				Title:      "Internal Server Error",
   388  				Detail:     "Error creating dc",
   389  				StatusCode: http.StatusInternalServerError,
   390  			},
   391  		},
   392  	}
   393  
   394  	for name, test := range tests {
   395  		t.Run(name, func(t *testing.T) {
   396  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   397  				if r.Method == http.MethodGet {
   398  					w.WriteHeader(http.StatusNotFound)
   399  					_, err = w.Write([]byte(`
   400                                          {
   401                                              "type": "Datacenter",
   402                                              "title": "not found"
   403                                          }`))
   404  					require.NoError(t, err)
   405  					return
   406  				}
   407  				assert.Equal(t, test.expectedPath, r.URL.String())
   408  				assert.Equal(t, http.MethodPost, r.Method)
   409  				w.WriteHeader(test.responseStatus)
   410  				_, err := w.Write([]byte(test.responseBody))
   411  				assert.NoError(t, err)
   412  			}))
   413  			client := mockAPIClient(t, mockServer)
   414  			result, err := client.CreateIPv4DefaultDatacenter(
   415  				session.ContextWithOptions(
   416  					context.Background(),
   417  					session.WithContextHeaders(test.headers)), test.domainName)
   418  			if test.withError != nil {
   419  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   420  				return
   421  			}
   422  			require.NoError(t, err)
   423  			assert.Equal(t, test.expectedResponse, result)
   424  		})
   425  	}
   426  }
   427  
   428  func TestGTM_CreateIPv6DefaultDatacenter(t *testing.T) {
   429  	var result DatacenterResponse
   430  
   431  	respData, err := loadTestData("TestGTM_CreateIPv6DefaultDatacenter.resp.json")
   432  	if err != nil {
   433  		t.Fatal(err)
   434  	}
   435  
   436  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   437  		t.Fatal(err)
   438  	}
   439  
   440  	tests := map[string]struct {
   441  		domainName       string
   442  		responseStatus   int
   443  		responseBody     string
   444  		expectedPath     string
   445  		expectedResponse *Datacenter
   446  		withError        error
   447  		headers          http.Header
   448  	}{
   449  		"200 OK": {
   450  			domainName: "example.akadns.net",
   451  			headers: http.Header{
   452  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   453  			},
   454  			responseStatus:   http.StatusCreated,
   455  			responseBody:     string(respData),
   456  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv6",
   457  			expectedResponse: result.Resource,
   458  		},
   459  		"500 internal server error": {
   460  			domainName:     "example.akadns.net",
   461  			headers:        http.Header{},
   462  			responseStatus: http.StatusInternalServerError,
   463  			responseBody: `
   464  {
   465      "type": "internal_error",
   466      "title": "Internal Server Error",
   467      "detail": "Error creating dc"
   468  }`,
   469  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv6",
   470  			withError: &Error{
   471  				Type:       "internal_error",
   472  				Title:      "Internal Server Error",
   473  				Detail:     "Error creating dc",
   474  				StatusCode: http.StatusInternalServerError,
   475  			},
   476  		},
   477  	}
   478  
   479  	for name, test := range tests {
   480  		t.Run(name, func(t *testing.T) {
   481  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   482  				if r.Method == http.MethodGet {
   483  					w.WriteHeader(http.StatusNotFound)
   484  					_, err = w.Write([]byte(`
   485                                          {
   486                                              "type": "Datacenter",
   487                                              "title": "not found"
   488                                          }`))
   489  					require.NoError(t, err)
   490  					return
   491  				}
   492  				assert.Equal(t, test.expectedPath, r.URL.String())
   493  				assert.Equal(t, http.MethodPost, r.Method)
   494  				w.WriteHeader(test.responseStatus)
   495  				_, err := w.Write([]byte(test.responseBody))
   496  				assert.NoError(t, err)
   497  			}))
   498  			client := mockAPIClient(t, mockServer)
   499  			result, err := client.CreateIPv6DefaultDatacenter(
   500  				session.ContextWithOptions(
   501  					context.Background(),
   502  					session.WithContextHeaders(test.headers)), test.domainName)
   503  			if test.withError != nil {
   504  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   505  				return
   506  			}
   507  			require.NoError(t, err)
   508  			assert.Equal(t, test.expectedResponse, result)
   509  		})
   510  	}
   511  }
   512  
   513  func TestGTM_UpdateDatacenter(t *testing.T) {
   514  	var result DatacenterResponse
   515  	var req Datacenter
   516  
   517  	respData, err := loadTestData("TestGTM_CreateDatacenter.resp.json")
   518  	if err != nil {
   519  		t.Fatal(err)
   520  	}
   521  
   522  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   523  		t.Fatal(err)
   524  	}
   525  
   526  	reqData, err := loadTestData("TestGTM_CreateDatacenter.req.json")
   527  	if err != nil {
   528  		t.Fatal(err)
   529  	}
   530  
   531  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   532  		t.Fatal(err)
   533  	}
   534  
   535  	tests := map[string]struct {
   536  		dc               *Datacenter
   537  		domainName       string
   538  		responseStatus   int
   539  		responseBody     string
   540  		expectedPath     string
   541  		expectedResponse *ResponseStatus
   542  		withError        error
   543  		headers          http.Header
   544  	}{
   545  		"200 OK": {
   546  			dc:         &req,
   547  			domainName: "example.akadns.net",
   548  			headers: http.Header{
   549  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   550  			},
   551  			responseStatus:   http.StatusOK,
   552  			responseBody:     string(respData),
   553  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   554  			expectedResponse: result.Status,
   555  		},
   556  		"500 internal server error": {
   557  			dc:             &req,
   558  			domainName:     "example.akadns.net",
   559  			headers:        http.Header{},
   560  			responseStatus: http.StatusInternalServerError,
   561  			responseBody: `
   562  {
   563      "type": "internal_error",
   564      "title": "Internal Server Error",
   565      "detail": "Error updating dc"
   566  }`,
   567  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   568  			withError: &Error{
   569  				Type:       "internal_error",
   570  				Title:      "Internal Server Error",
   571  				Detail:     "Error updating dc",
   572  				StatusCode: http.StatusInternalServerError,
   573  			},
   574  		},
   575  	}
   576  
   577  	for name, test := range tests {
   578  		t.Run(name, func(t *testing.T) {
   579  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   580  				assert.Equal(t, test.expectedPath, r.URL.String())
   581  				assert.Equal(t, http.MethodPut, r.Method)
   582  				w.WriteHeader(test.responseStatus)
   583  				_, err := w.Write([]byte(test.responseBody))
   584  				assert.NoError(t, err)
   585  			}))
   586  			client := mockAPIClient(t, mockServer)
   587  			result, err := client.UpdateDatacenter(
   588  				session.ContextWithOptions(
   589  					context.Background(),
   590  					session.WithContextHeaders(test.headers)), test.dc, test.domainName)
   591  			if test.withError != nil {
   592  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   593  				return
   594  			}
   595  			require.NoError(t, err)
   596  			assert.Equal(t, test.expectedResponse, result)
   597  		})
   598  	}
   599  }
   600  
   601  func TestGTM_DeleteDatacenter(t *testing.T) {
   602  	var result DatacenterResponse
   603  	var req Datacenter
   604  
   605  	respData, err := loadTestData("TestGTM_CreateDatacenter.resp.json")
   606  	if err != nil {
   607  		t.Fatal(err)
   608  	}
   609  
   610  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   611  		t.Fatal(err)
   612  	}
   613  
   614  	reqData, err := loadTestData("TestGTM_CreateDatacenter.req.json")
   615  	if err != nil {
   616  		t.Fatal(err)
   617  	}
   618  
   619  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   620  		t.Fatal(err)
   621  	}
   622  
   623  	tests := map[string]struct {
   624  		dc               *Datacenter
   625  		domainName       string
   626  		responseStatus   int
   627  		responseBody     string
   628  		expectedPath     string
   629  		expectedResponse *ResponseStatus
   630  		withError        error
   631  		headers          http.Header
   632  	}{
   633  		"200 OK": {
   634  			dc:         &req,
   635  			domainName: "example.akadns.net",
   636  			headers: http.Header{
   637  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   638  			},
   639  			responseStatus:   http.StatusOK,
   640  			responseBody:     string(respData),
   641  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   642  			expectedResponse: result.Status,
   643  		},
   644  		"500 internal server error": {
   645  			dc:             &req,
   646  			domainName:     "example.akadns.net",
   647  			headers:        http.Header{},
   648  			responseStatus: http.StatusInternalServerError,
   649  			responseBody: `
   650  {
   651      "type": "internal_error",
   652      "title": "Internal Server Error",
   653      "detail": "Error updating dc"
   654  }`,
   655  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   656  			withError: &Error{
   657  				Type:       "internal_error",
   658  				Title:      "Internal Server Error",
   659  				Detail:     "Error updating dc",
   660  				StatusCode: http.StatusInternalServerError,
   661  			},
   662  		},
   663  	}
   664  
   665  	for name, test := range tests {
   666  		t.Run(name, func(t *testing.T) {
   667  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   668  				assert.Equal(t, test.expectedPath, r.URL.String())
   669  				assert.Equal(t, http.MethodDelete, r.Method)
   670  				w.WriteHeader(test.responseStatus)
   671  				_, err := w.Write([]byte(test.responseBody))
   672  				assert.NoError(t, err)
   673  			}))
   674  			client := mockAPIClient(t, mockServer)
   675  			result, err := client.DeleteDatacenter(
   676  				session.ContextWithOptions(
   677  					context.Background(),
   678  					session.WithContextHeaders(test.headers)), test.dc, test.domainName)
   679  			if test.withError != nil {
   680  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   681  				return
   682  			}
   683  			require.NoError(t, err)
   684  			assert.Equal(t, test.expectedResponse, result)
   685  		})
   686  	}
   687  }