github.com/akamai/AkamaiOPEN-edgegrid-golang/v2@v2.17.0/pkg/appsec/malware_policy_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/v2/pkg/session"
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestAppSec_GetMalwarePolicy(t *testing.T) {
    17  
    18  	respData := compactJSON(loadFixtureBytes("testdata/TestMalwarePolicy/MalwarePolicyResponse.json"))
    19  	result := MalwarePolicyResponse{}
    20  	json.Unmarshal([]byte(respData), &result)
    21  
    22  	tests := map[string]struct {
    23  		params           GetMalwarePolicyRequest
    24  		responseStatus   int
    25  		responseBody     string
    26  		expectedPath     string
    27  		expectedResponse *MalwarePolicyResponse
    28  		withError        error
    29  	}{
    30  		"200 OK": {
    31  			params: GetMalwarePolicyRequest{
    32  				ConfigID:        43253,
    33  				ConfigVersion:   15,
    34  				MalwarePolicyID: 134644,
    35  			},
    36  			responseStatus:   http.StatusOK,
    37  			responseBody:     respData,
    38  			expectedPath:     "/appsec/v1/configs/43253/versions/15/malware-policies/134644",
    39  			expectedResponse: &result,
    40  		},
    41  		"500 internal server error": {
    42  			params: GetMalwarePolicyRequest{
    43  				ConfigID:        43253,
    44  				ConfigVersion:   15,
    45  				MalwarePolicyID: 134644,
    46  			},
    47  			responseStatus: http.StatusInternalServerError,
    48  			responseBody: (`
    49  {
    50      "type": "internal_error",
    51      "title": "Internal Server Error",
    52      "detail": "Error fetching match target"
    53  }`),
    54  			expectedPath: "/appsec/v1/configs/43253/versions/15/malware-policies/134644",
    55  			withError: &Error{
    56  				Type:       "internal_error",
    57  				Title:      "Internal Server Error",
    58  				Detail:     "Error fetching match target",
    59  				StatusCode: http.StatusInternalServerError,
    60  			},
    61  		},
    62  	}
    63  
    64  	for name, test := range tests {
    65  		t.Run(name, func(t *testing.T) {
    66  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    67  				assert.Equal(t, test.expectedPath, r.URL.String())
    68  				assert.Equal(t, http.MethodGet, r.Method)
    69  				w.WriteHeader(test.responseStatus)
    70  				_, err := w.Write([]byte(test.responseBody))
    71  				assert.NoError(t, err)
    72  			}))
    73  			client := mockAPIClient(t, mockServer)
    74  			result, err := client.GetMalwarePolicy(context.Background(), test.params)
    75  			if test.withError != nil {
    76  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
    77  				return
    78  			}
    79  			require.NoError(t, err)
    80  			assert.Equal(t, test.expectedResponse, result)
    81  		})
    82  	}
    83  }
    84  
    85  func TestAppSec_ListMalwareProtectionPolicies(t *testing.T) {
    86  
    87  	respData := compactJSON(loadFixtureBytes("testdata/TestMalwarePolicy/MalwarePolicies.json"))
    88  	result := MalwarePoliciesResponse{}
    89  	json.Unmarshal([]byte(respData), &result)
    90  
    91  	tests := map[string]struct {
    92  		params           GetMalwarePoliciesRequest
    93  		responseStatus   int
    94  		responseBody     string
    95  		expectedPath     string
    96  		expectedResponse *MalwarePoliciesResponse
    97  		withError        error
    98  		headers          http.Header
    99  	}{
   100  		"200 OK": {
   101  			params: GetMalwarePoliciesRequest{
   102  				ConfigID:      43253,
   103  				ConfigVersion: 15,
   104  			},
   105  			headers: http.Header{
   106  				"Content-Type": []string{"application/json"},
   107  			},
   108  			responseStatus:   http.StatusOK,
   109  			responseBody:     string(respData),
   110  			expectedPath:     "/appsec/v1/configs/43253/versions/15/malware-policies",
   111  			expectedResponse: &result,
   112  		},
   113  		"500 internal server error": {
   114  			params: GetMalwarePoliciesRequest{
   115  				ConfigID:      43253,
   116  				ConfigVersion: 15,
   117  			},
   118  			headers:        http.Header{},
   119  			responseStatus: http.StatusInternalServerError,
   120  			responseBody: `
   121  {
   122      "type": "internal_error",
   123      "title": "Internal Server Error",
   124      "detail": "Error fetching propertys",
   125      "status": 500
   126  }`,
   127  			expectedPath: "/appsec/v1/configs/43253/versions/15/malware-policies",
   128  			withError: &Error{
   129  				Type:       "internal_error",
   130  				Title:      "Internal Server Error",
   131  				Detail:     "Error fetching propertys",
   132  				StatusCode: http.StatusInternalServerError,
   133  			},
   134  		},
   135  	}
   136  
   137  	for name, test := range tests {
   138  		t.Run(name, func(t *testing.T) {
   139  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   140  				assert.Equal(t, test.expectedPath, r.URL.String())
   141  				assert.Equal(t, http.MethodGet, r.Method)
   142  				w.WriteHeader(test.responseStatus)
   143  				_, err := w.Write([]byte(test.responseBody))
   144  				assert.NoError(t, err)
   145  			}))
   146  			client := mockAPIClient(t, mockServer)
   147  			result, err := client.GetMalwarePolicies(
   148  				session.ContextWithOptions(
   149  					context.Background(),
   150  					session.WithContextHeaders(test.headers),
   151  				),
   152  				test.params)
   153  			if test.withError != nil {
   154  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   155  				return
   156  			}
   157  			require.NoError(t, err)
   158  			assert.Equal(t, test.expectedResponse, result)
   159  		})
   160  	}
   161  }
   162  
   163  // Test Create MalwarePolicy
   164  func TestAppSec_CreateMalwarePolicy(t *testing.T) {
   165  
   166  	reqData := compactJSON(loadFixtureBytes("testdata/TestMalwarePolicy/MalwarePolicyResponse.json"))
   167  	req := MalwarePolicyBody{}
   168  	json.Unmarshal([]byte(reqData), &req)
   169  
   170  	respData := compactJSON(loadFixtureBytes("testdata/TestMalwarePolicy/MalwarePolicyResponse.json"))
   171  	result := MalwarePolicyResponse{}
   172  	json.Unmarshal([]byte(respData), &result)
   173  
   174  	tests := map[string]struct {
   175  		params           CreateMalwarePolicyRequest
   176  		prop             *CreateMalwarePolicyRequest
   177  		responseStatus   int
   178  		responseBody     string
   179  		expectedPath     string
   180  		expectedResponse *MalwarePolicyResponse
   181  		withError        error
   182  		headers          http.Header
   183  	}{
   184  		"201 Created": {
   185  			params: CreateMalwarePolicyRequest{
   186  				ConfigID:      43253,
   187  				ConfigVersion: 15,
   188  				Policy:        &req,
   189  			},
   190  			headers: http.Header{
   191  				"Content-Type": []string{"application/json;charset=UTF-8"},
   192  			},
   193  			responseStatus:   http.StatusCreated,
   194  			responseBody:     respData,
   195  			expectedResponse: &result,
   196  			expectedPath:     "/appsec/v1/configs/43253/versions/15/malware-policies",
   197  		},
   198  		"500 internal server error": {
   199  			params: CreateMalwarePolicyRequest{
   200  				ConfigID:      43253,
   201  				ConfigVersion: 15,
   202  				Policy:        &req,
   203  			},
   204  			responseStatus: http.StatusInternalServerError,
   205  			responseBody: (`
   206  {
   207      "type": "internal_error",
   208      "title": "Internal Server Error",
   209      "detail": "Error creating domain"
   210  }`),
   211  			expectedPath: "/appsec/v1/configs/43253/versions/15/malware-policies",
   212  			withError: &Error{
   213  				Type:       "internal_error",
   214  				Title:      "Internal Server Error",
   215  				Detail:     "Error creating domain",
   216  				StatusCode: http.StatusInternalServerError,
   217  			},
   218  		},
   219  	}
   220  
   221  	for name, test := range tests {
   222  		t.Run(name, func(t *testing.T) {
   223  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   224  				assert.Equal(t, http.MethodPost, r.Method)
   225  				w.WriteHeader(test.responseStatus)
   226  				if len(test.responseBody) > 0 {
   227  					_, err := w.Write([]byte(test.responseBody))
   228  					assert.NoError(t, err)
   229  				}
   230  			}))
   231  			client := mockAPIClient(t, mockServer)
   232  			result, err := client.CreateMalwarePolicy(
   233  				session.ContextWithOptions(
   234  					context.Background(),
   235  					session.WithContextHeaders(test.headers)), test.params)
   236  			if test.withError != nil {
   237  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   238  				return
   239  			}
   240  			require.NoError(t, err)
   241  			assert.Equal(t, test.expectedResponse, result)
   242  		})
   243  	}
   244  }
   245  
   246  // Test Update MalwarePolicy
   247  func TestAppSec_UpdateMalwarePolicy(t *testing.T) {
   248  
   249  	reqData := compactJSON(loadFixtureBytes("testdata/TestMalwarePolicy/MalwarePolicyDescription.json"))
   250  	req := MalwarePolicyBody{}
   251  	json.Unmarshal([]byte(reqData), &req)
   252  
   253  	respData := compactJSON(loadFixtureBytes("testdata/TestMalwarePolicy/MalwarePolicyResponse.json"))
   254  	result := MalwarePolicyResponse{}
   255  	json.Unmarshal([]byte(respData), &result)
   256  
   257  	tests := map[string]struct {
   258  		params           UpdateMalwarePolicyRequest
   259  		responseStatus   int
   260  		responseBody     string
   261  		expectedPath     string
   262  		expectedResponse *MalwarePolicyResponse
   263  		withError        error
   264  		headers          http.Header
   265  	}{
   266  		"200 Success": {
   267  			params: UpdateMalwarePolicyRequest{
   268  				ConfigID:        43253,
   269  				ConfigVersion:   15,
   270  				MalwarePolicyID: 134644,
   271  				Policy:          &req,
   272  			},
   273  			headers: http.Header{
   274  				"Content-Type": []string{"application/json;charset=UTF-8"},
   275  			},
   276  			responseStatus:   http.StatusCreated,
   277  			responseBody:     respData,
   278  			expectedResponse: &result,
   279  			expectedPath:     "/appsec/v1/configs/43253/versions/15/malware-policies/134644",
   280  		},
   281  		"500 internal server error": {
   282  			params: UpdateMalwarePolicyRequest{
   283  				ConfigID:        43253,
   284  				ConfigVersion:   15,
   285  				MalwarePolicyID: 134644,
   286  				Policy:          &req,
   287  			},
   288  			responseStatus: http.StatusInternalServerError,
   289  			responseBody: (`
   290  {
   291      "type": "internal_error",
   292      "title": "Internal Server Error",
   293      "detail": "Error creating zone"
   294  }`),
   295  			expectedPath: "/appsec/v1/configs/43253/versions/15/malware-policies/134644",
   296  			withError: &Error{
   297  				Type:       "internal_error",
   298  				Title:      "Internal Server Error",
   299  				Detail:     "Error creating zone",
   300  				StatusCode: http.StatusInternalServerError,
   301  			},
   302  		},
   303  	}
   304  
   305  	for name, test := range tests {
   306  		t.Run(name, func(t *testing.T) {
   307  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   308  				assert.Equal(t, http.MethodPut, r.Method)
   309  				w.WriteHeader(test.responseStatus)
   310  				if len(test.responseBody) > 0 {
   311  					_, err := w.Write([]byte(test.responseBody))
   312  					assert.NoError(t, err)
   313  				}
   314  			}))
   315  			client := mockAPIClient(t, mockServer)
   316  			result, err := client.UpdateMalwarePolicy(
   317  				session.ContextWithOptions(
   318  					context.Background(),
   319  					session.WithContextHeaders(test.headers)), test.params)
   320  			if test.withError != nil {
   321  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   322  				return
   323  			}
   324  			require.NoError(t, err)
   325  			assert.Equal(t, test.expectedResponse, result)
   326  		})
   327  	}
   328  }
   329  
   330  // Test Remove MalwarePolicy
   331  func TestAppSec_RemoveMalwarePolicy(t *testing.T) {
   332  
   333  	tests := map[string]struct {
   334  		params         RemoveMalwarePolicyRequest
   335  		responseStatus int
   336  		responseBody   string
   337  		expectedPath   string
   338  		withError      error
   339  		headers        http.Header
   340  	}{
   341  		"200 Success": {
   342  			params: RemoveMalwarePolicyRequest{
   343  				ConfigID:        43253,
   344  				ConfigVersion:   15,
   345  				MalwarePolicyID: 134644,
   346  			},
   347  			headers: http.Header{
   348  				"Content-Type": []string{"application/json;charset=UTF-8"},
   349  			},
   350  			responseStatus: http.StatusOK,
   351  			expectedPath:   "/appsec/v1/configs/43253/versions/15/malware-policies/134644",
   352  		},
   353  		"500 internal server error": {
   354  			params: RemoveMalwarePolicyRequest{
   355  				ConfigID:        43253,
   356  				ConfigVersion:   15,
   357  				MalwarePolicyID: 134644,
   358  			},
   359  			responseStatus: http.StatusInternalServerError,
   360  			responseBody: (`
   361  {
   362      "type": "internal_error",
   363      "title": "Internal Server Error",
   364      "detail": "Error deleting match target"
   365  }`),
   366  			expectedPath: "/appsec/v1/configs/43253/versions/15/malware-policies/134644",
   367  			withError: &Error{
   368  				Type:       "internal_error",
   369  				Title:      "Internal Server Error",
   370  				Detail:     "Error deleting match target",
   371  				StatusCode: http.StatusInternalServerError,
   372  			},
   373  		},
   374  	}
   375  
   376  	for name, test := range tests {
   377  		t.Run(name, func(t *testing.T) {
   378  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   379  				assert.Equal(t, http.MethodDelete, r.Method)
   380  				w.WriteHeader(test.responseStatus)
   381  				if len(test.responseBody) > 0 {
   382  					_, err := w.Write([]byte(test.responseBody))
   383  					assert.NoError(t, err)
   384  				}
   385  			}))
   386  			client := mockAPIClient(t, mockServer)
   387  			err := client.RemoveMalwarePolicy(
   388  				session.ContextWithOptions(
   389  					context.Background(),
   390  					session.WithContextHeaders(test.headers)), test.params)
   391  			if test.withError != nil {
   392  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   393  				return
   394  			}
   395  			require.NoError(t, err)
   396  		})
   397  	}
   398  }