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

     1  package papi
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"io/ioutil"
     7  	"net/http"
     8  	"net/http/httptest"
     9  	"testing"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestCreateIncludeVersion(t *testing.T) {
    16  	tests := map[string]struct {
    17  		params              CreateIncludeVersionRequest
    18  		expectedRequestBody string
    19  		responseStatus      int
    20  		responseBody        string
    21  		expectedPath        string
    22  		expectedResponse    *CreateIncludeVersionResponse
    23  		withError           error
    24  	}{
    25  		"201 Created": {
    26  			params: CreateIncludeVersionRequest{
    27  				IncludeID: "inc_12345",
    28  				IncludeVersionRequest: IncludeVersionRequest{
    29  					CreateFromVersion: 2,
    30  				},
    31  			},
    32  			expectedRequestBody: `{"createFromVersion":2}`,
    33  			expectedPath:        "/papi/v1/includes/inc_12345/versions",
    34  			responseStatus:      http.StatusCreated,
    35  			responseBody: `
    36  {
    37      "versionLink": "/papi/v1/includes/inc_12345/versions/5"
    38  }`,
    39  			expectedResponse: &CreateIncludeVersionResponse{
    40  				VersionLink: "/papi/v1/includes/inc_12345/versions/5",
    41  				Version:     5,
    42  			},
    43  		},
    44  		"500 internal server error": {
    45  			params: CreateIncludeVersionRequest{
    46  				IncludeID: "inc_12345",
    47  				IncludeVersionRequest: IncludeVersionRequest{
    48  					CreateFromVersion: 2,
    49  				},
    50  			},
    51  			expectedPath:   "/papi/v1/includes/inc_12345/versions",
    52  			responseStatus: http.StatusInternalServerError,
    53  			responseBody: `
    54  {
    55  	"type": "internal_error",
    56      "title": "Internal Server Error",
    57      "detail": "Error getting include",
    58      "status": 500
    59  }`,
    60  			withError: &Error{
    61  				Type:       "internal_error",
    62  				Title:      "Internal Server Error",
    63  				Detail:     "Error getting include",
    64  				StatusCode: http.StatusInternalServerError,
    65  			},
    66  		},
    67  		"validation error - missing includeId": {
    68  			params: CreateIncludeVersionRequest{
    69  				IncludeVersionRequest: IncludeVersionRequest{
    70  					CreateFromVersion: 2,
    71  				},
    72  			},
    73  			withError: ErrStructValidation,
    74  		},
    75  		"validation error - missing createFromVersion": {
    76  			params: CreateIncludeVersionRequest{
    77  				IncludeID: "inc_12345",
    78  			},
    79  			withError: ErrStructValidation,
    80  		},
    81  	}
    82  	for name, test := range tests {
    83  		t.Run(name, func(t *testing.T) {
    84  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    85  				assert.Equal(t, test.expectedPath, r.URL.String())
    86  				assert.Equal(t, http.MethodPost, r.Method)
    87  				w.WriteHeader(test.responseStatus)
    88  				_, err := w.Write([]byte(test.responseBody))
    89  				assert.NoError(t, err)
    90  
    91  				if len(test.expectedRequestBody) > 0 {
    92  					body, err := ioutil.ReadAll(r.Body)
    93  					require.NoError(t, err)
    94  					assert.Equal(t, test.expectedRequestBody, string(body))
    95  				}
    96  			}))
    97  			client := mockAPIClient(t, mockServer)
    98  			result, err := client.CreateIncludeVersion(context.Background(), test.params)
    99  			if test.withError != nil {
   100  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   101  				return
   102  			}
   103  			require.NoError(t, err)
   104  			assert.Equal(t, test.expectedResponse, result)
   105  		})
   106  	}
   107  }
   108  
   109  func TestGetIncludeVersion(t *testing.T) {
   110  	tests := map[string]struct {
   111  		params           GetIncludeVersionRequest
   112  		responseStatus   int
   113  		responseBody     string
   114  		expectedPath     string
   115  		expectedResponse *GetIncludeVersionResponse
   116  		withError        error
   117  	}{
   118  		"200 OK": {
   119  			params: GetIncludeVersionRequest{
   120  				ContractID: "test_contract",
   121  				GroupID:    "test_group",
   122  				Version:    2,
   123  				IncludeID:  "inc_12345",
   124  			},
   125  			expectedPath:   "/papi/v1/includes/inc_12345/versions/2?contractId=test_contract&groupId=test_group",
   126  			responseStatus: http.StatusOK,
   127  			responseBody: `
   128  {
   129      "includeId": "inc_12345",
   130      "includeName": "tfp_test1",
   131      "accountId": "act_B-3-WNKA123",
   132      "contractId": "test_contract",
   133      "groupId": "test_group",
   134      "assetId": "aid_11069123",
   135      "includeType": "MICROSERVICES",
   136      "versions": {
   137          "items": [
   138              {
   139                  "updatedByUser": "test_user",
   140                  "updatedDate": "2022-08-22T07:17:48Z",
   141                  "productionStatus": "INACTIVE",
   142                  "stagingStatus": "ACTIVE",
   143                  "etag": "1d8ed19bce0833a3fe93e62ae5d5579a38cc2dbe",
   144                  "productId": "prd_Site_Defender",
   145                  "ruleFormat": "v2020-11-02",
   146                  "includeVersion": 2
   147              }
   148          ]
   149      }
   150  }`,
   151  			expectedResponse: &GetIncludeVersionResponse{
   152  				AccountID:   "act_B-3-WNKA123",
   153  				AssetID:     "aid_11069123",
   154  				ContractID:  "test_contract",
   155  				GroupID:     "test_group",
   156  				IncludeID:   "inc_12345",
   157  				IncludeName: "tfp_test1",
   158  				IncludeType: IncludeTypeMicroServices,
   159  				IncludeVersions: Versions{
   160  					Items: []IncludeVersion{
   161  						{
   162  							UpdatedByUser:    "test_user",
   163  							UpdatedDate:      "2022-08-22T07:17:48Z",
   164  							ProductionStatus: VersionStatusInactive,
   165  							Etag:             "1d8ed19bce0833a3fe93e62ae5d5579a38cc2dbe",
   166  							ProductID:        "prd_Site_Defender",
   167  							RuleFormat:       "v2020-11-02",
   168  							IncludeVersion:   2,
   169  							StagingStatus:    VersionStatusActive,
   170  						},
   171  					},
   172  				},
   173  				IncludeVersion: IncludeVersion{
   174  					UpdatedByUser:    "test_user",
   175  					UpdatedDate:      "2022-08-22T07:17:48Z",
   176  					ProductionStatus: VersionStatusInactive,
   177  					Etag:             "1d8ed19bce0833a3fe93e62ae5d5579a38cc2dbe",
   178  					ProductID:        "prd_Site_Defender",
   179  					RuleFormat:       "v2020-11-02",
   180  					IncludeVersion:   2,
   181  					StagingStatus:    VersionStatusActive,
   182  				},
   183  			},
   184  		},
   185  		"500 internal server error": {
   186  			params: GetIncludeVersionRequest{
   187  				ContractID: "test_contract",
   188  				GroupID:    "test_group",
   189  				Version:    2,
   190  				IncludeID:  "inc_12345",
   191  			},
   192  			expectedPath:   "/papi/v1/includes/inc_12345/versions/2?contractId=test_contract&groupId=test_group",
   193  			responseStatus: http.StatusInternalServerError,
   194  			responseBody: `
   195  {
   196  	"type": "internal_error",
   197      "title": "Internal Server Error",
   198      "detail": "Error getting include",
   199      "status": 500
   200  }`,
   201  			withError: &Error{
   202  				Type:       "internal_error",
   203  				Title:      "Internal Server Error",
   204  				Detail:     "Error getting include",
   205  				StatusCode: http.StatusInternalServerError,
   206  			},
   207  		},
   208  		"validation error - missing includeId": {
   209  			params: GetIncludeVersionRequest{
   210  				Version:    1,
   211  				ContractID: "test_contract",
   212  				GroupID:    "test_group",
   213  			},
   214  			withError: ErrStructValidation,
   215  		},
   216  		"validation error - missing contractId": {
   217  			params: GetIncludeVersionRequest{
   218  				IncludeID: "inc_12345",
   219  				Version:   1,
   220  				GroupID:   "test_group",
   221  			},
   222  			withError: ErrStructValidation,
   223  		},
   224  		"validation error - missing groupId": {
   225  			params: GetIncludeVersionRequest{
   226  				IncludeID:  "inc_12345",
   227  				ContractID: "test_contract",
   228  				Version:    1,
   229  			},
   230  			withError: ErrStructValidation,
   231  		},
   232  		"validation error - missing version": {
   233  			params: GetIncludeVersionRequest{
   234  				IncludeID:  "inc_12345",
   235  				ContractID: "test_contract",
   236  				GroupID:    "test_group",
   237  			},
   238  			withError: ErrStructValidation,
   239  		},
   240  	}
   241  	for name, test := range tests {
   242  		t.Run(name, func(t *testing.T) {
   243  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   244  				assert.Equal(t, test.expectedPath, r.URL.String())
   245  				assert.Equal(t, http.MethodGet, r.Method)
   246  				w.WriteHeader(test.responseStatus)
   247  				_, err := w.Write([]byte(test.responseBody))
   248  				assert.NoError(t, err)
   249  			}))
   250  			client := mockAPIClient(t, mockServer)
   251  			result, err := client.GetIncludeVersion(context.Background(), test.params)
   252  			if test.withError != nil {
   253  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   254  				return
   255  			}
   256  			require.NoError(t, err)
   257  			assert.Equal(t, test.expectedResponse, result)
   258  		})
   259  	}
   260  }
   261  
   262  func TestListIncludeVersions(t *testing.T) {
   263  	tests := map[string]struct {
   264  		params           ListIncludeVersionsRequest
   265  		responseStatus   int
   266  		responseBody     string
   267  		expectedPath     string
   268  		expectedResponse *ListIncludeVersionsResponse
   269  		withError        error
   270  	}{
   271  		"200 OK": {
   272  			params: ListIncludeVersionsRequest{
   273  				ContractID: "test_contract",
   274  				GroupID:    "test_group",
   275  				IncludeID:  "inc_12345",
   276  			},
   277  			expectedPath:   "/papi/v1/includes/inc_12345/versions?contractId=test_contract&groupId=test_group",
   278  			responseStatus: http.StatusOK,
   279  			responseBody: `
   280  {
   281      "includeId": "inc_12345",
   282      "includeName": "tfp_test1",
   283      "accountId": "act_B-3-WNKA123",
   284      "contractId": "test_contract",
   285      "groupId": "test_group",
   286      "assetId": "aid_11069123",
   287      "includeType": "MICROSERVICES",
   288      "versions": {
   289          "items": [
   290  			{
   291                  "updatedByUser": "test_user",
   292                  "updatedDate": "2022-10-14T08:41:00Z",
   293                  "productionStatus": "INACTIVE",
   294                  "stagingStatus": "INACTIVE",
   295                  "etag": "c925d2b5fa4cc002774c752186d8faafeac7f28a",
   296                  "productId": "prd_Site_Defender",
   297                  "ruleFormat": "v2020-11-02",
   298                  "includeVersion": 4
   299              },
   300              {
   301                  "updatedByUser": "test_user",
   302                  "updatedDate": "2022-08-23T12:39:33Z",
   303                  "productionStatus": "INACTIVE",
   304                  "stagingStatus": "INACTIVE",
   305                  "etag": "f5230dfe9d50e0a4a8b643388226b36db494d7c4",
   306                  "productId": "prd_Site_Defender",
   307                  "ruleFormat": "v2020-11-02",
   308                  "includeVersion": 3
   309              },
   310              {
   311                  "updatedByUser": "test_user",
   312                  "updatedDate": "2022-08-22T07:17:48Z",
   313                  "productionStatus": "INACTIVE",
   314                  "stagingStatus": "ACTIVE",
   315                  "etag": "1d8ed19bce0833a3fe93e62ae5d5579a38cc2dbe",
   316                  "productId": "prd_Site_Defender",
   317                  "ruleFormat": "v2020-11-02",
   318                  "includeVersion": 2
   319              },
   320              {
   321                  "updatedByUser": "test_user",
   322                  "updatedDate": "2022-08-16T10:29:43Z",
   323                  "productionStatus": "INACTIVE",
   324                  "stagingStatus": "DEACTIVATED",
   325                  "etag": "d2be894768ae4e587eae91f93f15d2217ef517d8",
   326                  "productId": "prd_Site_Defender",
   327                  "ruleFormat": "v2020-11-02",
   328                  "includeVersion": 1
   329              }
   330          ]
   331      }
   332  }`,
   333  			expectedResponse: &ListIncludeVersionsResponse{
   334  				AccountID:   "act_B-3-WNKA123",
   335  				AssetID:     "aid_11069123",
   336  				ContractID:  "test_contract",
   337  				GroupID:     "test_group",
   338  				IncludeID:   "inc_12345",
   339  				IncludeName: "tfp_test1",
   340  				IncludeType: IncludeTypeMicroServices,
   341  				IncludeVersions: Versions{
   342  					Items: []IncludeVersion{
   343  						{
   344  							UpdatedByUser:    "test_user",
   345  							UpdatedDate:      "2022-10-14T08:41:00Z",
   346  							ProductionStatus: VersionStatusInactive,
   347  							Etag:             "c925d2b5fa4cc002774c752186d8faafeac7f28a",
   348  							ProductID:        "prd_Site_Defender",
   349  							RuleFormat:       "v2020-11-02",
   350  							IncludeVersion:   4,
   351  							StagingStatus:    VersionStatusInactive,
   352  						},
   353  						{
   354  							UpdatedByUser:    "test_user",
   355  							UpdatedDate:      "2022-08-23T12:39:33Z",
   356  							ProductionStatus: VersionStatusInactive,
   357  							Etag:             "f5230dfe9d50e0a4a8b643388226b36db494d7c4",
   358  							ProductID:        "prd_Site_Defender",
   359  							RuleFormat:       "v2020-11-02",
   360  							IncludeVersion:   3,
   361  							StagingStatus:    VersionStatusInactive,
   362  						},
   363  						{
   364  							UpdatedByUser:    "test_user",
   365  							UpdatedDate:      "2022-08-22T07:17:48Z",
   366  							ProductionStatus: VersionStatusInactive,
   367  							Etag:             "1d8ed19bce0833a3fe93e62ae5d5579a38cc2dbe",
   368  							ProductID:        "prd_Site_Defender",
   369  							RuleFormat:       "v2020-11-02",
   370  							IncludeVersion:   2,
   371  							StagingStatus:    VersionStatusActive,
   372  						},
   373  						{
   374  							UpdatedByUser:    "test_user",
   375  							UpdatedDate:      "2022-08-16T10:29:43Z",
   376  							ProductionStatus: VersionStatusInactive,
   377  							Etag:             "d2be894768ae4e587eae91f93f15d2217ef517d8",
   378  							ProductID:        "prd_Site_Defender",
   379  							RuleFormat:       "v2020-11-02",
   380  							IncludeVersion:   1,
   381  							StagingStatus:    VersionStatusDeactivated,
   382  						},
   383  					},
   384  				},
   385  			},
   386  		},
   387  		"500 internal server error": {
   388  			params: ListIncludeVersionsRequest{
   389  				ContractID: "test_contract",
   390  				GroupID:    "test_group",
   391  				IncludeID:  "inc_12345",
   392  			},
   393  			expectedPath:   "/papi/v1/includes/inc_12345/versions?contractId=test_contract&groupId=test_group",
   394  			responseStatus: http.StatusInternalServerError,
   395  			responseBody: `
   396  {
   397  	"type": "internal_error",
   398      "title": "Internal Server Error",
   399      "detail": "Error getting include",
   400      "status": 500
   401  }`,
   402  			withError: &Error{
   403  				Type:       "internal_error",
   404  				Title:      "Internal Server Error",
   405  				Detail:     "Error getting include",
   406  				StatusCode: http.StatusInternalServerError,
   407  			},
   408  		},
   409  		"validation error - missing includeId": {
   410  			params: ListIncludeVersionsRequest{
   411  				ContractID: "test_contract",
   412  				GroupID:    "test_group",
   413  			},
   414  			withError: ErrStructValidation,
   415  		},
   416  		"validation error - missing contractId": {
   417  			params: ListIncludeVersionsRequest{
   418  				GroupID:   "test_group",
   419  				IncludeID: "inc_12345",
   420  			},
   421  			withError: ErrStructValidation,
   422  		},
   423  		"validation error - missing groupId": {
   424  			params: ListIncludeVersionsRequest{
   425  				ContractID: "test_contract",
   426  				IncludeID:  "inc_12345",
   427  			},
   428  			withError: ErrStructValidation,
   429  		},
   430  	}
   431  	for name, test := range tests {
   432  		t.Run(name, func(t *testing.T) {
   433  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   434  				assert.Equal(t, test.expectedPath, r.URL.String())
   435  				assert.Equal(t, http.MethodGet, r.Method)
   436  				w.WriteHeader(test.responseStatus)
   437  				_, err := w.Write([]byte(test.responseBody))
   438  				assert.NoError(t, err)
   439  			}))
   440  			client := mockAPIClient(t, mockServer)
   441  			result, err := client.ListIncludeVersions(context.Background(), test.params)
   442  			if test.withError != nil {
   443  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   444  				return
   445  			}
   446  			require.NoError(t, err)
   447  			assert.Equal(t, test.expectedResponse, result)
   448  		})
   449  	}
   450  }
   451  
   452  func TestGetIncludeVersionAvailableCriteria(t *testing.T) {
   453  	tests := map[string]struct {
   454  		params           ListAvailableCriteriaRequest
   455  		responseStatus   int
   456  		responseBody     string
   457  		expectedPath     string
   458  		expectedResponse *AvailableCriteriaResponse
   459  		withError        error
   460  	}{
   461  		"200 OK": {
   462  			params: ListAvailableCriteriaRequest{
   463  				IncludeID: "inc_12345",
   464  				Version:   2,
   465  			},
   466  			expectedPath:   "/papi/v1/includes/inc_12345/versions/2/available-criteria",
   467  			responseStatus: http.StatusOK,
   468  			responseBody: `
   469  {
   470      "contractId": "ctr_3-WNK123",
   471      "groupId": "grp_115123",
   472      "productId": "prd_Site_Defender",
   473      "ruleFormat": "v2020-11-02",
   474      "criteria": {
   475          "items": [
   476              {
   477                  "name": "bucket",
   478                  "schemaLink": "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fcriteria%2Fbucket"
   479              },
   480              {
   481                  "name": "cacheability",
   482                  "schemaLink": "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fcriteria%2Fcacheability"
   483              },
   484              {
   485                  "name": "chinaCdnRegion",
   486                  "schemaLink": "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fcriteria%2FchinaCdnRegion"
   487              }
   488          ]
   489      }
   490  }`,
   491  			expectedResponse: &AvailableCriteriaResponse{
   492  				ContractID: "ctr_3-WNK123",
   493  				GroupID:    "grp_115123",
   494  				ProductID:  "prd_Site_Defender",
   495  				RuleFormat: "v2020-11-02",
   496  				AvailableCriteria: AvailableCriteria{
   497  					Items: []Criteria{
   498  						{
   499  							Name:       "bucket",
   500  							SchemaLink: "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fcriteria%2Fbucket",
   501  						},
   502  						{
   503  							Name:       "cacheability",
   504  							SchemaLink: "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fcriteria%2Fcacheability",
   505  						},
   506  						{
   507  							Name:       "chinaCdnRegion",
   508  							SchemaLink: "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fcriteria%2FchinaCdnRegion",
   509  						},
   510  					},
   511  				},
   512  			},
   513  		},
   514  		"500 internal server error": {
   515  			params: ListAvailableCriteriaRequest{
   516  				IncludeID: "inc_12345",
   517  				Version:   2,
   518  			},
   519  			expectedPath:   "/papi/v1/includes/inc_12345/versions/2/available-criteria",
   520  			responseStatus: http.StatusInternalServerError,
   521  			responseBody: `
   522  {
   523  	"type": "internal_error",
   524      "title": "Internal Server Error",
   525      "detail": "Error getting include",
   526      "status": 500
   527  }`,
   528  			withError: &Error{
   529  				Type:       "internal_error",
   530  				Title:      "Internal Server Error",
   531  				Detail:     "Error getting include",
   532  				StatusCode: http.StatusInternalServerError,
   533  			},
   534  		},
   535  		"validation error - missing includeId": {
   536  			params: ListAvailableCriteriaRequest{
   537  				Version: 2,
   538  			},
   539  			withError: ErrStructValidation,
   540  		},
   541  		"validation error - missing version": {
   542  			params: ListAvailableCriteriaRequest{
   543  				IncludeID: "inc_12345",
   544  			},
   545  			withError: ErrStructValidation,
   546  		},
   547  	}
   548  	for name, test := range tests {
   549  		t.Run(name, func(t *testing.T) {
   550  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   551  				assert.Equal(t, test.expectedPath, r.URL.String())
   552  				assert.Equal(t, http.MethodGet, r.Method)
   553  				w.WriteHeader(test.responseStatus)
   554  				_, err := w.Write([]byte(test.responseBody))
   555  				assert.NoError(t, err)
   556  			}))
   557  			client := mockAPIClient(t, mockServer)
   558  			result, err := client.ListIncludeVersionAvailableCriteria(context.Background(), test.params)
   559  			if test.withError != nil {
   560  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   561  				return
   562  			}
   563  			require.NoError(t, err)
   564  			assert.Equal(t, test.expectedResponse, result)
   565  		})
   566  	}
   567  }
   568  
   569  func TestListIncludeVersionAvailableBehaviors(t *testing.T) {
   570  	tests := map[string]struct {
   571  		params           ListAvailableBehaviorsRequest
   572  		responseStatus   int
   573  		responseBody     string
   574  		expectedPath     string
   575  		expectedResponse *AvailableBehaviorsResponse
   576  		withError        error
   577  	}{
   578  		"200 OK": {
   579  			params: ListAvailableBehaviorsRequest{
   580  				IncludeID: "inc_12345",
   581  				Version:   2,
   582  			},
   583  			expectedPath:   "/papi/v1/includes/inc_12345/versions/2/available-behaviors",
   584  			responseStatus: http.StatusOK,
   585  			responseBody: `
   586  {
   587      "contractId": "ctr_3-WNK123",
   588      "groupId": "grp_115123",
   589      "productId": "prd_Site_Defender",
   590      "ruleFormat": "v2020-11-02",
   591      "behaviors": {
   592          "items": [
   593              {
   594                  "name": "akamaizer",
   595                  "schemaLink": "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2Fakamaizer"
   596              },
   597              {
   598                  "name": "akamaizerTag",
   599                  "schemaLink": "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2FakamaizerTag"
   600              },
   601              {
   602                  "name": "allHttpInCacheHierarchy",
   603                  "schemaLink": "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2FallHttpInCacheHierarchy"
   604              },
   605              {
   606                  "name": "allowDelete",
   607                  "schemaLink": "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2FallowDelete"
   608              }
   609          ]
   610      }
   611  }`,
   612  			expectedResponse: &AvailableBehaviorsResponse{
   613  				ContractID: "ctr_3-WNK123",
   614  				GroupID:    "grp_115123",
   615  				ProductID:  "prd_Site_Defender",
   616  				RuleFormat: "v2020-11-02",
   617  				AvailableBehaviors: AvailableBehaviors{
   618  					Items: []Behavior{
   619  						{
   620  							Name:       "akamaizer",
   621  							SchemaLink: "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2Fakamaizer",
   622  						},
   623  						{
   624  							Name:       "akamaizerTag",
   625  							SchemaLink: "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2FakamaizerTag",
   626  						},
   627  						{
   628  							Name:       "allHttpInCacheHierarchy",
   629  							SchemaLink: "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2FallHttpInCacheHierarchy",
   630  						},
   631  						{
   632  							Name:       "allowDelete",
   633  							SchemaLink: "/papi/v0/schemas/products/prd_Site_Defender/v2020-11-02#%2Fdefinitions%2Fcatalog%2Fbehaviors%2FallowDelete",
   634  						},
   635  					},
   636  				},
   637  			},
   638  		},
   639  		"500 internal server error": {
   640  			params: ListAvailableBehaviorsRequest{
   641  				IncludeID: "inc_12345",
   642  				Version:   2,
   643  			},
   644  			expectedPath:   "/papi/v1/includes/inc_12345/versions/2/available-behaviors",
   645  			responseStatus: http.StatusInternalServerError,
   646  			responseBody: `
   647  {
   648  	"type": "internal_error",
   649      "title": "Internal Server Error",
   650      "detail": "Error getting include",
   651      "status": 500
   652  }`,
   653  			withError: &Error{
   654  				Type:       "internal_error",
   655  				Title:      "Internal Server Error",
   656  				Detail:     "Error getting include",
   657  				StatusCode: http.StatusInternalServerError,
   658  			},
   659  		},
   660  		"validation error - missing includeId": {
   661  			params: ListAvailableBehaviorsRequest{
   662  				Version: 2,
   663  			},
   664  			withError: ErrStructValidation,
   665  		},
   666  		"validation error - missing version": {
   667  			params: ListAvailableBehaviorsRequest{
   668  				IncludeID: "inc_12345",
   669  			},
   670  			withError: ErrStructValidation,
   671  		},
   672  	}
   673  	for name, test := range tests {
   674  		t.Run(name, func(t *testing.T) {
   675  			mockServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   676  				assert.Equal(t, test.expectedPath, r.URL.String())
   677  				assert.Equal(t, http.MethodGet, r.Method)
   678  				w.WriteHeader(test.responseStatus)
   679  				_, err := w.Write([]byte(test.responseBody))
   680  				assert.NoError(t, err)
   681  			}))
   682  			client := mockAPIClient(t, mockServer)
   683  			result, err := client.ListIncludeVersionAvailableBehaviors(context.Background(), test.params)
   684  			if test.withError != nil {
   685  				assert.True(t, errors.Is(err, test.withError), "want: %s; got: %s", test.withError, err)
   686  				return
   687  			}
   688  			require.NoError(t, err)
   689  			assert.Equal(t, test.expectedResponse, result)
   690  		})
   691  	}
   692  }