fix: address Copilot review — use{} for resources, 404 for not found, curl -fSs

- Use Kotlin use{} blocks for PreparedStatement and ResultSet cleanup
- Return 404 ResponseEntity when member not found
- Handle null HikariPoolMXBean with proper error response
- Remove non-null assertion (!!) — return ResponseEntity directly
- Use curl -fSs in test.sh to fail on HTTP errors

Signed-off-by: slayerjain <shubhamkjain@outlook.com>

Author: slayerjain

ps-cache-kotlin/src/main/kotlin/com/demo/App.kt

@@ -6,6 +6,7 @@ import org.springframework.jdbc.core.JdbcTemplate
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
+import org.springframework.http.ResponseEntity
 import javax.sql.DataSource
 import com.zaxxer.hikari.HikariDataSource
 
@@ -29,63 +30,60 @@ class AccountController(private val jdbc: JdbcTemplate, private val dataSource:
     @GetMapping("/health")
     fun health() = mapOf("status" to "ok")
 
-    /**
-     * /account?member=N queries the travel_account table.
-     *
-     * JDBC PS caching (prepareThreshold=1):
-     * - 1st call on a fresh connection: Parse(query="SELECT ...") + Bind + Describe + Execute
-     * - 2nd+ calls on same connection: Bind(ps="S_1") + Execute only (cached PS)
-     *
-     * The /evict endpoint forces HikariCP to evict all connections, so the
-     * NEXT /account call gets a fresh connection with cold PS cache.
-     */
     @GetMapping("/account")
-    fun getAccount(@RequestParam("member") memberId: Int): Any {
-        return jdbc.execute { conn: java.sql.Connection ->
-            conn.autoCommit = false
-            try {
-                val ps = conn.prepareStatement(
-                    """SELECT id, member_id, name, balance
-                       FROM travelcard.travel_account
-                       WHERE member_id = ?"""
-                )
-                ps.setInt(1, memberId)
-                val rs = ps.executeQuery()
+    fun getAccount(@RequestParam("member") memberId: Int): ResponseEntity<Any> {
+        val result = jdbc.execute(
+            org.springframework.jdbc.core.ConnectionCallback<Account?> { conn ->
+                conn.autoCommit = false
+                try {
+                    conn.prepareStatement(
+                        """SELECT id, member_id, name, balance
+                           FROM travelcard.travel_account
+                           WHERE member_id = ?"""
+                    ).use { ps ->
+                        ps.setInt(1, memberId)
+                        ps.executeQuery().use { rs ->
+                            val account = if (rs.next()) {
+                                Account(
+                                    id = rs.getInt("id"),
+                                    memberId = rs.getInt("member_id"),
+                                    name = rs.getString("name"),
+                                    balance = rs.getInt("balance")
+                                )
+                            } else null
 
-                val result = if (rs.next()) {
-                    Account(
-                        id = rs.getInt("id"),
-                        memberId = rs.getInt("member_id"),
-                        name = rs.getString("name"),
-                        balance = rs.getInt("balance")
-                    )
-                } else {
-                    mapOf("error" to "not found", "member_id" to memberId)
+                            conn.commit()
+                            account
+                        }
+                    }
+                } catch (e: Exception) {
+                    conn.rollback()
+                    throw e
                 }
+            })
 
-                rs.close()
-                ps.close()
-                conn.commit()
-                result
-            } catch (e: Exception) {
-                conn.rollback()
-                throw e
-            }
-        }!!
+        return if (result != null) {
+            ResponseEntity.ok(result)
+        } else {
+            ResponseEntity.status(404).body(mapOf("error" to "not found", "member_id" to memberId))
+        }
     }
 
-    /**
-     * /evict forces HikariCP to evict all idle connections.
-     * Next request gets a FRESH PG connection → cold PS cache.
-     * This simulates what happens in production when connections cycle.
-     */
     @GetMapping("/evict")
-    fun evict(): Map<String, Any> {
-        val hikari = dataSource as HikariDataSource
-        hikari.hikariPoolMXBean?.softEvictConnections()
-        // Also wait briefly for eviction
+    fun evict(): ResponseEntity<Map<String, Any>> {
+        val hikari = dataSource as? HikariDataSource
+            ?: return ResponseEntity.status(500).body(mapOf("error" to "not a HikariDataSource"))
+
+        val mxBean = hikari.hikariPoolMXBean
+            ?: return ResponseEntity.status(500).body(mapOf("error" to "pool MXBean not available"))
+
+        mxBean.softEvictConnections()
         Thread.sleep(200)
-        return mapOf("evicted" to true, "active" to (hikari.hikariPoolMXBean?.activeConnections ?: 0),
-                      "idle" to (hikari.hikariPoolMXBean?.idleConnections ?: 0))
+
+        return ResponseEntity.ok(mapOf(
+            "evicted" to true,
+            "active" to mxBean.activeConnections,
+            "idle" to mxBean.idleConnections
+        ))
     }
 }

ps-cache-kotlin/test.sh

@@ -7,31 +7,31 @@ echo "=== PS-Cache Mock Mismatch Test (Kotlin/JDBC) ==="
 
 echo "--- Window 1: Connection A ---"
 echo "  /account?member=19:"
-curl -s "$BASE_URL/account?member=19"
+curl -fSs "$BASE_URL/account?member=19"
 echo ""
 sleep 0.3
 
 echo "  /account?member=23:"
-curl -s "$BASE_URL/account?member=23"
+curl -fSs "$BASE_URL/account?member=23"
 echo ""
 sleep 0.3
 
 echo ""
 echo "--- Evict (force new connection) ---"
 echo "  /evict:"
-curl -s "$BASE_URL/evict"
+curl -fSs "$BASE_URL/evict"
 echo ""
 sleep 1
 
 echo ""
 echo "--- Window 2: Connection B ---"
 echo "  /account?member=31:"
-curl -s "$BASE_URL/account?member=31"
+curl -fSs "$BASE_URL/account?member=31"
 echo ""
 sleep 0.3
 
 echo "  /account?member=42:"
-curl -s "$BASE_URL/account?member=42"
+curl -fSs "$BASE_URL/account?member=42"
 echo ""
 
 echo ""