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