fix: keep single-close guard honest when delegate close() throws

LoggableResponseBody.closeDelegateOnce() set the delegateClosed flag only
after delegate.close() returned normally. When that close throws, the flag
was left false, so a second close() reaching the delegate through the other
entry point (the over-cap one-shot PrefixThenTailSource.close() vs the
wrapper's own close()) would close the delegate a second time. The guard
exists precisely to guarantee a single close for delegates whose handles are
not safe to close twice, and the error path silently broke that guarantee.

Flip the guard in a finally so the delegate is marked closed whether or not
its close() succeeds, while still letting the exception propagate. This also
matches the drain-path error handler, which already marks the delegate closed
after a failed source close so a later close() is a no-op.

Closes #115

Author: OmarAlJarrah

sdk-core/src/main/kotlin/org/dexpace/sdk/core/http/response/LoggableResponseBody.kt

@@ -210,8 +210,14 @@ public class LoggableResponseBody
          */
         @Throws(IOException::class)
         private fun closeDelegateOnce() {
-            if (!delegateClosed) {
+            if (delegateClosed) return
+            // Flip the guard whether or not close() succeeds: a delegate whose handle is not safe
+            // to close twice must still see exactly one close even when that close throws. Marking
+            // it closed in a finally also matches the drain-path error handler, which marks the
+            // delegate closed after a failed source close so a later close() is a no-op.
+            try {
                 delegate.close()
+            } finally {
                 delegateClosed = true
             }
         }

sdk-core/src/test/kotlin/org/dexpace/sdk/core/http/response/LoggableResponseBodyTest.kt

@@ -474,6 +474,42 @@ class LoggableResponseBodyTest {
         )
     }
 
+    @Test
+    fun `delegate whose close throws is invoked only once across two close calls`() {
+        // Over-cap path: the one-shot source close and the wrapper close both funnel through the
+        // single-close guard. If the first close() throws, the guard must still flip so the second
+        // close() is a no-op — a delegate whose handle is not safe to close twice must see exactly
+        // one close even when that close fails.
+        val delegateCloseCount = AtomicInteger(0)
+        val payload = "abcdefghijklmnopqrstuvwxyz" // 26 bytes > cap
+        val delegate =
+            object : ResponseBody() {
+                override fun mediaType(): MediaType? = MediaType.parse("text/plain")
+
+                override fun contentLength(): Long = payload.toByteArray(Charsets.UTF_8).size.toLong()
+
+                override fun source(): BufferedSource = Io.provider.buffer().also { it.writeUtf8(payload) }
+
+                override fun close() {
+                    delegateCloseCount.incrementAndGet()
+                    throw IOException("delegate close failed")
+                }
+            }
+        val wrapper = LoggableResponseBody.bounded(delegate, Io.provider, 5L)
+
+        val tail = wrapper.source()
+        // First close reaches the delegate and throws; the guard must still flip.
+        assertFailsWith<IOException> { tail.close() }
+        // Second close must be a no-op — the delegate is not closed again.
+        wrapper.close()
+
+        assertEquals(
+            1,
+            delegateCloseCount.get(),
+            "a delegate whose close() throws must still be closed exactly once across two close() calls",
+        )
+    }
+
     @Test
     fun `over-cap close then source close closes the underlying source exactly once`() {
         // The reverse order: wrapper.close() first, then closing the already-handed-out one-shot