github.com/akamai/AkamaiOPEN-edgegrid-golang/v2@v2.17.0/pkg/networklists/network_list_test.go (about)

     1  package networklists
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"errors"
     7  	"net/http"
     8  	"net/http/httptest"
     9  	"testing"
    10  
    11  	"github.com/akamai/AkamaiOPEN-edgegrid-golang/v2/pkg/session"
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestNetworkList_ListNetworkList(t *testing.T) {
    17  
    18  	result := GetNetworkListsResponse{}
    19  
    20  	respData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkLists.json"))
    21  	json.Unmarshal([]byte(respData), &result)
    22  
    23  	tests := map[string]struct {
    24  		params           GetNetworkListsRequest
    25  		responseStatus   int
    26  		responseBody     string
    27  		expectedPath     string
    28  		expectedResponse *GetNetworkListsResponse
    29  		withError        error
    30  		headers          http.Header
    31  	}{
    32  		"200 OK": {
    33  			params: GetNetworkListsRequest{},
    34  			headers: http.Header{
    35  				"Content-Type": []string{"application/json"},
    36  			},
    37  			responseStatus:   http.StatusOK,
    38  			responseBody:     respData,
    39  			expectedPath:     "/network-list/v2/network-lists",
    40  			expectedResponse: &result,
    41  		},
    42  		"500 internal server error": {
    43  			params:         GetNetworkListsRequest{},
    44  			headers:        http.Header{},
    45  			responseStatus: http.StatusInternalServerError,
    46  			responseBody: `
    47  {
    48      "type": "internal_error",
    49      "title": "Internal Server Error",
    50      "detail": "Error fetching networklist",
    51      "status": 500
    52  }`,
    53  			expectedPath: "/network-list/v2/network-lists",
    54  			withError: &Error{
    55  				Type:       "internal_error",
    56  				Title:      "Internal Server Error",
    57  				Detail:     "Error fetching networklist",
    58  				StatusCode: http.StatusInternalServerError,
    59  			},
    60  		},
    61  	}
    62  
    63  	for name, test := range tests {
    64  		t.Run(name, func(t *testing.T) {
    65  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    66  				assert.Equal(t, test.expectedPath, r.URL.String())
    67  				assert.Equal(t, http.MethodGet, r.Method)
    68  				w.WriteHeader(test.responseStatus)
    69  				_, err := w.Write([]byte(test.responseBody))
    70  				assert.NoError(t, err)
    71  			}))
    72  			client := mockAPIClient(t, mockServer)
    73  			result, err := client.GetNetworkLists(
    74  				session.ContextWithOptions(
    75  					context.Background(),
    76  					session.WithContextHeaders(test.headers),
    77  				),
    78  				test.params)
    79  			if test.withError != nil {
    80  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
    81  				return
    82  			}
    83  			require.NoError(t, err)
    84  			assert.Equal(t, test.expectedResponse, result)
    85  		})
    86  	}
    87  }
    88  
    89  func TestNetworkList_FilterNetworkLists(t *testing.T) {
    90  
    91  	result := GetNetworkListsResponse{}
    92  
    93  	respData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkLists.json"))
    94  	json.Unmarshal([]byte(respData), &result)
    95  
    96  	expectedResult := GetNetworkListsResponse{}
    97  	expectedResponseData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkLists_GEO.json"))
    98  	json.Unmarshal([]byte(expectedResponseData), &expectedResult)
    99  
   100  	tests := map[string]struct {
   101  		params           GetNetworkListsRequest
   102  		responseStatus   int
   103  		responseBody     string
   104  		expectedPath     string
   105  		expectedResponse *GetNetworkListsResponse
   106  		withError        error
   107  		headers          http.Header
   108  	}{
   109  		"200 OK": {
   110  			params: GetNetworkListsRequest{Type: "GEO"},
   111  			headers: http.Header{
   112  				"Content-Type": []string{"application/json"},
   113  			},
   114  			responseStatus:   http.StatusOK,
   115  			responseBody:     respData,
   116  			expectedPath:     "/network-list/v2/network-lists",
   117  			expectedResponse: &expectedResult,
   118  		},
   119  		"500 internal server error": {
   120  			params:         GetNetworkListsRequest{},
   121  			headers:        http.Header{},
   122  			responseStatus: http.StatusInternalServerError,
   123  			responseBody: `
   124  {
   125      "type": "internal_error",
   126      "title": "Internal Server Error",
   127      "detail": "Error fetching networklist",
   128      "status": 500
   129  }`,
   130  			expectedPath: "/network-list/v2/network-lists",
   131  			withError: &Error{
   132  				Type:       "internal_error",
   133  				Title:      "Internal Server Error",
   134  				Detail:     "Error fetching networklist",
   135  				StatusCode: http.StatusInternalServerError,
   136  			},
   137  		},
   138  	}
   139  
   140  	for name, test := range tests {
   141  		t.Run(name, func(t *testing.T) {
   142  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   143  				assert.Equal(t, test.expectedPath, r.URL.String())
   144  				assert.Equal(t, http.MethodGet, r.Method)
   145  				w.WriteHeader(test.responseStatus)
   146  				_, err := w.Write([]byte(test.responseBody))
   147  				assert.NoError(t, err)
   148  			}))
   149  			client := mockAPIClient(t, mockServer)
   150  			result, err := client.GetNetworkLists(
   151  				session.ContextWithOptions(
   152  					context.Background(),
   153  					session.WithContextHeaders(test.headers),
   154  				),
   155  				test.params)
   156  			if test.withError != nil {
   157  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   158  				return
   159  			}
   160  			require.NoError(t, err)
   161  			assert.Equal(t, test.expectedResponse, result)
   162  		})
   163  	}
   164  }
   165  
   166  // Test NetworkList
   167  func TestNetworkList_GetNetworkList(t *testing.T) {
   168  
   169  	result := GetNetworkListResponse{}
   170  
   171  	respData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkList.json"))
   172  	json.Unmarshal([]byte(respData), &result)
   173  
   174  	tests := map[string]struct {
   175  		params           GetNetworkListRequest
   176  		responseStatus   int
   177  		responseBody     string
   178  		expectedPath     string
   179  		expectedResponse *GetNetworkListResponse
   180  		withError        error
   181  	}{
   182  		"200 OK": {
   183  			params:           GetNetworkListRequest{UniqueID: "Test"},
   184  			responseStatus:   http.StatusOK,
   185  			responseBody:     respData,
   186  			expectedPath:     "/network-list/v2/network-lists/Test",
   187  			expectedResponse: &result,
   188  		},
   189  		"500 internal server error": {
   190  			params:         GetNetworkListRequest{UniqueID: "Test"},
   191  			responseStatus: http.StatusInternalServerError,
   192  			responseBody: `
   193  {
   194      "type": "internal_error",
   195      "title": "Internal Server Error",
   196      "detail": "Error fetching networklist"
   197  }`,
   198  			expectedPath: "/network-list/v2/network-lists/Test",
   199  			withError: &Error{
   200  				Type:       "internal_error",
   201  				Title:      "Internal Server Error",
   202  				Detail:     "Error fetching networklist",
   203  				StatusCode: http.StatusInternalServerError,
   204  			},
   205  		},
   206  	}
   207  
   208  	for name, test := range tests {
   209  		t.Run(name, func(t *testing.T) {
   210  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   211  				assert.Equal(t, test.expectedPath, r.URL.String())
   212  				assert.Equal(t, http.MethodGet, r.Method)
   213  				w.WriteHeader(test.responseStatus)
   214  				_, err := w.Write([]byte(test.responseBody))
   215  				assert.NoError(t, err)
   216  			}))
   217  			client := mockAPIClient(t, mockServer)
   218  			result, err := client.GetNetworkList(context.Background(), test.params)
   219  			if test.withError != nil {
   220  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   221  				return
   222  			}
   223  			require.NoError(t, err)
   224  			assert.Equal(t, test.expectedResponse, result)
   225  		})
   226  	}
   227  }
   228  
   229  // Test Create NetworkList
   230  func TestNetworkList_CreateNetworkList(t *testing.T) {
   231  
   232  	result := CreateNetworkListResponse{}
   233  
   234  	respData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkList.json"))
   235  	json.Unmarshal([]byte(respData), &result)
   236  
   237  	req := CreateNetworkListRequest{}
   238  
   239  	reqData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkList.json"))
   240  	json.Unmarshal([]byte(reqData), &req)
   241  
   242  	tests := map[string]struct {
   243  		params           CreateNetworkListRequest
   244  		prop             *CreateNetworkListRequest
   245  		responseStatus   int
   246  		responseBody     string
   247  		expectedPath     string
   248  		expectedResponse *CreateNetworkListResponse
   249  		withError        error
   250  		headers          http.Header
   251  	}{
   252  		"201 Created": {
   253  			params: CreateNetworkListRequest{Name: "Test"},
   254  			headers: http.Header{
   255  				"Content-Type": []string{"application/json;charset=UTF-8"},
   256  			},
   257  			responseStatus:   http.StatusCreated,
   258  			responseBody:     respData,
   259  			expectedResponse: &result,
   260  			expectedPath:     "/network-list/v2/network-lists",
   261  		},
   262  		"500 internal server error": {
   263  			params:         CreateNetworkListRequest{Name: "Test"},
   264  			responseStatus: http.StatusInternalServerError,
   265  			responseBody: `
   266  {
   267      "type": "internal_error",
   268      "title": "Internal Server Error",
   269      "detail": "Error creating networklist"
   270  }`,
   271  			expectedPath: "/network-list/v2/network-lists",
   272  			withError: &Error{
   273  				Type:       "internal_error",
   274  				Title:      "Internal Server Error",
   275  				Detail:     "Error creating networklist",
   276  				StatusCode: http.StatusInternalServerError,
   277  			},
   278  		},
   279  	}
   280  
   281  	for name, test := range tests {
   282  		t.Run(name, func(t *testing.T) {
   283  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   284  				assert.Equal(t, http.MethodPost, r.Method)
   285  				assert.Equal(t, test.expectedPath, r.URL.String())
   286  				w.WriteHeader(test.responseStatus)
   287  				if len(test.responseBody) > 0 {
   288  					_, err := w.Write([]byte(test.responseBody))
   289  					assert.NoError(t, err)
   290  				}
   291  			}))
   292  			client := mockAPIClient(t, mockServer)
   293  			result, err := client.CreateNetworkList(
   294  				session.ContextWithOptions(
   295  					context.Background(),
   296  					session.WithContextHeaders(test.headers)), test.params)
   297  			if test.withError != nil {
   298  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   299  				return
   300  			}
   301  			require.NoError(t, err)
   302  			assert.Equal(t, test.expectedResponse, result)
   303  		})
   304  	}
   305  }
   306  
   307  // Test Update NetworkList
   308  func TestNetworkList_UpdateNetworkList(t *testing.T) {
   309  	result := UpdateNetworkListResponse{}
   310  
   311  	respData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkList.json"))
   312  	json.Unmarshal([]byte(respData), &result)
   313  
   314  	req := UpdateNetworkListRequest{}
   315  
   316  	reqData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkList.json"))
   317  	json.Unmarshal([]byte(reqData), &req)
   318  
   319  	tests := map[string]struct {
   320  		params           UpdateNetworkListRequest
   321  		responseStatus   int
   322  		responseBody     string
   323  		expectedPath     string
   324  		expectedResponse *UpdateNetworkListResponse
   325  		withError        error
   326  		headers          http.Header
   327  	}{
   328  		"200 Success": {
   329  			params: UpdateNetworkListRequest{Name: "TEST", UniqueID: "Test"},
   330  			headers: http.Header{
   331  				"Content-Type": []string{"application/json;charset=UTF-8"},
   332  			},
   333  			responseStatus:   http.StatusCreated,
   334  			responseBody:     respData,
   335  			expectedResponse: &result,
   336  			expectedPath:     "/network-list/v2/network-lists/Test",
   337  		},
   338  		"500 internal server error": {
   339  			params:         UpdateNetworkListRequest{Name: "TEST", UniqueID: "Test"},
   340  			responseStatus: http.StatusInternalServerError,
   341  			responseBody: `
   342  {
   343      "type": "internal_error",
   344      "title": "Internal Server Error",
   345      "detail": "Error updating networklist"
   346  }`,
   347  			expectedPath: "/network-list/v2/network-lists/Test",
   348  			withError: &Error{
   349  				Type:       "internal_error",
   350  				Title:      "Internal Server Error",
   351  				Detail:     "Error updating networklist",
   352  				StatusCode: http.StatusInternalServerError,
   353  			},
   354  		},
   355  	}
   356  
   357  	for name, test := range tests {
   358  		t.Run(name, func(t *testing.T) {
   359  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   360  				assert.Equal(t, http.MethodPut, r.Method)
   361  				assert.Equal(t, test.expectedPath, r.URL.String())
   362  				w.WriteHeader(test.responseStatus)
   363  				if len(test.responseBody) > 0 {
   364  					_, err := w.Write([]byte(test.responseBody))
   365  					assert.NoError(t, err)
   366  				}
   367  			}))
   368  			client := mockAPIClient(t, mockServer)
   369  			result, err := client.UpdateNetworkList(
   370  				session.ContextWithOptions(
   371  					context.Background(),
   372  					session.WithContextHeaders(test.headers)), test.params)
   373  			if test.withError != nil {
   374  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   375  				return
   376  			}
   377  			require.NoError(t, err)
   378  			assert.Equal(t, test.expectedResponse, result)
   379  		})
   380  	}
   381  }
   382  
   383  //Test delete NetworkList
   384  func TestNetworkList_DeleteNetworkList(t *testing.T) {
   385  
   386  	result := RemoveNetworkListResponse{}
   387  
   388  	respData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkListEmpty.json"))
   389  	json.Unmarshal([]byte(respData), &result)
   390  
   391  	req := RemoveNetworkListRequest{}
   392  
   393  	reqData := compactJSON(loadFixtureBytes("testdata/TestNetworkList/NetworkListEmpty.json"))
   394  	json.Unmarshal([]byte(reqData), &req)
   395  
   396  	tests := map[string]struct {
   397  		params           RemoveNetworkListRequest
   398  		responseStatus   int
   399  		responseBody     string
   400  		expectedPath     string
   401  		expectedResponse *RemoveNetworkListResponse
   402  		withError        error
   403  		headers          http.Header
   404  	}{
   405  		"200 Success": {
   406  			params: RemoveNetworkListRequest{UniqueID: "Test"},
   407  			headers: http.Header{
   408  				"Content-Type": []string{"application/json;charset=UTF-8"},
   409  			},
   410  			responseStatus:   http.StatusOK,
   411  			responseBody:     respData,
   412  			expectedResponse: &result,
   413  			expectedPath:     "/network-list/v2/network-lists/Test",
   414  		},
   415  		"500 internal server error": {
   416  			params:         RemoveNetworkListRequest{UniqueID: "Test"},
   417  			responseStatus: http.StatusInternalServerError,
   418  			responseBody: `
   419          {
   420           "type": "internal_error",
   421           "title": "Internal Server Error",
   422           "detail": "Error deleting networklist"
   423           }`,
   424  			expectedPath: "/network-list/v2/network-lists/Test",
   425  			withError: &Error{
   426  				Type:       "internal_error",
   427  				Title:      "Internal Server Error",
   428  				Detail:     "Error deleting networklist",
   429  				StatusCode: http.StatusInternalServerError,
   430  			},
   431  		},
   432  	}
   433  
   434  	for name, test := range tests {
   435  		t.Run(name, func(t *testing.T) {
   436  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   437  				assert.Equal(t, http.MethodDelete, r.Method)
   438  				assert.Equal(t, test.expectedPath, r.URL.String())
   439  				w.WriteHeader(test.responseStatus)
   440  				if len(test.responseBody) > 0 {
   441  					_, err := w.Write([]byte(test.responseBody))
   442  					assert.NoError(t, err)
   443  				}
   444  			}))
   445  			client := mockAPIClient(t, mockServer)
   446  			result, err := client.RemoveNetworkList(
   447  				session.ContextWithOptions(
   448  					context.Background(),
   449  					session.WithContextHeaders(test.headers)), test.params)
   450  			if test.withError != nil {
   451  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   452  				return
   453  			}
   454  			require.NoError(t, err)
   455  			assert.Equal(t, test.expectedResponse, result)
   456  		})
   457  	}
   458  }