tests

var ALLHTTPMethodsForWildCard = suite.IntegrationTest{
	ShortName:   "ALLHTTPMethodsForWildCard",
	Description: "Tests an API with wild card path using path prefix match and unspecified HTTP method",
	Manifests:   []string{"tests/all-http-methods-for-wildcard.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "all-http-methods-for-wildcard.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{

			{

				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{

				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/test",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/test",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/test",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/test",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/test1/test2/test3?foo=foo1&bar=bar1",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/test1/test2/test3?foo=foo1&bar=bar1",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/test1/test2/test3?foo=foo1&bar=bar1",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/test1/test2/test3?foo=foo1&bar=bar1",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/test",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/test",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/",
					Method: "PUT",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "PUT",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/",
					Method: "PUT",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "PUT",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full",
					Method: "PUT",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "PUT",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full",
					Method: "PUT",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "PUT",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/test",
					Method: "PUT",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "PUT",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/test",
					Method: "PUT",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "PUT",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/",
					Method: "PATCH",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "PATCH",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/",
					Method: "PATCH",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "PATCH",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full",
					Method: "PATCH",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "PATCH",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full",
					Method: "PATCH",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "PATCH",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/test",
					Method: "PATCH",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "PATCH",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/test",
					Method: "PATCH",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "PATCH",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/",
					Method: "DELETE",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "DELETE",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/",
					Method: "DELETE",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/",
						Method: "DELETE",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full",
					Method: "DELETE",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "DELETE",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full",
					Method: "DELETE",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "DELETE",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v1.0.0/v2/echo-full/test",
					Method: "DELETE",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "DELETE",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "all-http-methods-for-wildcard.test.gw.wso2.com",
					Path:   "/all-http-methods-for-wildcard/v2/echo-full/test",
					Method: "DELETE",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full/test",
						Method: "DELETE",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIDifferentListener = suite.IntegrationTest{
	ShortName:   "APIDifferentListener",
	Description: "An API is deployed to a different listener other than default gateway listener",
	Manifests:   []string{"tests/api-different-listener.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "api.am.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "api.am.wso2.com",
					Path: "/test-api-with-different-listener/v1.0.0/user/user123/playlist/watch-later",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/user/user123/playlist/watch-later",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "api.am.wso2.com",
					Path: "/test-api-with-different-listener/v1.0.0/user/user123/other-path",
				},
				Response: http.Response{StatusCode: 404},
			},
		}

		negativeTestCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/test-api-with-different-listener/v1.0.0/user/user123/playlist/watch-later",
				},
				Response:  http.Response{StatusCode: 404},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
		for i := range negativeTestCases {
			tc := negativeTestCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIDifferentPortListener = suite.IntegrationTest{
	ShortName:   "APIDifferentPortListener",
	Description: "An API is deployed to a different listener other than default gateway listener",
	Manifests:   []string{"tests/multiple_port_listener.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "api.am.wso2.com:9080"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "api.am.wso2.com",
					Path: "/test-api-with-multiple-port-listener/v1.0.0/user/user123/playlist/watch-later",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/user/user123/playlist/watch-later",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "api.am.wso2.com",
					Path: "/test-api-with-multiple-port-listener-1/v1.0.0/user/user123/playlist/watch-later",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/user/user123/playlist/watch-later",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeHTTPRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APILevelInterceptors = suite.IntegrationTest{
	ShortName:   "APILevelInterceptors",
	Description: "Tests API with with request and response interceptors",
	Manifests:   []string{"tests/interceptors-api-level.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		gwAddr := "interceptor-api.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "interceptor-api.test.gw.wso2.com",
					Path: "/interceptor/2.0.0/books",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "POST",
					Body:   `{"name":"The Prisoner"}`,
				},
				Response: http.Response{StatusCode: 201},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APILevelJWT = suite.IntegrationTest{
	ShortName:   "APILevelJWT",
	Description: "Tests API level jwt security",
	Manifests:   []string{"tests/jwt-api-level-security.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		gwAddr := "api-level-jwt.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)
		ns := "gateway-integration-test-infra"

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "api-level-jwt.test.gw.wso2.com",
					Path: "/api-level-jwt/v1.0.0/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
						"internal-key": token,
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host: "api-level-jwt.test.gw.wso2.com",
					Path: "/api-level-jwt/v1.0.0/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
			{
				Request: http.Request{
					Host: "api-level-jwt.test.gw.wso2.com",
					Path: "/api-level-jwt/v1.0.0/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
						"internal-key": "invalid",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIWithBackendBasePath = suite.IntegrationTest{
	ShortName:   "APIWithBackendBasePath",
	Description: "An API with a backend base path should be able to route requests to the backend",
	Manifests:   []string{"tests/api-with-backend-base-path.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "backend-base-path.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/test-api-with-backend-base-path/1.0.0/orders",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/backend-base-path/orders",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/test-api-with-backend-base-path/1.0.0/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/backend-base-path/users",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/test-api-with-backend-base-path/orders",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/backend-base-path/orders",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/test-api-with-backend-base-path/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/backend-base-path/users",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIWithCORSPolicy = suite.IntegrationTest{
	ShortName:   "APIWithCORSPolicy",
	Description: "Tests API with CORS policy",
	Manifests:   []string{"tests/api-with-cors-policy.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {

		gwAddr := "cors-policy.test.gw.wso2.com:9095"

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "cors-policy.test.gw.wso2.com",
					Path: "/cors-policy-api/1.0.0/test",
					Headers: map[string]string{
						"origin":                        "apk.wso2.com",
						"access-control-request-method": "GET",
					},
					Method: "OPTIONS",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Host:   "",
						Method: "OPTIONS",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"access-control-allow-origin":      "apk.wso2.com",
						"access-control-allow-credentials": "true",
						"access-control-allow-methods":     "GET, POST",
						"access-control-allow-headers":     "authorization",
						"access-control-expose-headers":    "*",
					},
					StatusCode: 200,
				},
			},
			{
				Request: http.Request{
					Host: "cors-policy.test.gw.wso2.com",
					Path: "/cors-policy-api/1.0.0/test",
					Headers: map[string]string{
						"origin":                        "apk.wso2.org",
						"access-control-request-method": "GET",
					},
					Method: "OPTIONS",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Host:   "",
						Method: "OPTIONS",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"allow": "OPTIONS, GET",
					},
					StatusCode: 204,
				},
			},
			{
				Request: http.Request{
					Host: "cors-policy.test.gw.wso2.com",
					Path: "/no-cors-policy-api/1.0.0/test",
					Headers: map[string]string{
						"origin":                        "apk.wso2.com",
						"access-control-request-method": "GET",
					},
					Method: "OPTIONS",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Host:   "",
						Method: "OPTIONS",
					},
				},
				Response: http.Response{
					StatusCode: 404,
				},
			},

			{
				Request: http.Request{
					Host: "cors-policy.test.gw.wso2.com",
					Path: "/cors-policy-api/test",
					Headers: map[string]string{
						"origin":                        "apk.wso2.com",
						"access-control-request-method": "GET",
					},
					Method: "OPTIONS",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Host:   "",
						Method: "OPTIONS",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"access-control-allow-origin":      "apk.wso2.com",
						"access-control-allow-credentials": "true",
						"access-control-allow-methods":     "GET, POST",
						"access-control-allow-headers":     "authorization",
						"access-control-expose-headers":    "*",
					},
					StatusCode: 200,
				},
			},
			{
				Request: http.Request{
					Host: "cors-policy.test.gw.wso2.com",
					Path: "/cors-policy-api/test",
					Headers: map[string]string{
						"origin":                        "apk.wso2.org",
						"access-control-request-method": "GET",
					},
					Method: "OPTIONS",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Host:   "",
						Method: "OPTIONS",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"allow": "OPTIONS, GET",
					},
					StatusCode: 204,
				},
			},
			{
				Request: http.Request{
					Host: "cors-policy.test.gw.wso2.com",
					Path: "/no-cors-policy-api/test",
					Headers: map[string]string{
						"origin":                        "apk.wso2.com",
						"access-control-request-method": "GET",
					},
					Method: "OPTIONS",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Host:   "",
						Method: "OPTIONS",
					},
				},
				Response: http.Response{
					StatusCode: 404,
				},
			},
		}
		for i := range testCases {
			tc := testCases[i]

			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIWithOperationalPolicy = suite.IntegrationTest{
	ShortName:   "APIWithOperationalPolicy",
	Description: "An API with operatinal policy",
	Manifests:   []string{"tests/api-with-operational-policy.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "backend-base-path.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "backend-base-path.test.gw.wso2.com",
					Path:   "/test-api-with-operatinal-policy/1.0.0/test-get-path",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/test-get-path",
						Method: "GET",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			}, {
				Request: http.Request{
					Host:   "backend-base-path.test.gw.wso2.com",
					Path:   "/test-api-with-operatinal-policy/1.0.0/test-post-path",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/test-post-path",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host:   "backend-base-path.test.gw.wso2.com",
					Path:   "/test-api-with-operatinal-policy/test-get-path",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/test-get-path",
						Method: "GET",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			}, {
				Request: http.Request{
					Host:   "backend-base-path.test.gw.wso2.com",
					Path:   "/test-api-with-operatinal-policy/test-post-path",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/test-post-path",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIWithPathParams = suite.IntegrationTest{
	ShortName:   "APIWithPathParams",
	Description: "An API with path param request is tested using regex path match",
	Manifests:   []string{"tests/api-with-path-params.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "path-param-api.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "path-param-api.test.gw.wso2.com",
					Path: "/test-api-with-path-params/v1.0.0/user/user123/playlist/watch-later",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/user/user123/playlist/watch-later",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "path-param-api.test.gw.wso2.com",
					Path: "/test-api-with-path-params/v1.0.0/user/user123/other-path",
				},
				Response: http.Response{StatusCode: 404},
			},
			{
				Request: http.Request{
					Host: "path-param-api.test.gw.wso2.com",
					Path: "/test-api-with-path-params/user/user123/playlist/watch-later",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/user/user123/playlist/watch-later",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "path-param-api.test.gw.wso2.com",
					Path: "/test-api-with-path-params/user/user123/other-path",
				},
				Response: http.Response{StatusCode: 404},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIWithRequestHeaderModify = suite.IntegrationTest{
	ShortName:   "APIWithRequestHeaderModify",
	Description: "An API with request header modify",
	Manifests:   []string{"tests/api-with-request-header-modify.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "backend-base-path.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/request-header-modify/1.0.0/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/users",
					},
					AbsentHeaders: []string{"X-Header-Remove"},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/request-header-modify/1.0.0/orders",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:    "/orders",
						Headers: map[string]string{"test-header": "test"},
					},
					AbsentHeaders: []string{"X-Header-add"},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/request-header-modify/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/users",
					},
					AbsentHeaders: []string{"X-Header-Remove"},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "backend-base-path.test.gw.wso2.com",
					Path: "/request-header-modify/orders",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:    "/orders",
						Headers: map[string]string{"test-header": "test"},
					},
					AbsentHeaders: []string{"X-Header-add"},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIWithResoponseHeaderModify = suite.IntegrationTest{
	ShortName:   "APIWithResoponseHeaderModify",
	Description: "An API with response header modify",
	Manifests:   []string{"tests/api-with-response-header-modify.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "gateway-integration-test-infra.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/1.0.0/set",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/set",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Set":      "set-overwrites-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/1.0.0/set",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
					"X-Header-Set":      "some-other-value",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/set",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Set":      "set-overwrites-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/1.0.0/add",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/add",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Add":      "add-appends-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/1.0.0/add",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
					"X-Header-Add":      "some-other-value",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/add",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Add":      "add-appends-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			}, {
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/1.0.0/remove",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/remove",
					},
				},
				BackendSetResponseHeaders: map[string]string{
					"X-Header-Remove": "val",
				},
				Response: http.Response{
					AbsentHeaders: []string{"X-Header-Remove"},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/set",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/set",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Set":      "set-overwrites-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/set",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
					"X-Header-Set":      "some-other-value",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/set",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Set":      "set-overwrites-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/add",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/add",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Add":      "add-appends-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/add",
				},
				BackendSetResponseHeaders: map[string]string{
					"Some-Other-Header": "val",
					"X-Header-Add":      "some-other-value",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/add",
					},
				},
				Response: http.Response{
					Headers: map[string]string{
						"Some-Other-Header": "val",
						"X-Header-Add":      "add-appends-values",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "gateway-integration-test-infra.test.gw.wso2.com",
					Path: "/response-header-modify/remove",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/remove",
					},
				},
				BackendSetResponseHeaders: map[string]string{
					"X-Header-Remove": "val",
				},
				Response: http.Response{
					AbsentHeaders: []string{"X-Header-Remove"},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var APIWithoutBackendBasePath = suite.IntegrationTest{
	ShortName:   "APIWithoutBackendBasePath",
	Description: "An API without a backend base path",
	Manifests:   []string{"tests/api-without-backend-base-path.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "no-base-path.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "no-base-path.test.gw.wso2.com",
					Path: "/no-basepath/v1",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "no-base-path.test.gw.wso2.com",
					Path: "/no-basepath/v1/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "no-base-path.test.gw.wso2.com",
					Path: "/no-basepath/v1/pet/findByTags",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/pet/findByTags",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var BackendJWTGenerationPolicy = suite.IntegrationTest{
	ShortName:   "BackendJWTGenerationPolicy",
	Description: "Tests API with backend JWT generation policy",
	Manifests:   []string{"tests/api-policy-with-jwt-generator.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "api-policy-with-jwt-generator.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		yamlFile, err := ioutil.ReadFile(filepath.Clean(filePathToResource))

		if err != nil {
			t.Error(err)
		}
		err = yaml.Unmarshal(yamlFile, &apiPolicy)
		if err != nil {
			t.Error(err)
		}

		if apiPolicy.Spec.Default != nil && apiPolicy.Spec.Default.BackendJWTToken != nil {
			isBackendJWTEnabled = apiPolicy.Spec.Default.BackendJWTToken.Enabled
		}

		if apiPolicy.Spec.Override != nil && apiPolicy.Spec.Override.BackendJWTToken != nil {
			isBackendJWTEnabled = apiPolicy.Spec.Override.BackendJWTToken.Enabled
		}

		var headers map[string]string = nil
		if isBackendJWTEnabled {
			headers = map[string]string{"X-JWT-Assertion": ""}
		}

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "api-policy-with-jwt-generator.test.gw.wso2.com",
					Path: "/api-policy-with-jwt-generator/v1.0.0/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:    "/v2/echo-full",
						Headers: headers,
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "api-policy-with-jwt-generator.test.gw.wso2.com",
					Path: "/api-policy-with-jwt-generator/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:    "/v2/echo-full",
						Headers: headers,
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var CustomAuthHeader = suite.IntegrationTest{
	ShortName:   "CustomAuthHeaderTest",
	Description: "Tests custome auth header requests",
	Manifests:   []string{"tests/custom-auth-header.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "custom-auth-header.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "custom-auth-header.test.gw.wso2.com",
					Path:   "/custom-auth-header/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
			{
				Request: http.Request{
					Host:   "custom-auth-header.test.gw.wso2.com",
					Path:   "/custom-auth-header/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
			{
				Request: http.Request{
					Host:   "custom-auth-header.test.gw.wso2.com",
					Path:   "/custom-auth-header/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "custom-auth-header.test.gw.wso2.com",
					Path:   "/custom-auth-header/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "custom-auth-header.test.gw.wso2.com",
					Path:   "/custom-auth-header/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "custom-auth-header.test.gw.wso2.com",
					Path:   "/custom-auth-header/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			if i == 2 || i == 3 {
				tc.Request.Headers = http.AddCustomBearerTokenHeader("testAuth", token, tc.Request.Headers)
			} else if i == 4 || i == 5 {
				tc.Request.Headers = http.AddInternalTokenHeader("testJwt", token, tc.Request.Headers)
			} else {
				tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			}
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var CustomRateLimitPolicies = suite.IntegrationTest{
	ShortName:   "CustomRateLimitPolicies",
	Description: "Tests API with with custom rate limit policies",
	Manifests:   []string{"tests/custom-policy-ratelimiting.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"

		gwAddr := "prod.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "prod.gw.wso2.com",
					Path: "/http-bin-api-basic/1.0.8/get",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/get",
					},
				},
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "prod.gw.wso2.com",
					Path: "/http-bin-api-basic/1.0.8/get",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/get",
					},
				},
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "prod.gw.wso2.com",
					Path: "/http-bin-api-basic/1.0.8/get",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/get",
					},
				},
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "prod.gw.wso2.com",
					Path: "/http-bin-api-basic/1.0.8/get",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/get",
					},
				},
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "prod.gw.wso2.com",
					Path: "/http-bin-api-basic/1.0.8/get",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/get",
					},
				},
				Namespace: ns,
				Response:  http.Response{StatusCode: 429},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DefaultAPIVersion = suite.IntegrationTest{
	ShortName:   "DefaultAPIVersionTest",
	Description: "Tests an API with default version",
	Manifests:   []string{"tests/default-api-version.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "default-api-version.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "default-api-version.test.gw.wso2.com",
					Path:   "/default-api-version/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "default-api-version.test.gw.wso2.com",
					Path:   "/default-api-version/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DefaultAPIVersionRatelimit = suite.IntegrationTest{
	ShortName:   "DefaultAPIVersionRatelimitTest",
	Description: "Tests an API with default version",
	Manifests:   []string{"tests/default-api-version-ratelimit.yaml"},
	Test: func(t *testing.T, testSuite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "default-api-version-ratelimit.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit/v1.0.0/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit/v1.0.0/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 429},
				UnacceptableStatuses: []int{200},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 429},
				UnacceptableStatuses: []int{200},
			},
		}
		suite.WaitForNextMinute(t)
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, testSuite.RoundTripper, testSuite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DefaultAPIVersionRatelimitResourceLevel = suite.IntegrationTest{
	ShortName:   "DefaultAPIVersionRatelimitResourceLevelTest",
	Description: "Tests an API with default version",
	Manifests:   []string{"tests/default-api-version-ratelimit-resource-level.yaml"},
	Test: func(t *testing.T, testSuite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "default-api-version-ratelimit-resource-level.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit-resource-level.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit-resource-level/v2/echo",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit-resource-level.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit-resource-level/v1.0.0/v2/echo",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit-resource-level.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit-resource-level/v1.0.0/v2/echo",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 429},
				UnacceptableStatuses: []int{200},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit-resource-level.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit-resource-level/v2/echo",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 429},
				UnacceptableStatuses: []int{200},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit-resource-level.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit-resource-level/v1.0.0/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
			{
				Request: http.Request{
					Host:   "default-api-version-ratelimit-resource-level.test.gw.wso2.com",
					Path:   "/default-api-version-ratelimit-resource-level/v2/echo-full",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
		}
		suite.WaitForNextMinute(t)
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, testSuite.RoundTripper, testSuite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DifferentAPIWithSameRoute = suite.IntegrationTest{
	ShortName:   "DifferentAPIWithSameRouteTest",
	Description: "Tests httproute that points to different endpoints with same route but different HTTP method",
	Manifests:   []string{"tests/different-endpoint-with-same-route.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "different-endpoint-with-same-route.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "different-endpoint-with-same-route.test.gw.wso2.com",
					Path:   "/different-endpoint-with-same-route/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "different-endpoint-with-same-route.test.gw.wso2.com",
					Path:   "/different-endpoint-with-same-route/v2/echo-full",
					Method: "POST",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path:   "/v2/echo-full",
						Method: "POST",
					},
				},
				Backend:   "infra-backend-v2",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableAPILevelJWT = suite.IntegrationTest{
	ShortName:   "DisableAPILevelJWTTest",
	Description: "Tests disabled JWT in API level",
	Manifests:   []string{"tests/disable-api-level-jwt.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-api-level-jwt.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "disable-api-level-jwt.test.gw.wso2.com",
					Path:   "/disable-api-level-jwt/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
			{
				Request: http.Request{
					Host:   "disable-api-level-jwt.test.gw.wso2.com",
					Path:   "/disable-api-level-jwt/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableAPILevelJWTTestWithFalseValue = suite.IntegrationTest{
	ShortName:   "DisableAPILevelJWTTestWithFalseValue",
	Description: "Tests enabled JWT in API level",
	Manifests:   []string{"tests/disable-api-level-jwt.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-api-level-jwt1.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "disable-api-level-jwt1.test.gw.wso2.com",
					Path:   "/disable-api-level-jwt1/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "disable-api-level-jwt1.test.gw.wso2.com",
					Path:   "/disable-api-level-jwt1/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableAPILevelJWTTestWithNoOtherAuth = suite.IntegrationTest{
	ShortName:   "DisableAPILevelJWTTestWithNoOtherAuthTest",
	Description: "Tests enabled JWT in API level with no other auth",
	Manifests:   []string{"tests/disable-api-level-jwt.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-api-level-jwt2.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "disable-api-level-jwt2.test.gw.wso2.com",
					Path:   "/disable-api-level-jwt2/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "disable-api-level-jwt2.test.gw.wso2.com",
					Path:   "/disable-api-level-jwt2/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableAPISecurity = suite.IntegrationTest{
	ShortName:   "DisableAPISecurity",
	Description: "Tests API with disabled security",
	Manifests:   []string{"tests/disable-api-level-security.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-api-security.test.gw.wso2.com:9095"

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "disable-api-security.test.gw.wso2.com",
					Path: "/disable-api-security/v1/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/users",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "disable-api-security.test.gw.wso2.com",
					Path: "/disable-api-security/v1/orders",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/orders",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "disable-api-security.test.gw.wso2.com",
					Path: "/disable-api-security/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/users",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "disable-api-security.test.gw.wso2.com",
					Path: "/disable-api-security/orders",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/orders",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		for i := range testCases {
			tc := testCases[i]

			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableResourceLevelJWT = suite.IntegrationTest{
	ShortName:   "DisableResourceLevelJWTTest",
	Description: "Tests disabled JWT in resource level",
	Manifests:   []string{"tests/disable-resource-level-jwt.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-resource-level-jwt.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "disable-resource-level-jwt.test.gw.wso2.com",
					Path:   "/disable-resource-level-jwt/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
			{
				Request: http.Request{
					Host:   "disable-resource-level-jwt.test.gw.wso2.com",
					Path:   "/disable-resource-level-jwt/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableResourceLevelJWTWithFalseValueTest = suite.IntegrationTest{
	ShortName:   "DisableResourceLevelJWTWithFalseValueTest",
	Description: "Tests enabled JWT in API level",
	Manifests:   []string{"tests/disable-resource-level-jwt.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-resource-level-jwt1.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "disable-resource-level-jwt1.test.gw.wso2.com",
					Path:   "/disable-resource-level-jwt1/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "disable-resource-level-jwt1.test.gw.wso2.com",
					Path:   "/disable-resource-level-jwt1/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableResourceLevelJWTWithNoOtherAuth = suite.IntegrationTest{
	ShortName:   "DisableResourceLevelJWTWithNoOtherAuthTest",
	Description: "Tests enabled JWT in API level with no other auth",
	Manifests:   []string{"tests/disable-resource-level-jwt.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-resource-level-jwt2.test.gw.wso2.com:9095"

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "disable-resource-level-jwt2.test.gw.wso2.com",
					Path:   "/disable-resource-level-jwt2/v1.0.0/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "disable-resource-level-jwt2.test.gw.wso2.com",
					Path:   "/disable-resource-level-jwt2/v2/echo-full/",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var DisableResourceSecurity = suite.IntegrationTest{
	ShortName:   "DisableResourceSecurity",
	Description: "Tests API with disabled security",
	Manifests:   []string{"tests/disable-resource-level-security.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "disable-resource-security.test.gw.wso2.com:9095"

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "disable-resource-security.test.gw.wso2.com",
					Path: "/disable-resource-security/v1/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/users",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "disable-resource-security.test.gw.wso2.com",
					Path: "/disable-resource-security/v1/orders",
				},
				Response: http.Response{StatusCode: 401},
			},
			{
				Request: http.Request{
					Host: "disable-resource-security.test.gw.wso2.com",
					Path: "/disable-resource-security/users",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/users",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "disable-resource-security.test.gw.wso2.com",
					Path: "/disable-resource-security/orders",
				},
				Response: http.Response{StatusCode: 401},
			},
		}
		for i := range testCases {
			tc := testCases[i]

			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var FetchAPIDefinition = suite.IntegrationTest{
	ShortName:   "FetchAPIDefinition",
	Description: "Tests an API definition fetch using path prefix match and unspecified HTTP method",
	Manifests:   []string{"tests/fetch-api-definition.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "fetch-api-definition.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "fetch-api-definition.test.gw.wso2.com",
					Path: "/fetch-api-definition/v1.0.0/api-definition",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				Response: http.Response{
					StatusCode: 200,
				},
				Backend:      "infra-backend-v1",
				Namespace:    ns,
				TestCaseName: "FetchAPIDefinition",
			},
			{
				Request: http.Request{
					Host: "fetch-api-definition.test.gw.wso2.com",
					Path: "/fetch-api-definition/api-definition",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				Response: http.Response{
					StatusCode: 200,
				},
				Backend:      "infra-backend-v1",
				Namespace:    ns,
				TestCaseName: "FetchAPIDefinition",
			},
		}

		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var FetchNonExistingAPIDefinition = suite.IntegrationTest{
	ShortName:   "FetchNonExistingAPIDefinition",
	Description: "Tests an invocation on non existing api definition from the api definition route",
	Manifests:   []string{"tests/fetch-non-existing-api-definition.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "fetch-non-existing-api-definition.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "fetch-non-existing-api-definition.gw.wso2.com",
					Path: "/fetch-non-existing-api-definition/v1.0.0/api-definition",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				Response: http.Response{
					StatusCode: 404,
				},
				Backend:      "infra-backend-v1",
				Namespace:    ns,
				TestCaseName: "FetchAPIDefinition",
			},
		}

		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var GQLAPI = suite.IntegrationTest{
	ShortName:   "GQLAPI",
	Description: "Tests GraphQL API",
	Manifests:   []string{"tests/gql-api.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		gwAddr := "gql.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "gql.test.gw.wso2.com",
					Path:   "/gql/v1",
					Method: "POST",
					Headers: map[string]string{
						"Content-Type": "application/json",
					},
					Body: `{"query":"query{\n    human(id:1000){\n        id\n        name\n    }\n}","variables":{}}`,
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Method: ""},
				},
				Response: http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host:   "gql.test.gw.wso2.com",
					Path:   "/gql/v1",
					Method: "POST",
					Headers: map[string]string{
						"Content-Type": "application/json",
					},
					Body: `{"query":"query{\n    human(id:1000){\n        id\n        name\n    }\n    droid(id:2000){\n        name\n        friends{\n            name\n            appearsIn\n        }\n    }\n}","variables":{}}`,
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Method: "",
					},
				},
				Response: http.Response{StatusCode: 401},
			}, {
				Request: http.Request{
					Host:   "gql.test.gw.wso2.com",
					Path:   "/gql/v1",
					Method: "POST",
					Headers: map[string]string{
						"Content-Type":  "application/json",
						"Authorization": "Bearer " + token,
					},
					Body: `{"query":"query{\n    human(id:1000){\n        id\n        name\n    }\n    droid(id:2000){\n        name\n        friends{\n            name\n            appearsIn\n        }\n    }\n}","variables":{}}`,
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Method: "",
					},
				},
				Response: http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var GatewayClassObservedGenerationBump = suite.IntegrationTest{
	ShortName:   "GatewayClassObservedGenerationBump",
	Description: "A GatewayClass should update the observedGeneration in all of it's Status.Conditions after an update to the spec",
	Manifests:   []string{"tests/gatewayclass-observed-generation-bump.yaml"},
	Test: func(t *testing.T, s *suite.IntegrationTestSuite) {
		gwc := types.NamespacedName{Name: "gatewayclass-observed-generation-bump"}

		t.Run("observedGeneration should increment", func(t *testing.T) {
			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
			defer cancel()

			kubernetes.GWCMustHaveAcceptedConditionAny(t, s.Client, s.TimeoutConfig, gwc.Name)

			original := &v1beta1.GatewayClass{}
			err := s.Client.Get(ctx, gwc, original)
			require.NoErrorf(t, err, "error getting GatewayClass: %v", err)

			kubernetes.GatewayClassMustHaveLatestConditions(t, original)

			mutate := original.DeepCopy()
			desc := "new"
			mutate.Spec.Description = &desc

			err = s.Client.Patch(ctx, mutate, client.MergeFrom(original))
			require.NoErrorf(t, err, "error patching the GatewayClass: %v", err)

			kubernetes.GWCMustHaveAcceptedConditionAny(t, s.Client, s.TimeoutConfig, gwc.Name)

			updated := &v1beta1.GatewayClass{}
			err = s.Client.Get(ctx, gwc, updated)
			require.NoErrorf(t, err, "error getting GatewayClass: %v", err)

			kubernetes.GatewayClassMustHaveLatestConditions(t, updated)

			require.NotEqual(t, original.Generation, updated.Generation, "generation should change after an update")
		})
	},
}

var IntegrationTests []suite.IntegrationTest

var ProdAndSandAPIs = suite.IntegrationTest{
	ShortName:   "ProdAndSandAPIs",
	Description: "Tests API with disabled security",
	Manifests:   []string{"tests/prod-and-sand-apis.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr1 := "prod-api.test.gw.wso2.com:9095"
		gwAddr2 := "sand-api.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases1 := []http.ExpectedResponse{

			{
				Request: http.Request{
					Host: "prod-api.test.gw.wso2.com",
					Path: "/prod-sand-test-api/v1",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}
		testCases2 := []http.ExpectedResponse{

			{
				Request: http.Request{
					Host: "sand-api.test.gw.wso2.com",
					Path: "/prod-sand-test-api/v1",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/",
					},
				},
				Backend:   "infra-backend-v2",
				Namespace: ns,
			},
		}

		for i := range testCases1 {
			tc := testCases1[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr1, tc)
			})
		}
		for i := range testCases2 {
			tc := testCases2[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr2, tc)
			})
		}
	},
}

var RatelimitPriority = suite.IntegrationTest{
	ShortName:   "RatelimitPriorityTest",
	Description: "Tests ratelimit priority between API level and resource level",
	Manifests:   []string{"tests/ratelimit-priority.yaml"},
	Test: func(t *testing.T, testSuite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "ratelimit-priority.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host:   "ratelimit-priority.test.gw.wso2.com",
					Path:   "/ratelimit-priority/v2/echo",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
			{
				Request: http.Request{
					Host:   "ratelimit-priority.test.gw.wso2.com",
					Path:   "/ratelimit-priority/v1.0.0/v2/echo",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 200},
				UnacceptableStatuses: []int{429},
			},
			{
				Request: http.Request{
					Host:   "ratelimit-priority.test.gw.wso2.com",
					Path:   "/ratelimit-priority/v1.0.0/v2/echo",
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo",
					},
				},
				Backend:              "infra-backend-v1",
				Namespace:            ns,
				Response:             http.Response{StatusCode: 429},
				UnacceptableStatuses: []int{200},
			},
		}
		suite.WaitForNextMinute(t)
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, testSuite.RoundTripper, testSuite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var ResourceLevelInterceptors = suite.IntegrationTest{
	ShortName:   "ResourceLevelInterceptors",
	Description: "Tests API with with request and response interceptors",
	Manifests:   []string{"tests/interceptors-resource-level.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		gwAddr := "interceptor-resource.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "interceptor-resource.test.gw.wso2.com",
					Path: "/interceptor/1.0.0/books/with-interceptors",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "POST",
					Body:   `{"name":"The Prisoner"}`,
				},
				Response: http.Response{StatusCode: 201},
			},
			{
				Request: http.Request{
					Host: "interceptor-resource.test.gw.wso2.com",
					Path: "/interceptor/1.0.0/books/without-interceptors",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "POST",
					Body:   `{"name":"The Prisoner"}`,
				},
				Response: http.Response{StatusCode: 401},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var ResourceLevelJWT = suite.IntegrationTest{
	ShortName:   "ResourceLevelJWT",
	Description: "Tests resource level jwt security",
	Manifests:   []string{"tests/jwt-resource-level-security.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		gwAddr := "resource-level-jwt.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)
		ns := "gateway-integration-test-infra"
		testCases := []http.ExpectedResponse{
			{
				Request: http.Request{
					Host: "resource-level-jwt.test.gw.wso2.com",
					Path: "/resource-level-jwt/v1.0.0/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
						"internal-key": token,
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
			{
				Request: http.Request{
					Host: "resource-level-jwt.test.gw.wso2.com",
					Path: "/resource-level-jwt/v1.0.0/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},
			{
				Request: http.Request{
					Host: "resource-level-jwt.test.gw.wso2.com",
					Path: "/resource-level-jwt/v1.0.0/v2/echo-full",
					Headers: map[string]string{
						"content-type": "application/json",
						"internal-key": "invalid",
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},

			{
				Request: http.Request{
					Host: "resource-level-jwt.test.gw.wso2.com",
					Path: "/resource-level-jwt/v1.0.0/v2/echo-1",
					Headers: map[string]string{
						"content-type": "application/json",
						"internal-key": token,
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-1",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 401},
			},

			{
				Request: http.Request{
					Host: "resource-level-jwt.test.gw.wso2.com",
					Path: "/resource-level-jwt/v1.0.0/v2/echo-2",
					Headers: map[string]string{
						"content-type": "application/json",
						"internal-key": token,
					},
					Method: "GET",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-2",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
				Response:  http.Response{StatusCode: 200},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var ResourceScopes = suite.IntegrationTest{
	ShortName:   "ResourceScopes",
	Description: "Tests resource with scopes",
	Manifests:   []string{"tests/resource-scopes.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "resource-scopes.test.gw.wso2.com:9095"

		tokenWithoutScopes := http.GetTestToken(t)
		tokenWithMatchingScopes := http.GetTestToken(t, "read:pets", "write:pets")
		tokenWithNotMatchingScopes := http.GetTestToken(t, "no:pets")
		testTokens := []string{
			tokenWithoutScopes,
			tokenWithMatchingScopes,
			tokenWithNotMatchingScopes,
			tokenWithoutScopes,
		}

		testCases := []http.ExpectedResponse{

			{
				Request: http.Request{
					Host: "resource-scopes.test.gw.wso2.com",
					Path: "/resource-scopes/v1/pet/123",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/pet/123",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "resource-scopes.test.gw.wso2.com",
					Path: "/resource-scopes/v1/pets/findByTags",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/pets/findByTags",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "resource-scopes.test.gw.wso2.com",
					Path: "/resource-scopes/v1/pets/findByTags",
				},
				Response: http.Response{StatusCode: 403},
			},

			{
				Request: http.Request{
					Host: "resource-scopes.test.gw.wso2.com",
					Path: "/resource-scopes/v1/pets/findByTags",
				},
				Response: http.Response{StatusCode: 403},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(testTokens[i], tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var TrailingSlash = suite.IntegrationTest{
	ShortName:   "TrailingSlash",
	Description: "Invoking API with and without trailing slash",
	Manifests:   []string{"tests/trailing-slash.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr := "trailing-slash.test.gw.wso2.com:9095"
		token := http.GetTestToken(t, gwAddr)

		testCases := []http.ExpectedResponse{

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/no-slash/findByStatus",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/no-slash/findByStatus",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/no-slash/findByStatus/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/no-slash/findByStatus",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/no-slash/1",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/no-slash/1",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/no-slash/1/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/no-slash/1",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/no-slash/1/pet/123",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/no-slash/1/pet/123",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/no-slash/1/pet/123/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/no-slash/1/pet/123",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-slash/findByStatus",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/with-slash/findByStatus/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-slash/findByStatus/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/with-slash/findByStatus/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-slash/1",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/with-slash/1/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-slash/1/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/with-slash/1/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-slash/1/pet/123",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/with-slash/1/pet/123/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-slash/1/pet/123/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/with-slash/1/pet/123/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/chars",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/chars",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/charsAdditional",
				},
				Response: http.Response{StatusCode: 404},
			},

			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-param/1/",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/v2/echo-full/with-param/1",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
			{
				Request: http.Request{
					Host: "trailing-slash.test.gw.wso2.com",
					Path: "/trailing-slash/v1.0.0/echo-full/with-param/1/additional",
				},
				Response: http.Response{StatusCode: 404},
			},
		}
		for i := range testCases {
			tc := testCases[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, tc)
			})
		}
	},
}

var UpdateOwnerReferences = suite.IntegrationTest{
	ShortName:   "UpdateOwnerReference",
	Description: "Test owner reference functionality",
	Manifests: []string{
		"tests/owner-reference.yaml",
	},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		time.Sleep(5 * time.Second)
		namespace := "apk-integration-test"

		hr1Key := types.NamespacedName{
			Name:      "hr1",
			Namespace: namespace,
		}
		var hr1 gwapiv1b1.HTTPRoute
		if err := suite.Client.Get(context.TODO(), hr1Key, &hr1); err != nil {
			t.Fatalf("Unable to load http route with key %+v error: %+v", hr1Key, err)
		}

		if len(hr1.ObjectMeta.OwnerReferences) != 1 || hr1.ObjectMeta.OwnerReferences[0].Name != "api1" {
			t.Fatalf("Unexpected owner reference found in http route hr1:  %+v", hr1)
		}

		hr2Key := types.NamespacedName{
			Name:      "hr2",
			Namespace: namespace,
		}
		var hr2 gwapiv1b1.HTTPRoute
		if err := suite.Client.Get(context.TODO(), hr2Key, &hr2); err != nil {
			t.Fatalf("Unable to load http route with key %+v error: %+v", hr2Key, err)
		}

		if len(hr2.ObjectMeta.OwnerReferences) != 2 {
			t.Fatalf("Unexpected owner reference found in http route hr2:  %+v", hr2)
		}
		namesToCheck := []string{"api1", "api2"}
		found := false
		for _, ownerRef := range hr2.ObjectMeta.OwnerReferences {
			foundLocal := false
			for _, name := range namesToCheck {
				if ownerRef.Name == name {
					foundLocal = true
				}
			}
			found = foundLocal
		}
		if !found {
			t.Fatalf("Unexpected owner reference found in http route hr2:  %+v", hr2)
		}

		backend1Key := types.NamespacedName{
			Name:      "backend1",
			Namespace: namespace,
		}
		var backend1 dpv1alpha1.Backend
		if err := suite.Client.Get(context.TODO(), backend1Key, &backend1); err != nil {
			t.Fatalf("Unable to load backend with key %+v error: %+v", backend1Key, err)
		}

		if len(backend1.ObjectMeta.OwnerReferences) != 1 || backend1.ObjectMeta.OwnerReferences[0].Name != "api1" {
			t.Fatalf("Unexpected owner reference found in backend1:  %+v", backend1)
		}

		backend2Key := types.NamespacedName{
			Name:      "backend2",
			Namespace: namespace,
		}
		var backend2 dpv1alpha1.Backend
		if err := suite.Client.Get(context.TODO(), backend2Key, &backend2); err != nil {
			t.Fatalf("Unable to load backend with key %+v error: %+v", backend2Key, err)
		}

		if len(hr2.ObjectMeta.OwnerReferences) != 2 {
			t.Fatalf("Unexpected owner reference found in backend2:  %+v", backend2)
		}
		found = false
		for _, ownerRef := range hr2.ObjectMeta.OwnerReferences {
			foundLocal := false
			for _, name := range namesToCheck {
				if ownerRef.Name == name {
					foundLocal = true
				}
			}
			found = foundLocal
		}
		if !found {
			t.Fatalf("Unexpected owner reference found in backend2:  %+v", backend2)
		}

		rl1Key := types.NamespacedName{
			Name:      "rl1",
			Namespace: namespace,
		}
		var rl1 dpv1alpha1.RateLimitPolicy
		if err := suite.Client.Get(context.TODO(), rl1Key, &rl1); err != nil {
			t.Fatalf("Unable to load ratelimit with key %+v error: %+v", rl1Key, err)
		}

		if len(rl1.ObjectMeta.OwnerReferences) != 1 || rl1.ObjectMeta.OwnerReferences[0].Name != "api1" {
			t.Fatalf("Unexpected owner reference found in ratelimit rl1:  %+v", rl1)
		}

		api1Key := types.NamespacedName{
			Name:      "api1",
			Namespace: namespace,
		}
		var api1 dpv1alpha1.API
		if err := suite.Client.Get(context.TODO(), api1Key, &api1); err != nil {
			t.Fatalf("Unable to load api with key %+v error: %+v", api1Key, err)
		}

		api2Key := types.NamespacedName{
			Name:      "api2",
			Namespace: namespace,
		}
		var api2 dpv1alpha1.API
		if err := suite.Client.Get(context.TODO(), api2Key, &api2); err != nil {
			t.Fatalf("Unable to load api with key %+v error: %+v", api2Key, err)
		}

		if err := suite.Client.Delete(context.TODO(), &api1); err != nil {
			t.Fatalf("Unable to delete api with key %+v error: %+v", api1Key, err)
		}

		time.Sleep(5 * time.Second)

		if err := suite.Client.Get(context.TODO(), hr2Key, &hr2); err != nil {
			t.Fatalf("Unable to load http route with key %+v error: %+v", hr2Key, err)
		}

		if len(hr2.ObjectMeta.OwnerReferences) != 1 {
			t.Fatalf("Unexpected owner reference found in http route hr2:  %+v", hr2)
		}
		namesToCheck = []string{"api2"}
		found = false
		for _, ownerRef := range hr2.ObjectMeta.OwnerReferences {
			foundLocal := false
			for _, name := range namesToCheck {
				if ownerRef.Name == name {
					foundLocal = true
				}
			}
			found = foundLocal
		}
		if !found {
			t.Fatalf("Unexpected owner reference found in http route hr2:  %+v", hr2)
		}

	},
}

var VerifyOldAPIs = suite.IntegrationTest{
	ShortName:   "VerifyOldAPIs",
	Description: "Verify Old APIs with different CR versions",
	Manifests:   []string{"tests/verify-old-apis.yaml"},
	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
		ns := "gateway-integration-test-infra"
		gwAddr1 := "prod-api.test.gw.wso2.com:9095"
		token := http.GetTestToken(t)

		testCases1 := []http.ExpectedResponse{

			{
				Request: http.Request{
					Host: "prod-api.test.gw.wso2.com",
					Path: "/verify-old-apis/v1",
				},
				ExpectedRequest: &http.ExpectedRequest{
					Request: http.Request{
						Path: "/",
					},
				},
				Backend:   "infra-backend-v1",
				Namespace: ns,
			},
		}

		for i := range testCases1 {
			tc := testCases1[i]
			tc.Request.Headers = http.AddBearerTokenToHeader(token, tc.Request.Headers)
			t.Run(tc.GetTestCaseName(i), func(t *testing.T) {
				t.Parallel()
				http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr1, tc)
			})
		}

	},
}