fix: treat prepare Partial as terminal, honor real instrument coverage

- StatusNormalizer maps "partial" to COMPLETED (terminal) instead of
  IN_PROGRESS. Coverage windows can include hours with no trades; a prepare
  job resolving Partial means the available data is ready to execute on, not
  that more will arrive. Previously this polled until timeout.
- BacktestIntegrationTest derives its backtest window from the instrument
  coverage API (tickers, falling back to klines) instead of a hardcoded
  full-day range, capped at 24h.

Author: mrmx

CHANGELOG.md

@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.6.1] — 2026-07-10
+
+### Fixed 🐛
+
+- **Prepare is treated as terminal on `Partial`, not just `Completed`.** An instrument's coverage can span hours that hold no ticks — e.g. the tickers window `2026-07-10T13:00Z → 15:30Z`, where only the `14:00–15:00` hour traded — in which case the prepare reports partial coverage. The backtest workflow now proceeds to execute on the available data instead of polling that state until it times out.
+
 ## [0.6.0] — 2026-07-10
 
 ### Changed 🔄

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.qtsurfer</groupId>
     <artifactId>sdk-java</artifactId>
-    <version>0.6.0</version>
+    <version>0.6.1</version>
     <packaging>jar</packaging>
 
     <name>QTSurfer SDK</name>

src/main/java/com/qtsurfer/api/sdk/internal/StatusNormalizer.java

@@ -16,7 +16,11 @@ public static Normalized normalize(Object raw) {
         if (raw == null) return Normalized.IN_PROGRESS;
         String value = raw.toString().toLowerCase(java.util.Locale.ROOT);
         return switch (value) {
-            case "completed" -> Normalized.COMPLETED;
+            // A prepare job is terminal as soon as it returns: {@code Completed}, or the
+            // legacy {@code Partial} (some hours in the range legitimately hold no data —
+            // e.g. low-activity hours — so those hours never arrive). Both mean "ready to
+            // execute on the available coverage"; polling on Partial would hang forever.
+            case "completed", "partial" -> Normalized.COMPLETED;
             case "failed" -> Normalized.FAILED;
             case "aborted", "cancelled", "canceled" -> Normalized.ABORTED;
             default -> Normalized.IN_PROGRESS;

src/test/java/com/qtsurfer/api/sdk/integration/BacktestIntegrationTest.java

@@ -1,5 +1,8 @@
 package com.qtsurfer.api.sdk.integration;
 
+import com.qtsurfer.api.client.model.CoverageWindow;
+import com.qtsurfer.api.client.model.InstrumentCoverage;
+import com.qtsurfer.api.client.model.InstrumentDetail;
 import com.qtsurfer.api.client.model.ResultMap;
 import com.qtsurfer.api.sdk.BacktestOptions;
 import com.qtsurfer.api.sdk.BacktestRequest;
@@ -14,8 +17,7 @@
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
+import java.time.OffsetDateTime;
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentSkipListSet;
@@ -55,12 +57,26 @@ void completesCompilePrepareExecuteAgainstBinanceBtcUsdt() throws Exception {
                 .token(token)
                 .build();
 
+        // Honor the instrument's real data availability from the instruments API
+        // instead of presupposing a fixed calendar day — the backend may hold only
+        // a short recent window. Prefer ticker coverage (this is a TICKER backtest),
+        // fall back to klines, and cap the span at 24h.
+        CoverageWindow window = availableWindow(qts, "binance", "BTC/USDT");
+        OffsetDateTime to = window.getTo();
+        OffsetDateTime from = window.getFrom();
+        if (Duration.between(from, to).compareTo(Duration.ofHours(24)) > 0) {
+            from = to.minus(Duration.ofHours(24));
+        }
+        if (VERBOSE) {
+            log.info("Backtest window (instrument coverage, capped at 24h): {} → {}", from, to);
+        }
+
         BacktestRequest req = BacktestRequest.builder()
                 .strategy(loadFixture("fixtures/ForcedTradeStrategy.java"))
                 .exchangeId("binance")
                 .instrument("BTC/USDT")
-                .from(dayStartIso(1))
-                .to(dayStartIso(0))
+                .from(from.toInstant().toString())
+                .to(to.toInstant().toString())
                 .build();
 
         Set<BacktestStage> stages = new ConcurrentSkipListSet<>();
@@ -96,11 +112,22 @@ void completesCompilePrepareExecuteAgainstBinanceBtcUsdt() throws Exception {
         assertTrue(stages.contains(BacktestStage.EXECUTING), "executing stage fired");
     }
 
-    private static String dayStartIso(int offsetDays) {
-        return Instant.now()
-                .truncatedTo(ChronoUnit.DAYS)
-                .minus(offsetDays, ChronoUnit.DAYS)
-                .toString();
+    /**
+     * Resolves the instrument's currently-available data window from the
+     * instruments API, preferring ticker coverage and falling back to klines.
+     */
+    private static CoverageWindow availableWindow(QTSurfer qts, String exchangeId, String instrumentId) {
+        InstrumentDetail instrument = qts.instruments(exchangeId).stream()
+                .filter(i -> instrumentId.equals(i.getId()))
+                .findFirst()
+                .orElseThrow(() -> new AssertionError(instrumentId + " not listed on " + exchangeId));
+        InstrumentCoverage coverage = instrument.getCoverage();
+        assertNotNull(coverage, "coverage for " + instrumentId);
+        CoverageWindow window = coverage.getTickers() != null ? coverage.getTickers() : coverage.getKlines();
+        assertNotNull(window, "ticker/kline coverage window for " + instrumentId);
+        assertNotNull(window.getFrom(), "coverage window from");
+        assertNotNull(window.getTo(), "coverage window to");
+        return window;
     }
 
     private static String loadFixture(String path) throws IOException {

src/test/java/com/qtsurfer/api/sdk/internal/StatusNormalizerTest.java

@@ -14,6 +14,14 @@ void recognizesCompletedCaseInsensitive() {
         assertEquals(Normalized.COMPLETED, StatusNormalizer.normalize("COMPLETED"));
     }
 
+    @Test
+    void treatsPartialAsTerminalCompleted() {
+        // A prepare job is terminal on the legacy `Partial` status (low-activity hours
+        // never arrive), so it must resolve like `Completed`, not keep polling.
+        assertEquals(Normalized.COMPLETED, StatusNormalizer.normalize("partial"));
+        assertEquals(Normalized.COMPLETED, StatusNormalizer.normalize("Partial"));
+    }
+
     @Test
     void recognizesFailed() {
         assertEquals(Normalized.FAILED, StatusNormalizer.normalize("failed"));