HTTP range responses (RFC 7233) - httpobjectstore (#928)

- Improvement: HTTP range responses (RFC 7233) are now fully compliant across the object store and build store
  - 206 Partial Content responses now include a `Content-Range` header; previously absent for single-range requests, which broke `HttpClient::GetRanges()`
  - 416 Range Not Satisfiable responses now include `Content-Range: bytes */N` as required by RFC 7233
  - Out-of-bounds range requests return 416 Range Not Satisfiable (was 400 Bad Request)
  - Single-byte ranges (`bytes=N-N`) are now correctly accepted (were previously rejected)
  - Range byte positions widened from 32-bit to 64-bit; RFC 7233 imposes no size limit on byte range values
  - Build store binary GET requests with a Range header now return 206 Partial Content with `Content-Range` (previously returned 200 OK without it)

1 files changed, 95 insertions, 6 deletions

diff --git a/src/zenserver-test/objectstore-tests.cpp b/src/zenserver-test/objectstore-tests.cpp
index 2139d4d3a..99c92e15f 100644
--- a/src/zenserver-test/objectstore-tests.cpp
+++ b/src/zenserver-test/objectstore-tests.cpp
@@ -201,19 +201,108 @@ TEST_CASE("objectstore")
 			CHECK(Result.ResponsePayload.GetView().EqualBytes(BlobView.Mid(1000, 24)));
 		}
 
-		// Multiple ranges: not supported, falls back to 200 with full body per RFC 7233
+		// Multiple ranges: bytes 0-49 and 100-149
 		{
 			HttpClient::Response Result = Client.Get(ObjectPath, {{"Range", "bytes=0-49,100-149"}});
-			CHECK(Result.StatusCode == HttpResponseCode::OK);
-			CHECK_EQ(Result.ResponsePayload.GetSize(), 1024u);
-			CHECK(Result.ResponsePayload.GetView().EqualBytes(BlobView));
+			CHECK(Result.StatusCode == HttpResponseCode::PartialContent);
+
+			std::string_view Body(reinterpret_cast<const char*>(Result.ResponsePayload.GetData()), Result.ResponsePayload.GetSize());
+
+			// Verify multipart structure contains both range payloads
+			CHECK(Body.find("Content-Range: bytes 0-49/1024") != std::string_view::npos);
+			CHECK(Body.find("Content-Range: bytes 100-149/1024") != std::string_view::npos);
+
+			// Extract and verify actual data for first range
+			auto FindPartData = [&](std::string_view ContentRange) -> std::string_view {
+				size_t Pos = Body.find(ContentRange);
+				if (Pos == std::string_view::npos)
+				{
+					return {};
+				}
+				// Skip past the Content-Range line and the blank line separator
+				Pos = Body.find("\r\n\r\n", Pos);
+				if (Pos == std::string_view::npos)
+				{
+					return {};
+				}
+				Pos += 4;
+				size_t End = Body.find("\r\n--", Pos);
+				if (End == std::string_view::npos)
+				{
+					return {};
+				}
+				return Body.substr(Pos, End - Pos);
+			};
+
+			std::string_view Part1 = FindPartData("Content-Range: bytes 0-49/1024");
+			CHECK_EQ(Part1.size(), 50u);
+			CHECK(MemoryView(Part1.data(), Part1.size()).EqualBytes(BlobView.Mid(0, 50)));
+
+			std::string_view Part2 = FindPartData("Content-Range: bytes 100-149/1024");
+			CHECK_EQ(Part2.size(), 50u);
+			CHECK(MemoryView(Part2.data(), Part2.size()).EqualBytes(BlobView.Mid(100, 50)));
 		}
 
-		// Out-of-bounds range: should return 400
+		// Out-of-bounds single range
 		{
 			HttpClient::Response Result = Client.Get(ObjectPath, {{"Range", "bytes=2000-2099"}});
-			CHECK(Result.StatusCode == HttpResponseCode::BadRequest);
+			CHECK(Result.StatusCode == HttpResponseCode::RangeNotSatisfiable);
 		}
+
+		// Out-of-bounds multi-range
+		{
+			HttpClient::Response Result = Client.Get(ObjectPath, {{"Range", "bytes=0-49,2000-2099"}});
+			CHECK(Result.StatusCode == HttpResponseCode::RangeNotSatisfiable);
+		}
+	}
+}
+
+TEST_CASE("objectstore.range-requests-download")
+{
+	ZenServerInstance Instance(TestEnv);
+	const uint16_t	  Port = Instance.SpawnServerAndWaitUntilReady("--objectstore-enabled");
+	REQUIRE(Port != 0);
+
+	HttpClient Client(Instance.GetBaseUri() + "/obj/");
+
+	IoBuffer	Blob	   = CreateRandomBlob(1024);
+	MemoryView	BlobView   = Blob.GetView();
+	std::string ObjectPath = "bucket/bkt/range-download-test/data.bin";
+
+	HttpClient::Response PutResult = Client.Put(ObjectPath, IoBuffer(Blob));
+	REQUIRE(PutResult);
+
+	ScopedTemporaryDirectory DownloadDir;
+
+	// Single range via Download: verify Ranges is populated and GetRanges maps correctly
+	{
+		HttpClient::Response Result = Client.Download(ObjectPath, DownloadDir.Path(), {{"Range", "bytes=100-199"}});
+		CHECK(Result.StatusCode == HttpResponseCode::PartialContent);
+		REQUIRE_EQ(Result.Ranges.size(), 1u);
+		CHECK_EQ(Result.Ranges[0].RangeOffset, 100u);
+		CHECK_EQ(Result.Ranges[0].RangeLength, 100u);
+
+		std::vector<std::pair<uint64_t, uint64_t>> RequestedRanges = {{100, 100}};
+		std::vector<std::pair<uint64_t, uint64_t>> PayloadRanges   = Result.GetRanges(RequestedRanges);
+		REQUIRE_EQ(PayloadRanges.size(), 1u);
+		CHECK(Result.ResponsePayload.GetView().Mid(PayloadRanges[0].first, PayloadRanges[0].second).EqualBytes(BlobView.Mid(100, 100)));
+	}
+
+	// Multi-range via Download: verify Ranges is populated for both parts and GetRanges maps correctly
+	{
+		HttpClient::Response Result = Client.Download(ObjectPath, DownloadDir.Path(), {{"Range", "bytes=0-49,100-149"}});
+		CHECK(Result.StatusCode == HttpResponseCode::PartialContent);
+		REQUIRE_EQ(Result.Ranges.size(), 2u);
+		CHECK_EQ(Result.Ranges[0].RangeOffset, 0u);
+		CHECK_EQ(Result.Ranges[0].RangeLength, 50u);
+		CHECK_EQ(Result.Ranges[1].RangeOffset, 100u);
+		CHECK_EQ(Result.Ranges[1].RangeLength, 50u);
+
+		std::vector<std::pair<uint64_t, uint64_t>> RequestedRanges = {{0, 50}, {100, 50}};
+		std::vector<std::pair<uint64_t, uint64_t>> PayloadRanges   = Result.GetRanges(RequestedRanges);
+		REQUIRE_EQ(PayloadRanges.size(), 2u);
+		CHECK(Result.ResponsePayload.GetView().Mid(PayloadRanges[0].first, PayloadRanges[0].second).EqualBytes(BlobView.Mid(0, 50)));
+		CHECK(Result.ResponsePayload.GetView().Mid(PayloadRanges[1].first, PayloadRanges[1].second).EqualBytes(BlobView.Mid(100, 50)));
 	}
 }