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