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

     1  package appsec
     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/v8/pkg/session"
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestAppSec_ListReputationAnalysis(t *testing.T) {
    17  
    18  	result := GetReputationAnalysisResponse{}
    19  
    20  	respData := compactJSON(loadFixtureBytes("testdata/TestReputationAnalysis/ReputationAnalysis.json"))
    21  	err := json.Unmarshal([]byte(respData), &result)
    22  	require.NoError(t, err)
    23  
    24  	tests := map[string]struct {
    25  		params           GetReputationAnalysisRequest
    26  		responseStatus   int
    27  		responseBody     string
    28  		expectedPath     string
    29  		expectedResponse *GetReputationAnalysisResponse
    30  		withError        error
    31  		headers          http.Header
    32  	}{
    33  		"200 OK": {
    34  			params: GetReputationAnalysisRequest{
    35  				ConfigID: 43253,
    36  				Version:  15,
    37  				PolicyID: "AAAA_81230",
    38  			},
    39  			headers: http.Header{
    40  				"Content-Type": []string{"application/json"},
    41  			},
    42  			responseStatus:   http.StatusOK,
    43  			responseBody:     string(respData),
    44  			expectedPath:     "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
    45  			expectedResponse: &result,
    46  		},
    47  		"500 internal server error": {
    48  			params: GetReputationAnalysisRequest{
    49  				ConfigID: 43253,
    50  				Version:  15,
    51  				PolicyID: "AAAA_81230",
    52  			},
    53  			headers:        http.Header{},
    54  			responseStatus: http.StatusInternalServerError,
    55  			responseBody: `
    56  {
    57      "type": "internal_error",
    58      "title": "Internal Server Error",
    59      "detail": "Error fetching ReputationAnalysis",
    60      "status": 500
    61  }`,
    62  			expectedPath: "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
    63  			withError: &Error{
    64  				Type:       "internal_error",
    65  				Title:      "Internal Server Error",
    66  				Detail:     "Error fetching ReputationAnalysis",
    67  				StatusCode: http.StatusInternalServerError,
    68  			},
    69  		},
    70  	}
    71  
    72  	for name, test := range tests {
    73  		t.Run(name, func(t *testing.T) {
    74  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    75  				assert.Equal(t, test.expectedPath, r.URL.String())
    76  				assert.Equal(t, http.MethodGet, r.Method)
    77  				w.WriteHeader(test.responseStatus)
    78  				_, err := w.Write([]byte(test.responseBody))
    79  				assert.NoError(t, err)
    80  			}))
    81  			client := mockAPIClient(t, mockServer)
    82  			result, err := client.GetReputationAnalysis(
    83  				session.ContextWithOptions(
    84  					context.Background(),
    85  					session.WithContextHeaders(test.headers),
    86  				),
    87  				test.params)
    88  			if test.withError != nil {
    89  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
    90  				return
    91  			}
    92  			require.NoError(t, err)
    93  			assert.Equal(t, test.expectedResponse, result)
    94  		})
    95  	}
    96  }
    97  
    98  // Test ReputationAnalysis
    99  func TestAppSec_GetReputationAnalysis(t *testing.T) {
   100  
   101  	result := GetReputationAnalysisResponse{}
   102  
   103  	respData := compactJSON(loadFixtureBytes("testdata/TestReputationAnalysis/ReputationAnalysis.json"))
   104  	err := json.Unmarshal([]byte(respData), &result)
   105  	require.NoError(t, err)
   106  
   107  	tests := map[string]struct {
   108  		params           GetReputationAnalysisRequest
   109  		responseStatus   int
   110  		responseBody     string
   111  		expectedPath     string
   112  		expectedResponse *GetReputationAnalysisResponse
   113  		withError        error
   114  	}{
   115  		"200 OK": {
   116  			params: GetReputationAnalysisRequest{
   117  				ConfigID: 43253,
   118  				Version:  15,
   119  				PolicyID: "AAAA_81230",
   120  			},
   121  			responseStatus:   http.StatusOK,
   122  			responseBody:     respData,
   123  			expectedPath:     "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
   124  			expectedResponse: &result,
   125  		},
   126  		"500 internal server error": {
   127  			params: GetReputationAnalysisRequest{
   128  				ConfigID: 43253,
   129  				Version:  15,
   130  				PolicyID: "AAAA_81230",
   131  			},
   132  			responseStatus: http.StatusInternalServerError,
   133  			responseBody: `
   134  			{
   135  				"type": "internal_error",
   136  				"title": "Internal Server Error",
   137  				"detail": "Error fetching ReputationAnalysis"
   138  			}`,
   139  			expectedPath: "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
   140  			withError: &Error{
   141  				Type:       "internal_error",
   142  				Title:      "Internal Server Error",
   143  				Detail:     "Error fetching ReputationAnalysis",
   144  				StatusCode: http.StatusInternalServerError,
   145  			},
   146  		},
   147  	}
   148  
   149  	for name, test := range tests {
   150  		t.Run(name, func(t *testing.T) {
   151  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   152  				assert.Equal(t, test.expectedPath, r.URL.String())
   153  				assert.Equal(t, http.MethodGet, r.Method)
   154  				w.WriteHeader(test.responseStatus)
   155  				_, err := w.Write([]byte(test.responseBody))
   156  				assert.NoError(t, err)
   157  			}))
   158  			client := mockAPIClient(t, mockServer)
   159  			result, err := client.GetReputationAnalysis(context.Background(), test.params)
   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  // Test Update ReputationAnalysis
   171  func TestAppSec_UpdateReputationAnalysis(t *testing.T) {
   172  	result := UpdateReputationAnalysisResponse{}
   173  
   174  	respData := compactJSON(loadFixtureBytes("testdata/TestReputationAnalysis/ReputationAnalysis.json"))
   175  	err := json.Unmarshal([]byte(respData), &result)
   176  	require.NoError(t, err)
   177  
   178  	req := UpdateReputationAnalysisRequest{}
   179  
   180  	reqData := compactJSON(loadFixtureBytes("testdata/TestReputationAnalysis/ReputationAnalysis.json"))
   181  	err = json.Unmarshal([]byte(reqData), &req)
   182  	require.NoError(t, err)
   183  
   184  	tests := map[string]struct {
   185  		params           UpdateReputationAnalysisRequest
   186  		responseStatus   int
   187  		responseBody     string
   188  		expectedPath     string
   189  		expectedResponse *UpdateReputationAnalysisResponse
   190  		withError        error
   191  		headers          http.Header
   192  	}{
   193  		"200 Success": {
   194  			params: UpdateReputationAnalysisRequest{
   195  				ConfigID: 43253,
   196  				Version:  15,
   197  				PolicyID: "AAAA_81230",
   198  			},
   199  			headers: http.Header{
   200  				"Content-Type": []string{"application/json;charset=UTF-8"},
   201  			},
   202  			responseStatus:   http.StatusCreated,
   203  			responseBody:     respData,
   204  			expectedResponse: &result,
   205  			expectedPath:     "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
   206  		},
   207  		"500 internal server error": {
   208  			params: UpdateReputationAnalysisRequest{
   209  				ConfigID: 43253,
   210  				Version:  15,
   211  				PolicyID: "AAAA_81230",
   212  			},
   213  			responseStatus: http.StatusInternalServerError,
   214  			responseBody: `
   215  			{
   216  				"type": "internal_error",
   217  				"title": "Internal Server Error",
   218  				"detail": "Error creating ReputationAnalysis"
   219  			}`,
   220  			expectedPath: "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
   221  			withError: &Error{
   222  				Type:       "internal_error",
   223  				Title:      "Internal Server Error",
   224  				Detail:     "Error creating ReputationAnalysis",
   225  				StatusCode: http.StatusInternalServerError,
   226  			},
   227  		},
   228  	}
   229  
   230  	for name, test := range tests {
   231  		t.Run(name, func(t *testing.T) {
   232  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   233  				assert.Equal(t, test.expectedPath, r.URL.String())
   234  				assert.Equal(t, http.MethodPut, r.Method)
   235  				w.WriteHeader(test.responseStatus)
   236  				if len(test.responseBody) > 0 {
   237  					_, err := w.Write([]byte(test.responseBody))
   238  					assert.NoError(t, err)
   239  				}
   240  			}))
   241  			client := mockAPIClient(t, mockServer)
   242  			result, err := client.UpdateReputationAnalysis(
   243  				session.ContextWithOptions(
   244  					context.Background(),
   245  					session.WithContextHeaders(test.headers)), test.params)
   246  			if test.withError != nil {
   247  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   248  				return
   249  			}
   250  			require.NoError(t, err)
   251  			assert.Equal(t, test.expectedResponse, result)
   252  		})
   253  	}
   254  }
   255  
   256  // Test Remove ReputationAnalysis
   257  func TestAppSec_RemoveReputationAnalysis(t *testing.T) {
   258  
   259  	result := RemoveReputationAnalysisResponse{}
   260  
   261  	respData := compactJSON(loadFixtureBytes("testdata/TestReputationAnalysis/ReputationAnalysisEmpty.json"))
   262  	err := json.Unmarshal([]byte(respData), &result)
   263  	require.NoError(t, err)
   264  
   265  	req := RemoveReputationAnalysisRequest{}
   266  
   267  	reqData := compactJSON(loadFixtureBytes("testdata/TestReputationAnalysis/ReputationAnalysisEmpty.json"))
   268  	err = json.Unmarshal([]byte(reqData), &req)
   269  	require.NoError(t, err)
   270  
   271  	tests := map[string]struct {
   272  		params           RemoveReputationAnalysisRequest
   273  		responseStatus   int
   274  		responseBody     string
   275  		expectedPath     string
   276  		expectedResponse *RemoveReputationAnalysisResponse
   277  		withError        error
   278  		headers          http.Header
   279  	}{
   280  		"200 Success": {
   281  			params: RemoveReputationAnalysisRequest{
   282  				ConfigID: 43253,
   283  				Version:  15,
   284  				PolicyID: "AAAA_81230",
   285  			},
   286  			headers: http.Header{
   287  				"Content-Type": []string{"application/json;charset=UTF-8"},
   288  			},
   289  			responseStatus:   http.StatusOK,
   290  			responseBody:     respData,
   291  			expectedResponse: &result,
   292  			expectedPath:     "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
   293  		},
   294  		"500 internal server error": {
   295  			params: RemoveReputationAnalysisRequest{
   296  				ConfigID: 43253,
   297  				Version:  15,
   298  				PolicyID: "AAAA_81230",
   299  			},
   300  			responseStatus: http.StatusInternalServerError,
   301  			responseBody: `
   302  			{
   303  				"type": "internal_error",
   304  				"title": "Internal Server Error",
   305  				"detail": "Error deleting ReputationAnalysis"
   306  			}`,
   307  			expectedPath: "/appsec/v1/configs/43253/versions/15/security-policies/AAAA_81230/reputation-analysis",
   308  			withError: &Error{
   309  				Type:       "internal_error",
   310  				Title:      "Internal Server Error",
   311  				Detail:     "Error deleting ReputationAnalysis",
   312  				StatusCode: http.StatusInternalServerError,
   313  			},
   314  		},
   315  	}
   316  
   317  	for name, test := range tests {
   318  		t.Run(name, func(t *testing.T) {
   319  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   320  				assert.Equal(t, test.expectedPath, r.URL.String())
   321  				assert.Equal(t, http.MethodPut, r.Method)
   322  				w.WriteHeader(test.responseStatus)
   323  				if len(test.responseBody) > 0 {
   324  					_, err := w.Write([]byte(test.responseBody))
   325  					assert.NoError(t, err)
   326  				}
   327  			}))
   328  			client := mockAPIClient(t, mockServer)
   329  			result, err := client.RemoveReputationAnalysis(
   330  				session.ContextWithOptions(
   331  					context.Background(),
   332  					session.WithContextHeaders(test.headers)), test.params)
   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  }