github.com/akamai/AkamaiOPEN-edgegrid-golang/v2@v2.17.0/pkg/configgtm/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/v2/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  					w.Write([]byte(`
   331                                          {
   332                                              "type": "Datacenter",
   333                                              "title": "not found"
   334                                          }`))
   335  					return
   336  				}
   337  				assert.Equal(t, test.expectedPath, r.URL.String())
   338  				assert.Equal(t, http.MethodPost, r.Method)
   339  				w.WriteHeader(test.responseStatus)
   340  				_, err := w.Write([]byte(test.responseBody))
   341  				assert.NoError(t, err)
   342  			}))
   343  			client := mockAPIClient(t, mockServer)
   344  			result, err := client.CreateMapsDefaultDatacenter(
   345  				session.ContextWithOptions(
   346  					context.Background(),
   347  					session.WithContextHeaders(test.headers)), test.domainName)
   348  			if test.withError != nil {
   349  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   350  				return
   351  			}
   352  			require.NoError(t, err)
   353  			assert.Equal(t, test.expectedResponse, result)
   354  		})
   355  	}
   356  }
   357  
   358  func TestGtm_CreateIPv4DefaultDatacenter(t *testing.T) {
   359  	var result DatacenterResponse
   360  
   361  	respData, err := loadTestData("TestGtm_CreateIPv4DefaultDatacenter.resp.json")
   362  	if err != nil {
   363  		t.Fatal(err)
   364  	}
   365  
   366  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   367  		t.Fatal(err)
   368  	}
   369  
   370  	tests := map[string]struct {
   371  		domainName       string
   372  		responseStatus   int
   373  		responseBody     string
   374  		expectedPath     string
   375  		expectedResponse *Datacenter
   376  		withError        error
   377  		headers          http.Header
   378  	}{
   379  		"200 OK": {
   380  			domainName: "example.akadns.net",
   381  			headers: http.Header{
   382  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   383  			},
   384  			responseStatus:   http.StatusCreated,
   385  			responseBody:     string(respData),
   386  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv4",
   387  			expectedResponse: result.Resource,
   388  		},
   389  		"500 internal server error": {
   390  			domainName:     "example.akadns.net",
   391  			headers:        http.Header{},
   392  			responseStatus: http.StatusInternalServerError,
   393  			responseBody: `
   394  {
   395      "type": "internal_error",
   396      "title": "Internal Server Error",
   397      "detail": "Error creating dc"
   398  }`,
   399  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv4",
   400  			withError: &Error{
   401  				Type:       "internal_error",
   402  				Title:      "Internal Server Error",
   403  				Detail:     "Error creating dc",
   404  				StatusCode: http.StatusInternalServerError,
   405  			},
   406  		},
   407  	}
   408  
   409  	for name, test := range tests {
   410  		t.Run(name, func(t *testing.T) {
   411  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   412  				if r.Method == http.MethodGet {
   413  					w.WriteHeader(http.StatusNotFound)
   414  					w.Write([]byte(`
   415                                          {
   416                                              "type": "Datacenter",
   417                                              "title": "not found"
   418                                          }`))
   419  					return
   420  				}
   421  				assert.Equal(t, test.expectedPath, r.URL.String())
   422  				assert.Equal(t, http.MethodPost, r.Method)
   423  				w.WriteHeader(test.responseStatus)
   424  				_, err := w.Write([]byte(test.responseBody))
   425  				assert.NoError(t, err)
   426  			}))
   427  			client := mockAPIClient(t, mockServer)
   428  			result, err := client.CreateIPv4DefaultDatacenter(
   429  				session.ContextWithOptions(
   430  					context.Background(),
   431  					session.WithContextHeaders(test.headers)), test.domainName)
   432  			if test.withError != nil {
   433  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   434  				return
   435  			}
   436  			require.NoError(t, err)
   437  			assert.Equal(t, test.expectedResponse, result)
   438  		})
   439  	}
   440  }
   441  
   442  func TestGtm_CreateIPv6DefaultDatacenter(t *testing.T) {
   443  	var result DatacenterResponse
   444  
   445  	respData, err := loadTestData("TestGtm_CreateIPv6DefaultDatacenter.resp.json")
   446  	if err != nil {
   447  		t.Fatal(err)
   448  	}
   449  
   450  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   451  		t.Fatal(err)
   452  	}
   453  
   454  	tests := map[string]struct {
   455  		domainName       string
   456  		responseStatus   int
   457  		responseBody     string
   458  		expectedPath     string
   459  		expectedResponse *Datacenter
   460  		withError        error
   461  		headers          http.Header
   462  	}{
   463  		"200 OK": {
   464  			domainName: "example.akadns.net",
   465  			headers: http.Header{
   466  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   467  			},
   468  			responseStatus:   http.StatusCreated,
   469  			responseBody:     string(respData),
   470  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv6",
   471  			expectedResponse: result.Resource,
   472  		},
   473  		"500 internal server error": {
   474  			domainName:     "example.akadns.net",
   475  			headers:        http.Header{},
   476  			responseStatus: http.StatusInternalServerError,
   477  			responseBody: `
   478  {
   479      "type": "internal_error",
   480      "title": "Internal Server Error",
   481      "detail": "Error creating dc"
   482  }`,
   483  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/datacenter-for-ip-version-selector-ipv6",
   484  			withError: &Error{
   485  				Type:       "internal_error",
   486  				Title:      "Internal Server Error",
   487  				Detail:     "Error creating dc",
   488  				StatusCode: http.StatusInternalServerError,
   489  			},
   490  		},
   491  	}
   492  
   493  	for name, test := range tests {
   494  		t.Run(name, func(t *testing.T) {
   495  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   496  				if r.Method == http.MethodGet {
   497  					w.WriteHeader(http.StatusNotFound)
   498  					w.Write([]byte(`
   499                                          {
   500                                              "type": "Datacenter",
   501                                              "title": "not found"
   502                                          }`))
   503  					return
   504  				}
   505  				assert.Equal(t, test.expectedPath, r.URL.String())
   506  				assert.Equal(t, http.MethodPost, r.Method)
   507  				w.WriteHeader(test.responseStatus)
   508  				_, err := w.Write([]byte(test.responseBody))
   509  				assert.NoError(t, err)
   510  			}))
   511  			client := mockAPIClient(t, mockServer)
   512  			result, err := client.CreateIPv6DefaultDatacenter(
   513  				session.ContextWithOptions(
   514  					context.Background(),
   515  					session.WithContextHeaders(test.headers)), test.domainName)
   516  			if test.withError != nil {
   517  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   518  				return
   519  			}
   520  			require.NoError(t, err)
   521  			assert.Equal(t, test.expectedResponse, result)
   522  		})
   523  	}
   524  }
   525  
   526  func TestGtm_UpdateDatacenter(t *testing.T) {
   527  	var result DatacenterResponse
   528  	var req Datacenter
   529  
   530  	respData, err := loadTestData("TestGtm_CreateDatacenter.resp.json")
   531  	if err != nil {
   532  		t.Fatal(err)
   533  	}
   534  
   535  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   536  		t.Fatal(err)
   537  	}
   538  
   539  	reqData, err := loadTestData("TestGtm_CreateDatacenter.req.json")
   540  	if err != nil {
   541  		t.Fatal(err)
   542  	}
   543  
   544  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   545  		t.Fatal(err)
   546  	}
   547  
   548  	tests := map[string]struct {
   549  		dc               *Datacenter
   550  		domainName       string
   551  		responseStatus   int
   552  		responseBody     string
   553  		expectedPath     string
   554  		expectedResponse *ResponseStatus
   555  		withError        error
   556  		headers          http.Header
   557  	}{
   558  		"200 OK": {
   559  			dc:         &req,
   560  			domainName: "example.akadns.net",
   561  			headers: http.Header{
   562  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   563  			},
   564  			responseStatus:   http.StatusOK,
   565  			responseBody:     string(respData),
   566  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   567  			expectedResponse: result.Status,
   568  		},
   569  		"500 internal server error": {
   570  			dc:             &req,
   571  			domainName:     "example.akadns.net",
   572  			headers:        http.Header{},
   573  			responseStatus: http.StatusInternalServerError,
   574  			responseBody: `
   575  {
   576      "type": "internal_error",
   577      "title": "Internal Server Error",
   578      "detail": "Error updating dc"
   579  }`,
   580  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   581  			withError: &Error{
   582  				Type:       "internal_error",
   583  				Title:      "Internal Server Error",
   584  				Detail:     "Error updating dc",
   585  				StatusCode: http.StatusInternalServerError,
   586  			},
   587  		},
   588  	}
   589  
   590  	for name, test := range tests {
   591  		t.Run(name, func(t *testing.T) {
   592  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   593  				assert.Equal(t, test.expectedPath, r.URL.String())
   594  				assert.Equal(t, http.MethodPut, r.Method)
   595  				w.WriteHeader(test.responseStatus)
   596  				_, err := w.Write([]byte(test.responseBody))
   597  				assert.NoError(t, err)
   598  			}))
   599  			client := mockAPIClient(t, mockServer)
   600  			result, err := client.UpdateDatacenter(
   601  				session.ContextWithOptions(
   602  					context.Background(),
   603  					session.WithContextHeaders(test.headers)), test.dc, test.domainName)
   604  			if test.withError != nil {
   605  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   606  				return
   607  			}
   608  			require.NoError(t, err)
   609  			assert.Equal(t, test.expectedResponse, result)
   610  		})
   611  	}
   612  }
   613  
   614  func TestGtm_DeleteDatacenter(t *testing.T) {
   615  	var result DatacenterResponse
   616  	var req Datacenter
   617  
   618  	respData, err := loadTestData("TestGtm_CreateDatacenter.resp.json")
   619  	if err != nil {
   620  		t.Fatal(err)
   621  	}
   622  
   623  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   624  		t.Fatal(err)
   625  	}
   626  
   627  	reqData, err := loadTestData("TestGtm_CreateDatacenter.req.json")
   628  	if err != nil {
   629  		t.Fatal(err)
   630  	}
   631  
   632  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   633  		t.Fatal(err)
   634  	}
   635  
   636  	tests := map[string]struct {
   637  		dc               *Datacenter
   638  		domainName       string
   639  		responseStatus   int
   640  		responseBody     string
   641  		expectedPath     string
   642  		expectedResponse *ResponseStatus
   643  		withError        error
   644  		headers          http.Header
   645  	}{
   646  		"200 OK": {
   647  			dc:         &req,
   648  			domainName: "example.akadns.net",
   649  			headers: http.Header{
   650  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   651  			},
   652  			responseStatus:   http.StatusOK,
   653  			responseBody:     string(respData),
   654  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   655  			expectedResponse: result.Status,
   656  		},
   657  		"500 internal server error": {
   658  			dc:             &req,
   659  			domainName:     "example.akadns.net",
   660  			headers:        http.Header{},
   661  			responseStatus: http.StatusInternalServerError,
   662  			responseBody: `
   663  {
   664      "type": "internal_error",
   665      "title": "Internal Server Error",
   666      "detail": "Error updating dc"
   667  }`,
   668  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/datacenters/0",
   669  			withError: &Error{
   670  				Type:       "internal_error",
   671  				Title:      "Internal Server Error",
   672  				Detail:     "Error updating dc",
   673  				StatusCode: http.StatusInternalServerError,
   674  			},
   675  		},
   676  	}
   677  
   678  	for name, test := range tests {
   679  		t.Run(name, func(t *testing.T) {
   680  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   681  				assert.Equal(t, test.expectedPath, r.URL.String())
   682  				assert.Equal(t, http.MethodDelete, r.Method)
   683  				w.WriteHeader(test.responseStatus)
   684  				_, err := w.Write([]byte(test.responseBody))
   685  				assert.NoError(t, err)
   686  			}))
   687  			client := mockAPIClient(t, mockServer)
   688  			result, err := client.DeleteDatacenter(
   689  				session.ContextWithOptions(
   690  					context.Background(),
   691  					session.WithContextHeaders(test.headers)), test.dc, test.domainName)
   692  			if test.withError != nil {
   693  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   694  				return
   695  			}
   696  			require.NoError(t, err)
   697  			assert.Equal(t, test.expectedResponse, result)
   698  		})
   699  	}
   700  }