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

     1  package botman
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"testing"
     9  
    10  	"github.com/akamai/AkamaiOPEN-edgegrid-golang/v8/pkg/session"
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  // Test Get RecategorizedAkamaiDefinedBot List
    16  func TestBotman_GetRecategorizedAkamaiDefinedBotList(t *testing.T) {
    17  
    18  	tests := map[string]struct {
    19  		params           GetRecategorizedAkamaiDefinedBotListRequest
    20  		responseStatus   int
    21  		responseBody     string
    22  		expectedPath     string
    23  		expectedResponse *GetRecategorizedAkamaiDefinedBotListResponse
    24  		withError        func(*testing.T, error)
    25  	}{
    26  		"200 OK": {
    27  			params: GetRecategorizedAkamaiDefinedBotListRequest{
    28  				ConfigID: 43253,
    29  				Version:  15,
    30  			},
    31  			responseStatus: http.StatusOK,
    32  			responseBody: `
    33  {
    34  	"recategorizedBots": [
    35  		{"botId":"b85e3eaa-d334-466d-857e-33308ce416be", "customBotCategoryId":"39cbadc6-c5ef-42d1-9290-7895f24316ad"},
    36  		{"botId":"69acad64-7459-4c1d-9bad-672600150127", "customBotCategoryId":"5eb700c8-275d-4866-a271-b6fa25e1fdc5"},
    37  		{"botId":"cc9c3f89-e179-4892-89cf-d5e623ba9dc7", "customBotCategoryId":"0d38d0fe-b05d-42f6-a58f-bc98c821793e"},
    38  		{"botId":"10c54ea3-e3cb-4fc0-b0e0-fa3658aebd7b", "customBotCategoryId":"87a152a9-8af0-4c4f-9c37-a895fe7ca6b4"},
    39  		{"botId":"4d64d85a-a07f-485a-bbac-24c60658a1b8", "customBotCategoryId":"b61a3017-bff4-41b0-9396-be378d4f07c1"}
    40  	]
    41  }`,
    42  			expectedPath: "/appsec/v1/configs/43253/versions/15/recategorized-akamai-defined-bots",
    43  			expectedResponse: &GetRecategorizedAkamaiDefinedBotListResponse{
    44  				Bots: []RecategorizedAkamaiDefinedBotResponse{
    45  					{BotID: "b85e3eaa-d334-466d-857e-33308ce416be", CategoryID: "39cbadc6-c5ef-42d1-9290-7895f24316ad"},
    46  					{BotID: "69acad64-7459-4c1d-9bad-672600150127", CategoryID: "5eb700c8-275d-4866-a271-b6fa25e1fdc5"},
    47  					{BotID: "cc9c3f89-e179-4892-89cf-d5e623ba9dc7", CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e"},
    48  					{BotID: "10c54ea3-e3cb-4fc0-b0e0-fa3658aebd7b", CategoryID: "87a152a9-8af0-4c4f-9c37-a895fe7ca6b4"},
    49  					{BotID: "4d64d85a-a07f-485a-bbac-24c60658a1b8", CategoryID: "b61a3017-bff4-41b0-9396-be378d4f07c1"},
    50  				},
    51  			},
    52  		},
    53  		"200 OK One Record": {
    54  			params: GetRecategorizedAkamaiDefinedBotListRequest{
    55  				ConfigID: 43253,
    56  				Version:  15,
    57  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
    58  			},
    59  			responseStatus: http.StatusOK,
    60  			responseBody: `
    61  {
    62  	"recategorizedBots":[
    63  		{"botId":"b85e3eaa-d334-466d-857e-33308ce416be", "customBotCategoryId":"39cbadc6-c5ef-42d1-9290-7895f24316ad"},
    64  		{"botId":"69acad64-7459-4c1d-9bad-672600150127", "customBotCategoryId":"5eb700c8-275d-4866-a271-b6fa25e1fdc5"},
    65  		{"botId":"cc9c3f89-e179-4892-89cf-d5e623ba9dc7", "customBotCategoryId":"0d38d0fe-b05d-42f6-a58f-bc98c821793e"},
    66  		{"botId":"10c54ea3-e3cb-4fc0-b0e0-fa3658aebd7b", "customBotCategoryId":"87a152a9-8af0-4c4f-9c37-a895fe7ca6b4"},
    67  		{"botId":"4d64d85a-a07f-485a-bbac-24c60658a1b8", "customBotCategoryId":"b61a3017-bff4-41b0-9396-be378d4f07c1"}
    68  	]
    69  }`,
    70  			expectedPath: "/appsec/v1/configs/43253/versions/15/recategorized-akamai-defined-bots",
    71  			expectedResponse: &GetRecategorizedAkamaiDefinedBotListResponse{
    72  				Bots: []RecategorizedAkamaiDefinedBotResponse{
    73  					{BotID: "cc9c3f89-e179-4892-89cf-d5e623ba9dc7", CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e"},
    74  				},
    75  			},
    76  		},
    77  		"500 internal server error": {
    78  			params: GetRecategorizedAkamaiDefinedBotListRequest{
    79  				ConfigID: 43253,
    80  				Version:  15,
    81  			},
    82  			responseStatus: http.StatusInternalServerError,
    83  			responseBody: `
    84  {
    85     "type": "internal_error",
    86     "title": "Internal Server Error",
    87     "detail": "Error fetching data",
    88     "status": 500
    89  }`,
    90  			expectedPath: "/appsec/v1/configs/43253/versions/15/recategorized-akamai-defined-bots",
    91  			withError: func(t *testing.T, err error) {
    92  				want := &Error{
    93  					Type:       "internal_error",
    94  					Title:      "Internal Server Error",
    95  					Detail:     "Error fetching data",
    96  					StatusCode: http.StatusInternalServerError,
    97  				}
    98  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
    99  			},
   100  		},
   101  		"Missing ConfigID": {
   102  			params: GetRecategorizedAkamaiDefinedBotListRequest{
   103  				Version: 15,
   104  			},
   105  			withError: func(t *testing.T, err error) {
   106  				want := ErrStructValidation
   107  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   108  				assert.Contains(t, err.Error(), "ConfigID")
   109  			},
   110  		},
   111  		"Missing Version": {
   112  			params: GetRecategorizedAkamaiDefinedBotListRequest{
   113  				ConfigID: 43253,
   114  			},
   115  			withError: func(t *testing.T, err error) {
   116  				want := ErrStructValidation
   117  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   118  				assert.Contains(t, err.Error(), "Version")
   119  			},
   120  		},
   121  	}
   122  
   123  	for name, test := range tests {
   124  		t.Run(name, func(t *testing.T) {
   125  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   126  				assert.Equal(t, test.expectedPath, r.URL.String())
   127  				assert.Equal(t, http.MethodGet, r.Method)
   128  				w.WriteHeader(test.responseStatus)
   129  				_, err := w.Write([]byte(test.responseBody))
   130  				assert.NoError(t, err)
   131  			}))
   132  			client := mockAPIClient(t, mockServer)
   133  			result, err := client.GetRecategorizedAkamaiDefinedBotList(
   134  				session.ContextWithOptions(
   135  					context.Background(),
   136  				),
   137  				test.params)
   138  			if test.withError != nil {
   139  				test.withError(t, err)
   140  				return
   141  			}
   142  			require.NoError(t, err)
   143  			assert.Equal(t, test.expectedResponse, result)
   144  		})
   145  	}
   146  }
   147  
   148  // Test Get RecategorizedAkamaiDefinedBot
   149  func TestBotman_GetRecategorizedAkamaiDefinedBot(t *testing.T) {
   150  	tests := map[string]struct {
   151  		params           GetRecategorizedAkamaiDefinedBotRequest
   152  		responseStatus   int
   153  		responseBody     string
   154  		expectedPath     string
   155  		expectedResponse *RecategorizedAkamaiDefinedBotResponse
   156  		withError        func(*testing.T, error)
   157  	}{
   158  		"200 OK": {
   159  			params: GetRecategorizedAkamaiDefinedBotRequest{
   160  				ConfigID: 43253,
   161  				Version:  15,
   162  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   163  			},
   164  			responseStatus: http.StatusOK,
   165  			responseBody:   `{"botId":"cc9c3f89-e179-4892-89cf-d5e623ba9dc7", "customBotCategoryId":"0d38d0fe-b05d-42f6-a58f-bc98c821793e"}`,
   166  			expectedPath:   "/appsec/v1/configs/43253/versions/15/recategorized-akamai-defined-bots/cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   167  			expectedResponse: &RecategorizedAkamaiDefinedBotResponse{
   168  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   169  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   170  			},
   171  		},
   172  		"500 internal server error": {
   173  			params: GetRecategorizedAkamaiDefinedBotRequest{
   174  				ConfigID: 43253,
   175  				Version:  15,
   176  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   177  			},
   178  			responseStatus: http.StatusInternalServerError,
   179  			responseBody: `
   180  			{
   181  				"type": "internal_error",
   182  				"title": "Internal Server Error",
   183  				"detail": "Error fetching data"
   184  			}`,
   185  			expectedPath: "/appsec/v1/configs/43253/versions/15/recategorized-akamai-defined-bots/cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   186  			withError: func(t *testing.T, err error) {
   187  				want := &Error{
   188  					Type:       "internal_error",
   189  					Title:      "Internal Server Error",
   190  					Detail:     "Error fetching data",
   191  					StatusCode: http.StatusInternalServerError,
   192  				}
   193  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   194  			},
   195  		},
   196  		"Missing ConfigID": {
   197  			params: GetRecategorizedAkamaiDefinedBotRequest{
   198  				Version: 15,
   199  				BotID:   "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   200  			},
   201  			withError: func(t *testing.T, err error) {
   202  				want := ErrStructValidation
   203  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   204  				assert.Contains(t, err.Error(), "ConfigID")
   205  			},
   206  		},
   207  		"Missing Version": {
   208  			params: GetRecategorizedAkamaiDefinedBotRequest{
   209  				ConfigID: 43253,
   210  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   211  			},
   212  			withError: func(t *testing.T, err error) {
   213  				want := ErrStructValidation
   214  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   215  				assert.Contains(t, err.Error(), "Version")
   216  			},
   217  		},
   218  		"Missing BotID": {
   219  			params: GetRecategorizedAkamaiDefinedBotRequest{
   220  				ConfigID: 43253,
   221  				Version:  15,
   222  			},
   223  			withError: func(t *testing.T, err error) {
   224  				want := ErrStructValidation
   225  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   226  				assert.Contains(t, err.Error(), "BotID")
   227  			},
   228  		},
   229  	}
   230  
   231  	for name, test := range tests {
   232  		t.Run(name, func(t *testing.T) {
   233  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   234  				assert.Equal(t, test.expectedPath, r.URL.String())
   235  				assert.Equal(t, http.MethodGet, r.Method)
   236  				w.WriteHeader(test.responseStatus)
   237  				_, err := w.Write([]byte(test.responseBody))
   238  				assert.NoError(t, err)
   239  			}))
   240  			client := mockAPIClient(t, mockServer)
   241  			result, err := client.GetRecategorizedAkamaiDefinedBot(context.Background(), test.params)
   242  			if test.withError != nil {
   243  				test.withError(t, err)
   244  				return
   245  			}
   246  			require.NoError(t, err)
   247  			assert.Equal(t, test.expectedResponse, result)
   248  		})
   249  	}
   250  }
   251  
   252  // Test Create RecategorizedAkamaiDefinedBot
   253  func TestBotman_CreateRecategorizedAkamaiDefinedBot(t *testing.T) {
   254  
   255  	tests := map[string]struct {
   256  		params           CreateRecategorizedAkamaiDefinedBotRequest
   257  		prop             *CreateRecategorizedAkamaiDefinedBotRequest
   258  		responseStatus   int
   259  		responseBody     string
   260  		expectedPath     string
   261  		expectedResponse *RecategorizedAkamaiDefinedBotResponse
   262  		withError        func(*testing.T, error)
   263  	}{
   264  		"201 Created": {
   265  			params: CreateRecategorizedAkamaiDefinedBotRequest{
   266  				ConfigID:   43253,
   267  				Version:    15,
   268  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   269  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   270  			},
   271  			responseStatus: http.StatusCreated,
   272  			responseBody:   `{"botId":"cc9c3f89-e179-4892-89cf-d5e623ba9dc7", "customBotCategoryId":"0d38d0fe-b05d-42f6-a58f-bc98c821793e"}`,
   273  			expectedResponse: &RecategorizedAkamaiDefinedBotResponse{
   274  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   275  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   276  			},
   277  			expectedPath: "/appsec/v1/configs/43253/versions/15/recategorized-akamai-defined-bots",
   278  		},
   279  		"500 internal server error": {
   280  			params: CreateRecategorizedAkamaiDefinedBotRequest{
   281  				ConfigID:   43253,
   282  				Version:    15,
   283  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   284  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   285  			},
   286  			responseStatus: http.StatusInternalServerError,
   287  			responseBody: `
   288  			{
   289  				"type": "internal_error",
   290  				"title": "Internal Server Error",
   291  				"detail": "Error creating data"
   292  			}`,
   293  			expectedPath: "/appsec/v1/configs/43253/versions/15/recategorized-akamai-defined-bots",
   294  			withError: func(t *testing.T, err error) {
   295  				want := &Error{
   296  					Type:       "internal_error",
   297  					Title:      "Internal Server Error",
   298  					Detail:     "Error creating data",
   299  					StatusCode: http.StatusInternalServerError,
   300  				}
   301  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   302  			},
   303  		},
   304  		"Missing ConfigID": {
   305  			params: CreateRecategorizedAkamaiDefinedBotRequest{
   306  				Version:    15,
   307  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   308  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   309  			},
   310  			withError: func(t *testing.T, err error) {
   311  				want := ErrStructValidation
   312  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   313  				assert.Contains(t, err.Error(), "ConfigID")
   314  			},
   315  		},
   316  		"Missing Version": {
   317  			params: CreateRecategorizedAkamaiDefinedBotRequest{
   318  				ConfigID:   43253,
   319  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   320  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   321  			},
   322  			withError: func(t *testing.T, err error) {
   323  				want := ErrStructValidation
   324  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   325  				assert.Contains(t, err.Error(), "Version")
   326  			},
   327  		},
   328  		"Missing BotID": {
   329  			params: CreateRecategorizedAkamaiDefinedBotRequest{
   330  				ConfigID:   43253,
   331  				Version:    15,
   332  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   333  			},
   334  			withError: func(t *testing.T, err error) {
   335  				want := ErrStructValidation
   336  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   337  				assert.Contains(t, err.Error(), "BotID")
   338  			},
   339  		},
   340  		"Missing CategoryID": {
   341  			params: CreateRecategorizedAkamaiDefinedBotRequest{
   342  				ConfigID: 43253,
   343  				Version:  15,
   344  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   345  			},
   346  			withError: func(t *testing.T, err error) {
   347  				want := ErrStructValidation
   348  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   349  				assert.Contains(t, err.Error(), "CategoryID")
   350  			},
   351  		},
   352  	}
   353  
   354  	for name, test := range tests {
   355  		t.Run(name, func(t *testing.T) {
   356  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   357  				assert.Equal(t, test.expectedPath, r.URL.String())
   358  				assert.Equal(t, http.MethodPost, r.Method)
   359  				w.WriteHeader(test.responseStatus)
   360  				if len(test.responseBody) > 0 {
   361  					_, err := w.Write([]byte(test.responseBody))
   362  					assert.NoError(t, err)
   363  				}
   364  			}))
   365  			client := mockAPIClient(t, mockServer)
   366  			result, err := client.CreateRecategorizedAkamaiDefinedBot(session.ContextWithOptions(context.Background()), test.params)
   367  			if test.withError != nil {
   368  				test.withError(t, err)
   369  				return
   370  			}
   371  			require.NoError(t, err)
   372  			assert.Equal(t, test.expectedResponse, result)
   373  		})
   374  	}
   375  }
   376  
   377  // Test Update RecategorizedAkamaiDefinedBot
   378  func TestBotman_UpdateRecategorizedAkamaiDefinedBot(t *testing.T) {
   379  	tests := map[string]struct {
   380  		params           UpdateRecategorizedAkamaiDefinedBotRequest
   381  		responseStatus   int
   382  		responseBody     string
   383  		expectedPath     string
   384  		expectedResponse *RecategorizedAkamaiDefinedBotResponse
   385  		withError        func(*testing.T, error)
   386  	}{
   387  		"200 Success": {
   388  			params: UpdateRecategorizedAkamaiDefinedBotRequest{
   389  				ConfigID:   43253,
   390  				Version:    10,
   391  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   392  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   393  			},
   394  			responseStatus: http.StatusOK,
   395  			responseBody:   `{"botId":"cc9c3f89-e179-4892-89cf-d5e623ba9dc7", "customBotCategoryId":"0d38d0fe-b05d-42f6-a58f-bc98c821793e"}`,
   396  			expectedResponse: &RecategorizedAkamaiDefinedBotResponse{
   397  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   398  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   399  			},
   400  			expectedPath: "/appsec/v1/configs/43253/versions/10/recategorized-akamai-defined-bots/cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   401  		},
   402  		"500 internal server error": {
   403  			params: UpdateRecategorizedAkamaiDefinedBotRequest{
   404  				ConfigID:   43253,
   405  				Version:    10,
   406  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   407  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   408  			},
   409  			responseStatus: http.StatusInternalServerError,
   410  			responseBody: `
   411  			{
   412  				"type": "internal_error",
   413  				"title": "Internal Server Error",
   414  				"detail": "Error creating zone"
   415  			}`,
   416  			expectedPath: "/appsec/v1/configs/43253/versions/10/recategorized-akamai-defined-bots/cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   417  			withError: func(t *testing.T, err error) {
   418  				want := &Error{
   419  					Type:       "internal_error",
   420  					Title:      "Internal Server Error",
   421  					Detail:     "Error creating zone",
   422  					StatusCode: http.StatusInternalServerError,
   423  				}
   424  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   425  			},
   426  		},
   427  		"Missing ConfigID": {
   428  			params: UpdateRecategorizedAkamaiDefinedBotRequest{
   429  				Version:    15,
   430  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   431  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   432  			},
   433  			withError: func(t *testing.T, err error) {
   434  				want := ErrStructValidation
   435  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   436  				assert.Contains(t, err.Error(), "ConfigID")
   437  			},
   438  		},
   439  		"Missing Version": {
   440  			params: UpdateRecategorizedAkamaiDefinedBotRequest{
   441  				ConfigID:   43253,
   442  				BotID:      "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   443  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   444  			},
   445  			withError: func(t *testing.T, err error) {
   446  				want := ErrStructValidation
   447  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   448  				assert.Contains(t, err.Error(), "Version")
   449  			},
   450  		},
   451  		"Missing CategoryID": {
   452  			params: UpdateRecategorizedAkamaiDefinedBotRequest{
   453  				ConfigID: 43253,
   454  				Version:  15,
   455  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   456  			},
   457  			withError: func(t *testing.T, err error) {
   458  				want := ErrStructValidation
   459  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   460  				assert.Contains(t, err.Error(), "CategoryID")
   461  			},
   462  		},
   463  		"Missing BotID": {
   464  			params: UpdateRecategorizedAkamaiDefinedBotRequest{
   465  				ConfigID:   43253,
   466  				Version:    15,
   467  				CategoryID: "0d38d0fe-b05d-42f6-a58f-bc98c821793e",
   468  			},
   469  			withError: func(t *testing.T, err error) {
   470  				want := ErrStructValidation
   471  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   472  				assert.Contains(t, err.Error(), "BotID")
   473  			},
   474  		},
   475  	}
   476  
   477  	for name, test := range tests {
   478  		t.Run(name, func(t *testing.T) {
   479  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   480  				assert.Equal(t, test.expectedPath, r.URL.Path)
   481  				assert.Equal(t, http.MethodPut, r.Method)
   482  				w.WriteHeader(test.responseStatus)
   483  				if len(test.responseBody) > 0 {
   484  					_, err := w.Write([]byte(test.responseBody))
   485  					assert.NoError(t, err)
   486  				}
   487  			}))
   488  			client := mockAPIClient(t, mockServer)
   489  			result, err := client.UpdateRecategorizedAkamaiDefinedBot(session.ContextWithOptions(context.Background()), test.params)
   490  			if test.withError != nil {
   491  				test.withError(t, err)
   492  				return
   493  			}
   494  			require.NoError(t, err)
   495  			assert.Equal(t, test.expectedResponse, result)
   496  		})
   497  	}
   498  }
   499  
   500  // Test Remove RecategorizedAkamaiDefinedBot
   501  func TestBotman_RemoveRecategorizedAkamaiDefinedBot(t *testing.T) {
   502  	tests := map[string]struct {
   503  		params           RemoveRecategorizedAkamaiDefinedBotRequest
   504  		responseStatus   int
   505  		responseBody     string
   506  		expectedPath     string
   507  		expectedResponse map[string]interface{}
   508  		withError        func(*testing.T, error)
   509  	}{
   510  		"200 Success": {
   511  			params: RemoveRecategorizedAkamaiDefinedBotRequest{
   512  				ConfigID: 43253,
   513  				Version:  10,
   514  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   515  			},
   516  			responseStatus: http.StatusNoContent,
   517  			expectedPath:   "/appsec/v1/configs/43253/versions/10/recategorized-akamai-defined-bots/cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   518  		},
   519  		"500 internal server error": {
   520  			params: RemoveRecategorizedAkamaiDefinedBotRequest{
   521  				ConfigID: 43253,
   522  				Version:  10,
   523  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   524  			},
   525  			responseStatus: http.StatusInternalServerError,
   526  			responseBody: `
   527  			{
   528  				"type": "internal_error",
   529  				"title": "Internal Server Error",
   530  				"detail": "Error deleting match target"
   531  			}`,
   532  			expectedPath: "/appsec/v1/configs/43253/versions/10/recategorized-akamai-defined-bots/cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   533  			withError: func(t *testing.T, err error) {
   534  				want := &Error{
   535  					Type:       "internal_error",
   536  					Title:      "Internal Server Error",
   537  					Detail:     "Error deleting match target",
   538  					StatusCode: http.StatusInternalServerError,
   539  				}
   540  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   541  			},
   542  		},
   543  		"Missing ConfigID": {
   544  			params: RemoveRecategorizedAkamaiDefinedBotRequest{
   545  				Version: 15,
   546  				BotID:   "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   547  			},
   548  			withError: func(t *testing.T, err error) {
   549  				want := ErrStructValidation
   550  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   551  				assert.Contains(t, err.Error(), "ConfigID")
   552  			},
   553  		},
   554  		"Missing Version": {
   555  			params: RemoveRecategorizedAkamaiDefinedBotRequest{
   556  				ConfigID: 43253,
   557  				BotID:    "cc9c3f89-e179-4892-89cf-d5e623ba9dc7",
   558  			},
   559  			withError: func(t *testing.T, err error) {
   560  				want := ErrStructValidation
   561  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   562  				assert.Contains(t, err.Error(), "Version")
   563  			},
   564  		},
   565  		"Missing BotID": {
   566  			params: RemoveRecategorizedAkamaiDefinedBotRequest{
   567  				ConfigID: 43253,
   568  				Version:  15,
   569  			},
   570  			withError: func(t *testing.T, err error) {
   571  				want := ErrStructValidation
   572  				assert.True(t, errors.Is(err, want), "want: %s; got: %s", want, err)
   573  				assert.Contains(t, err.Error(), "BotID")
   574  			},
   575  		},
   576  	}
   577  
   578  	for name, test := range tests {
   579  		t.Run(name, func(t *testing.T) {
   580  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   581  				assert.Equal(t, test.expectedPath, r.URL.Path)
   582  				assert.Equal(t, http.MethodDelete, r.Method)
   583  				w.WriteHeader(test.responseStatus)
   584  				if len(test.responseBody) > 0 {
   585  					_, err := w.Write([]byte(test.responseBody))
   586  					assert.NoError(t, err)
   587  				}
   588  			}))
   589  			client := mockAPIClient(t, mockServer)
   590  			err := client.RemoveRecategorizedAkamaiDefinedBot(session.ContextWithOptions(context.Background()), test.params)
   591  			if test.withError != nil {
   592  				test.withError(t, err)
   593  				return
   594  			}
   595  			require.NoError(t, err)
   596  		})
   597  	}
   598  }