github.com/akamai/AkamaiOPEN-edgegrid-golang/v2@v2.17.0/pkg/configgtm/cidrmap_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_NewCidrMap(t *testing.T) {
    18  	client := Client(session.Must(session.New()))
    19  
    20  	cmap := client.NewCidrMap(context.Background(), "foo")
    21  
    22  	assert.Equal(t, "foo", cmap.Name)
    23  }
    24  
    25  func TestGtm_ListCidrMaps(t *testing.T) {
    26  	var result CidrMapList
    27  
    28  	respData, err := loadTestData("TestGtm_ListCidrMap.resp.json")
    29  	if err != nil {
    30  		t.Fatal(err)
    31  	}
    32  
    33  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
    34  		t.Fatal(err)
    35  	}
    36  
    37  	tests := map[string]struct {
    38  		domainName       string
    39  		responseStatus   int
    40  		responseBody     string
    41  		expectedPath     string
    42  		expectedResponse []*CidrMap
    43  		withError        error
    44  		headers          http.Header
    45  	}{
    46  		"200 OK": {
    47  			domainName: "example.akadns.net",
    48  			headers: http.Header{
    49  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
    50  			},
    51  			responseStatus:   http.StatusOK,
    52  			responseBody:     string(respData),
    53  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/cidr-maps",
    54  			expectedResponse: result.CidrMapItems,
    55  		},
    56  		"500 internal server error": {
    57  			domainName:     "example.akadns.net",
    58  			headers:        http.Header{},
    59  			responseStatus: http.StatusInternalServerError,
    60  			responseBody: `
    61  {
    62      "type": "internal_error",
    63      "title": "Internal Server Error",
    64      "detail": "Error fetching asmap",
    65      "status": 500
    66  }`,
    67  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/cidr-maps",
    68  			withError: &Error{
    69  				Type:       "internal_error",
    70  				Title:      "Internal Server Error",
    71  				Detail:     "Error fetching asmap",
    72  				StatusCode: http.StatusInternalServerError,
    73  			},
    74  		},
    75  	}
    76  
    77  	for name, test := range tests {
    78  		t.Run(name, func(t *testing.T) {
    79  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    80  				assert.Equal(t, test.expectedPath, r.URL.String())
    81  				assert.Equal(t, http.MethodGet, r.Method)
    82  				w.WriteHeader(test.responseStatus)
    83  				_, err := w.Write([]byte(test.responseBody))
    84  				assert.NoError(t, err)
    85  			}))
    86  			client := mockAPIClient(t, mockServer)
    87  			result, err := client.ListCidrMaps(
    88  				session.ContextWithOptions(
    89  					context.Background(),
    90  					session.WithContextHeaders(test.headers)), test.domainName)
    91  			if test.withError != nil {
    92  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
    93  				return
    94  			}
    95  			require.NoError(t, err)
    96  			assert.Equal(t, test.expectedResponse, result)
    97  		})
    98  	}
    99  }
   100  
   101  func TestGtm_GetCidrMap(t *testing.T) {
   102  	var result CidrMap
   103  
   104  	respData, err := loadTestData("TestGtm_GetCidrMap.resp.json")
   105  	if err != nil {
   106  		t.Fatal(err)
   107  	}
   108  
   109  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   110  		t.Fatal(err)
   111  	}
   112  
   113  	tests := map[string]struct {
   114  		name             string
   115  		domainName       string
   116  		responseStatus   int
   117  		responseBody     string
   118  		expectedPath     string
   119  		expectedResponse *CidrMap
   120  		withError        error
   121  		headers          http.Header
   122  	}{
   123  		"200 OK": {
   124  			name:       "Software-rollout",
   125  			domainName: "example.akadns.net",
   126  			headers: http.Header{
   127  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   128  			},
   129  			responseStatus:   http.StatusOK,
   130  			responseBody:     string(respData),
   131  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/cidr-maps/Software-rollout",
   132  			expectedResponse: &result,
   133  		},
   134  		"500 internal server error": {
   135  			name:           "Software-rollout",
   136  			domainName:     "example.akadns.net",
   137  			headers:        http.Header{},
   138  			responseStatus: http.StatusInternalServerError,
   139  			responseBody: `
   140  {
   141      "type": "internal_error",
   142      "title": "Internal Server Error",
   143      "detail": "Error fetching asmap",
   144      "status": 500
   145  }`,
   146  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/cidr-maps/Software-rollout",
   147  			withError: &Error{
   148  				Type:       "internal_error",
   149  				Title:      "Internal Server Error",
   150  				Detail:     "Error fetching asmap",
   151  				StatusCode: http.StatusInternalServerError,
   152  			},
   153  		},
   154  	}
   155  
   156  	for name, test := range tests {
   157  		t.Run(name, func(t *testing.T) {
   158  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   159  				assert.Equal(t, test.expectedPath, r.URL.String())
   160  				assert.Equal(t, http.MethodGet, r.Method)
   161  				w.WriteHeader(test.responseStatus)
   162  				_, err := w.Write([]byte(test.responseBody))
   163  				assert.NoError(t, err)
   164  			}))
   165  			client := mockAPIClient(t, mockServer)
   166  			result, err := client.GetCidrMap(
   167  				session.ContextWithOptions(
   168  					context.Background(),
   169  					session.WithContextHeaders(test.headers)), test.name, test.domainName)
   170  			if test.withError != nil {
   171  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   172  				return
   173  			}
   174  			require.NoError(t, err)
   175  			assert.Equal(t, test.expectedResponse, result)
   176  		})
   177  	}
   178  }
   179  
   180  func TestGtm_NewCidrAssignment(t *testing.T) {
   181  	client := Client(session.Must(session.New()))
   182  
   183  	asn := client.NewCidrAssignment(context.Background(), nil, 100, "foo")
   184  
   185  	assert.Equal(t, 100, asn.DatacenterId)
   186  	assert.Equal(t, "foo", asn.Nickname)
   187  }
   188  
   189  func TestGtm_CreateCidrMap(t *testing.T) {
   190  	var result CidrMapResponse
   191  	var req CidrMap
   192  
   193  	respData, err := loadTestData("TestGtm_CreateCidrMap.resp.json")
   194  	if err != nil {
   195  		t.Fatal(err)
   196  	}
   197  
   198  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   199  		t.Fatal(err)
   200  	}
   201  
   202  	reqData, err := loadTestData("TestGtm_CreateCidrMap.req.json")
   203  	if err != nil {
   204  		t.Fatal(err)
   205  	}
   206  
   207  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   208  		t.Fatal(err)
   209  	}
   210  
   211  	tests := map[string]struct {
   212  		cmap             *CidrMap
   213  		domainName       string
   214  		responseStatus   int
   215  		responseBody     string
   216  		expectedPath     string
   217  		expectedResponse *CidrMapResponse
   218  		withError        error
   219  		headers          http.Header
   220  	}{
   221  		"200 OK": {
   222  			cmap:       &req,
   223  			domainName: "example.akadns.net",
   224  			headers: http.Header{
   225  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   226  			},
   227  			responseStatus:   http.StatusOK,
   228  			responseBody:     string(respData),
   229  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/cidr-maps/The%20North",
   230  			expectedResponse: &result,
   231  		},
   232  		"500 internal server error": {
   233  			cmap:           &req,
   234  			domainName:     "example.akadns.net",
   235  			headers:        http.Header{},
   236  			responseStatus: http.StatusInternalServerError,
   237  			responseBody: `
   238  {
   239      "type": "internal_error",
   240      "title": "Internal Server Error",
   241      "detail": "Error creating asmap"
   242  }`,
   243  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/cidr-maps/The%20North",
   244  			withError: &Error{
   245  				Type:       "internal_error",
   246  				Title:      "Internal Server Error",
   247  				Detail:     "Error creating asmap",
   248  				StatusCode: http.StatusInternalServerError,
   249  			},
   250  		},
   251  	}
   252  
   253  	for name, test := range tests {
   254  		t.Run(name, func(t *testing.T) {
   255  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   256  				assert.Equal(t, test.expectedPath, r.URL.String())
   257  				assert.Equal(t, http.MethodPut, r.Method)
   258  				w.WriteHeader(test.responseStatus)
   259  				_, err := w.Write([]byte(test.responseBody))
   260  				assert.NoError(t, err)
   261  			}))
   262  			client := mockAPIClient(t, mockServer)
   263  			result, err := client.CreateCidrMap(
   264  				session.ContextWithOptions(
   265  					context.Background(),
   266  					session.WithContextHeaders(test.headers)), test.cmap, test.domainName)
   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 TestGtm_UpdateCidrMap(t *testing.T) {
   278  	var result CidrMapResponse
   279  	var req CidrMap
   280  
   281  	respData, err := loadTestData("TestGtm_CreateCidrMap.resp.json")
   282  	if err != nil {
   283  		t.Fatal(err)
   284  	}
   285  
   286  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   287  		t.Fatal(err)
   288  	}
   289  
   290  	reqData, err := loadTestData("TestGtm_CreateCidrMap.req.json")
   291  	if err != nil {
   292  		t.Fatal(err)
   293  	}
   294  
   295  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   296  		t.Fatal(err)
   297  	}
   298  
   299  	tests := map[string]struct {
   300  		cmap             *CidrMap
   301  		domainName       string
   302  		responseStatus   int
   303  		responseBody     string
   304  		expectedPath     string
   305  		expectedResponse *ResponseStatus
   306  		withError        error
   307  		headers          http.Header
   308  	}{
   309  		"200 OK": {
   310  			cmap:       &req,
   311  			domainName: "example.akadns.net",
   312  			headers: http.Header{
   313  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   314  			},
   315  			responseStatus:   http.StatusOK,
   316  			responseBody:     string(respData),
   317  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/cidr-maps/The%20North",
   318  			expectedResponse: result.Status,
   319  		},
   320  		"500 internal server error": {
   321  			cmap:           &req,
   322  			domainName:     "example.akadns.net",
   323  			headers:        http.Header{},
   324  			responseStatus: http.StatusInternalServerError,
   325  			responseBody: `
   326  {
   327      "type": "internal_error",
   328      "title": "Internal Server Error",
   329      "detail": "Error creating asmap"
   330  }`,
   331  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/cidr-maps/The%20North",
   332  			withError: &Error{
   333  				Type:       "internal_error",
   334  				Title:      "Internal Server Error",
   335  				Detail:     "Error creating asmap",
   336  				StatusCode: http.StatusInternalServerError,
   337  			},
   338  		},
   339  	}
   340  
   341  	for name, test := range tests {
   342  		t.Run(name, func(t *testing.T) {
   343  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   344  				assert.Equal(t, test.expectedPath, r.URL.String())
   345  				assert.Equal(t, http.MethodPut, r.Method)
   346  				w.WriteHeader(test.responseStatus)
   347  				_, err := w.Write([]byte(test.responseBody))
   348  				assert.NoError(t, err)
   349  			}))
   350  			client := mockAPIClient(t, mockServer)
   351  			result, err := client.UpdateCidrMap(
   352  				session.ContextWithOptions(
   353  					context.Background(),
   354  					session.WithContextHeaders(test.headers)), test.cmap, test.domainName)
   355  			if test.withError != nil {
   356  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   357  				return
   358  			}
   359  			require.NoError(t, err)
   360  			assert.Equal(t, test.expectedResponse, result)
   361  		})
   362  	}
   363  }
   364  
   365  func TestGtm_DeleteCidrMap(t *testing.T) {
   366  	var result CidrMapResponse
   367  	var req CidrMap
   368  
   369  	respData, err := loadTestData("TestGtm_CreateCidrMap.resp.json")
   370  	if err != nil {
   371  		t.Fatal(err)
   372  	}
   373  
   374  	if err := json.NewDecoder(bytes.NewBuffer(respData)).Decode(&result); err != nil {
   375  		t.Fatal(err)
   376  	}
   377  
   378  	reqData, err := loadTestData("TestGtm_CreateCidrMap.req.json")
   379  	if err != nil {
   380  		t.Fatal(err)
   381  	}
   382  
   383  	if err := json.NewDecoder(bytes.NewBuffer(reqData)).Decode(&req); err != nil {
   384  		t.Fatal(err)
   385  	}
   386  
   387  	tests := map[string]struct {
   388  		cmap             *CidrMap
   389  		domainName       string
   390  		responseStatus   int
   391  		responseBody     string
   392  		expectedPath     string
   393  		expectedResponse *ResponseStatus
   394  		withError        error
   395  		headers          http.Header
   396  	}{
   397  		"200 OK": {
   398  			cmap:       &req,
   399  			domainName: "example.akadns.net",
   400  			headers: http.Header{
   401  				"Content-Type": []string{"application/vnd.config-gtm.v1.4+json;charset=UTF-8"},
   402  			},
   403  			responseStatus:   http.StatusOK,
   404  			responseBody:     string(respData),
   405  			expectedPath:     "/config-gtm/v1/domains/example.akadns.net/cidr-maps/The%20North",
   406  			expectedResponse: result.Status,
   407  		},
   408  		"500 internal server error": {
   409  			cmap:           &req,
   410  			domainName:     "example.akadns.net",
   411  			headers:        http.Header{},
   412  			responseStatus: http.StatusInternalServerError,
   413  			responseBody: `
   414  {
   415      "type": "internal_error",
   416      "title": "Internal Server Error",
   417      "detail": "Error creating asmap"
   418  }`,
   419  			expectedPath: "/config-gtm/v1/domains/example.akadns.net/cidr-maps/The%20North",
   420  			withError: &Error{
   421  				Type:       "internal_error",
   422  				Title:      "Internal Server Error",
   423  				Detail:     "Error creating asmap",
   424  				StatusCode: http.StatusInternalServerError,
   425  			},
   426  		},
   427  	}
   428  
   429  	for name, test := range tests {
   430  		t.Run(name, func(t *testing.T) {
   431  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   432  				assert.Equal(t, test.expectedPath, r.URL.String())
   433  				assert.Equal(t, http.MethodDelete, r.Method)
   434  				w.WriteHeader(test.responseStatus)
   435  				_, err := w.Write([]byte(test.responseBody))
   436  				assert.NoError(t, err)
   437  			}))
   438  			client := mockAPIClient(t, mockServer)
   439  			result, err := client.DeleteCidrMap(
   440  				session.ContextWithOptions(
   441  					context.Background(),
   442  					session.WithContextHeaders(test.headers)), test.cmap, test.domainName)
   443  			if test.withError != nil {
   444  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   445  				return
   446  			}
   447  			require.NoError(t, err)
   448  			assert.Equal(t, test.expectedResponse, result)
   449  		})
   450  	}
   451  }