SPINEDEM-5254 Enforce rate limit in INT

karate-tests/karate-config.js

@@ -78,6 +78,10 @@ function fn() {
       privilegedAccessSigningKey: java.lang.System.getenv('PRIVILEGED_ACCESS_SIGNING_KEY_PATH'),
       privilegedAccessApiKey: java.lang.System.getenv('PRIVILEGED_ACCESS_API_KEY'),
       keyID: java.lang.System.getenv('KEY_ID'),
+      rateLimitingAppClientID: java.lang.System.getenv('RATE_LIMITING_APP_CLIENT_ID'),
+      rateLimitingAppClientSecret: java.lang.System.getenv('RATE_LIMITING_APP_CLIENT_SECRET'),
+      proxyRateLimitingAppClientID: java.lang.System.getenv('PROXY_RATE_LIMITING_APP_CLIENT_ID'),
+      proxyRateLimitingAppClientSecret: java.lang.System.getenv('PROXY_RATE_LIMITING_APP_CLIENT_SECRET'),
       internalServerURL: `${java.lang.System.getenv('INTERNAL_SERVER_BASE_URI')}/personal-demographics/FHIR/R4`
     };
   } 

karate-tests/src/test/java/patients/TestLocalMockParallel.java

@@ -20,7 +20,7 @@ public class TestLocalMockParallel {
     void testLocalMockParallel() {
         Results results = Runner.path("classpath:patients")
             .karateEnv("local-sandbox")
-            .tags("@sandbox, @sandbox-only", "~@smoke-only")
+            .tags("@sandbox, @sandbox-only", "~@smoke-only", "~@rateLimit")
             .outputJunitXml(true)
             .parallel(5);
         assertTrue(results.getFailCount() == 0, results.getErrorMessages());

karate-tests/src/test/java/patients/TestMockParallel.java

@@ -14,7 +14,7 @@ public class TestMockParallel {
     void testMockParallel() {
         Results results = Runner.path("classpath:patients")
             .karateEnv("sandbox")
-            .tags("@sandbox, @sandbox-only", "~@smoke-only")
+            .tags("@sandbox, @sandbox-only", "~@smoke-only", "~@rateLimit")
             .outputJunitXml(true)
             .parallel(5);
         assertTrue(results.getFailCount() == 0, results.getErrorMessages());

karate-tests/src/test/java/patients/TestParallel.java

@@ -14,7 +14,7 @@ public class TestParallel {
     void testDevParallel() {
         Results results = Runner.path("classpath:patients")
                 .outputJunitXml(true)
-                .tags("~@sandbox-only", "~@smoke-only")
+                .tags("~@sandbox-only", "~@smoke-only", "~@rateLimit")
                 .karateEnv("veit07")
                 .parallel(2);
         assertTrue(results.getFailCount() == 0, results.getErrorMessages());

karate-tests/src/test/java/patients/TestSchemaParallel.java

@@ -14,7 +14,7 @@ public class TestSchemaParallel {
     void testSchemaParallel() {
         Results results = Runner.path("classpath:patients")
                 .outputJunitXml(true)
-                .tags("~@sandbox-only", "~@no-oas", "~@oas-bug", "~@smoke-only")
+                .tags("~@sandbox-only", "~@no-oas", "~@oas-bug", "~@smoke-only", "~@rateLimit")
                 .karateEnv("prism")
                 .parallel(5);
         assertTrue(results.getFailCount() == 0, results.getErrorMessages());

karate-tests/src/test/java/patients/rateLimits/README.md

@@ -0,0 +1,31 @@
+# Rate Limit testing
+
+To ensure the proxy's rate limit has been configured correctly, there is a test suite, using Gatling, that runs a scenario multiple times, across multiple threads.
+
+## Rate Limiting Apps
+
+As part of the parameters passed in to the test, the name of the requesting app is required. These must match the app's name as defined in the karate-config.js file, eg rateLimitingApp.
+
+## Single-app Testing
+
+To test rate limit configuration of a given app or proxy run
+```bash
+mvn test-compile gatling:test -Dgatling.simulationClass=patients.GetPatientRateLimitSimulation -DrequestingApp=rateLimitingApp -DnumberOfRequests=41 -Dduration=60
+```
+where
+* requestingApp - the name of the app, which ties to the environment names for its client id and secret
+* numberOfRequests - the number of request you wish to send
+* duration - the duration over which you wish to send the requests
+
+The expected rate limit varies according to the environment, access mode, requests and requesting app. See karate-config.js  and the Simulation class for the variables the tests pick up.
+
+
+## Two-app Testing
+
+Some rate limits are counted per app, others are counted across all apps. In this way, one app's request can affect another.
+
+To test rate limit configuration across two apps concurrently, run
+Run the individual test:
+```bash
+mvn test-compile gatling:test -Dgatling.simulationClass=patients.GetPatientByTwoAppsSimulation -DrateLimitAppRequests=300 -DproxyRateLimitAppRequests=20 -Dduration=60
+```

karate-tests/src/test/java/patients/rateLimits/getPatientDetails.feature

@@ -0,0 +1,19 @@
+Feature: Get a patient - Healthcare worker access mode
+ # By default, the test application uses the proxy rate limits. These rate limits vary across the internal-dev, int, and ref environments.
+ # As a precondition, the appropriate proxy must be assigned to the test application based on the specific testing requirements.
+
+Background:
+
+  * def accessToken = karate.callSingle('classpath:auth/auth-redirect.feature', { clientID: karate.get(requestingApp + 'ClientID'),clientSecret: karate.get(requestingApp + 'ClientSecret')}).accessToken
+  * def requestHeaders = call read('classpath:auth/auth-headers.js')
+  * configure headers = requestHeaders 
+  * url baseURL
+
+@rateLimit
+Scenario: Get patient details
+  * def nhsNumber = '9727022820'
+  * path 'Patient', nhsNumber
+  * method get
+  * def is429 = responseStatus == 429
+  * karate.set('is429', is429)
+  * if (is429) karate.set('timestamp429', java.time.ZonedDateTime.now(java.time.ZoneOffset.UTC).toString())

karate-tests/src/test/java/patients/rateLimits/rateLimitSimulation.scala

@@ -0,0 +1,47 @@
+package patients
+
+import com.intuit.karate.gatling.PreDef._
+import io.gatling.core.Predef._
+import scala.concurrent.duration._
+
+
+class GetPatientRateLimitSimulation extends Simulation {
+  val requestingApp = System.getProperty("requestingApp")
+
+  val numberOfRequests = Integer.getInteger("numberOfRequests")
+  val duration = Integer.getInteger("duration")  
+
+  val protocol = karateProtocol()
+  protocol.runner.karateEnv("veit07")
+
+  var requestCounter = 0
+  var all429s: Seq[Int] = Seq()
+
+  val scn = scenario("RateLimitTest")
+    .exec(session => {
+      requestCounter += 1
+      session.set("requestIndex", requestCounter)
+    })
+    .exec(karateSet("requestingApp", session => requestingApp))
+    .exec(karateFeature(s"classpath:patients/rateLimits/getPatientDetails.feature"))
+    .exec { session =>
+      if (session.contains("is429") && session("is429").as[Boolean]) {
+      all429s = all429s :+ session("requestIndex").as[Int]
+      }
+      session
+    }
+
+    setUp(
+      scn.inject(rampUsers(numberOfRequests) during (duration.seconds)).protocols(protocol)
+    )
+
+  after {
+    println("=== Simulation Complete ===")
+    println(s"Total requests from $requestingApp: $numberOfRequests")
+    if (all429s.nonEmpty) {
+      println(s"Total 429 responses: ${all429s.size}")
+    }else {
+      println("No 429 responses received")
+    }
+  }
+}

karate-tests/src/test/java/patients/rateLimits/twoAppsRateLimitsSimulation.scala

@@ -0,0 +1,91 @@
+package patients
+
+import com.intuit.karate.gatling.PreDef._
+import io.gatling.core.Predef._
+import scala.concurrent.duration._
+
+
+class GetPatientByTwoAppsSimulation extends Simulation {
+ // === Configuration ===
+  val rateLimitAppRequests = Integer.getInteger("rateLimitAppRequests")
+  val proxyRateLimit = Integer.getInteger("proxyRateLimitAppRequests")
+  val duration = Integer.getInteger("duration")
+  val protocol = karateProtocol()
+  protocol.runner.karateEnv("veit07")
+
+  // === State Tracking ===
+  var app1Counter = 0
+  var app2Counter = 0
+  var app1_429s, app2_429s = Seq[Int]()
+  var app1_429Timestamps, app2_429Timestamps = Seq[String]()
+
+  // === Helper to Handle 429 Tracking ===
+  def track429(session: Session, appLabel: String): Session = {
+    if (session.contains("is429") && session("is429").as[Boolean]) {
+      val index = session("requestIndex").as[Int]
+      val timestamp = session("timestamp429").as[String]
+      val entry = s"Request $index at $timestamp"
+
+      appLabel match {
+        case "App1" =>
+          app1_429s = app1_429s :+ index
+          app1_429Timestamps = app1_429Timestamps :+ entry
+        case "App2" =>
+          app2_429s = app2_429s :+ index
+          app2_429Timestamps = app2_429Timestamps :+ entry
+      }
+    }
+    session
+  }
+
+  // === Scenario Definitions ===
+  def scenarioForApp(appLabel: String, requestingApp: String) = {
+    scenario(s"${appLabel}Test")
+      .exec(session => {
+        val index = appLabel match {
+          case "App1" => app1Counter += 1; app1Counter
+          case "App2" => app2Counter += 1; app2Counter
+        }
+        session
+          .set("requestIndex", index)
+          .set("appName", appLabel)
+      })
+      .exec(karateSet("requestingApp", session => requestingApp))
+      // Optional: Log each request for debugging
+      .exec(session => {
+        val app = session("appName").as[String]
+        val idx = session("requestIndex").as[Int]
+        val now = java.time.Instant.now.toString
+        println(s"[DEBUG] $app - Request $idx at $now")
+        session
+      })
+      .exec(karateFeature("classpath:patients/rateLimits/getPatientDetails.feature"))
+      .exec(session => track429(session, appLabel))
+  }
+
+  val rateLimitingAppScenario = scenarioForApp("App1", "rateLimitingApp")
+  val proxyRateLimitingAppScenario = scenarioForApp("App2", "proxyRateLimitingApp")
+
+  // === Simulation Setup ===
+  setUp(
+    rateLimitingAppScenario.inject(rampUsers(rateLimitAppRequests) during (duration.seconds)).protocols(protocol).andThen(
+      proxyRateLimitingAppScenario.inject(rampUsers(proxyRateLimit) during (duration.seconds)).protocols(protocol)
+    )
+  )
+
+  // === Report Output ===
+  after {
+    println("=== Simulation Complete ===")
+    println(s"Total requests from App1Test: $rateLimitAppRequests")
+    println(s"Total requests from App2Test: $proxyRateLimit")
+
+    def print429s(appLabel: String, count: Int, timestamps: Seq[String]) = {
+      println(s"Total 429 responses from $appLabel: $count")
+      if (timestamps.nonEmpty) timestamps.foreach(println)
+      else println("No 429 responses received")
+    }
+
+    print429s("App1Test", app1_429s.size, app1_429Timestamps)
+    print429s("App2Test", app2_429s.size, app2_429Timestamps)
+  }
+}

manifest_template.yml

@@ -14,9 +14,13 @@ APIGEE_ENVIRONMENTS:
           ratelimit: 600pm # 10 requests per second
       app:
         quota:
-          enabled: false
+          enabled: true
+          limit: 300
+          interval: 1
+          timeunit: minute
         spikeArrest:
-          enabled: false
+          enabled: true
+          ratelimit: 900pm
   # TODO: Remove as we don't want this included in an actual release
   - name: internal-dev-sandbox
     display_name_suffix: Internal Development Sandbox
@@ -92,9 +96,13 @@ APIGEE_ENVIRONMENTS:
           ratelimit: 2400pm # 40 requests per second
       app:
         quota:
-          enabled: false
+          enabled: true
+          limit: 300
+          interval: 1
+          timeunit: minute
         spikeArrest:
-          enabled: false
+          enabled: true
+          ratelimit: 900pm
   - name: prod
     approval_type: manual
     display_name_suffix: Production