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)

2 files changed, 237 insertions, 6 deletions

diff --git a/src/zenserver-test/buildstore-tests.cpp b/src/zenserver-test/buildstore-tests.cpp
index 28fc4d7ea..1f2157993 100644
--- a/src/zenserver-test/buildstore-tests.cpp
+++ b/src/zenserver-test/buildstore-tests.cpp
@@ -183,6 +183,60 @@ TEST_CASE("buildstore.blobs")
 			CHECK(ActualRange.EqualBytes(RangeView));
 		}
 
+		{
+			// GET blob not found
+			IoHash				 FakeHash = IoHash::HashBuffer("nonexistent", 11);
+			HttpClient::Response Result	  = Client.Get(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, FakeHash));
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::NotFound);
+		}
+
+		{
+			// GET with out-of-bounds range
+			const IoHash& RawHash  = CompressedBlobsHashes.front();
+			uint64_t	  BlobSize = CompressedBlobsSizes.front();
+
+			HttpClient::KeyValueMap Headers;
+			Headers.Entries.insert({"Range", fmt::format("bytes={}-{}", BlobSize + 100, BlobSize + 200)});
+
+			HttpClient::Response Result = Client.Get(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash), Headers);
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::RangeNotSatisfiable);
+		}
+
+		{
+			// GET with multi-range header (uses Download for multipart boundary parsing)
+			const IoHash& RawHash  = CompressedBlobsHashes.front();
+			uint64_t	  BlobSize = CompressedBlobsSizes.front();
+
+			uint64_t Range1Start = 0;
+			uint64_t Range1End	 = BlobSize / 4 - 1;
+			uint64_t Range2Start = BlobSize / 2;
+			uint64_t Range2End	 = BlobSize / 2 + BlobSize / 4 - 1;
+
+			HttpClient::KeyValueMap Headers;
+			Headers.Entries.insert({"Range", fmt::format("bytes={}-{},{}-{}", Range1Start, Range1End, Range2Start, Range2End)});
+
+			HttpClient::Response Result =
+				Client.Download(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash), SystemRootPath, Headers);
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::PartialContent);
+			REQUIRE_EQ(Result.Ranges.size(), 2);
+
+			HttpClient::Response FullBlobResult = Client.Get(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash),
+															 HttpClient::Accept(ZenContentType::kCompressedBinary));
+			REQUIRE(FullBlobResult);
+
+			uint64_t Range1Len = Range1End - Range1Start + 1;
+			uint64_t Range2Len = Range2End - Range2Start + 1;
+
+			MemoryView ExpectedRange1 = FullBlobResult.ResponsePayload.GetView().Mid(Range1Start, Range1Len);
+			MemoryView ExpectedRange2 = FullBlobResult.ResponsePayload.GetView().Mid(Range2Start, Range2Len);
+
+			MemoryView ActualRange1 = Result.ResponsePayload.GetView().Mid(Result.Ranges[0].OffsetInPayload, Range1Len);
+			MemoryView ActualRange2 = Result.ResponsePayload.GetView().Mid(Result.Ranges[1].OffsetInPayload, Range2Len);
+
+			CHECK(ExpectedRange1.EqualBytes(ActualRange1));
+			CHECK(ExpectedRange2.EqualBytes(ActualRange2));
+		}
+
 		// Single-range Post
 		{
 			uint64_t RangeSizeSum = 0;
@@ -248,6 +302,94 @@ TEST_CASE("buildstore.blobs")
 			}
 		}
 
+		{
+			// POST with wrong accept type
+			const IoHash& RawHash = CompressedBlobsHashes.front();
+
+			CbObjectWriter Writer;
+			Writer.BeginArray("ranges"sv);
+			Writer.BeginObject();
+			Writer.AddInteger("offset"sv, uint64_t(0));
+			Writer.AddInteger("length"sv, uint64_t(10));
+			Writer.EndObject();
+			Writer.EndArray();
+
+			HttpClient::Response Result = Client.Post(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash),
+													  Writer.Save(),
+													  HttpClient::Accept(ZenContentType::kBinary));
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::BadRequest);
+		}
+
+		{
+			// POST with missing payload
+			const IoHash& RawHash = CompressedBlobsHashes.front();
+
+			HttpClient::Response Result = Client.Post(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash),
+													  HttpClient::Accept(ZenContentType::kCbPackage));
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::BadRequest);
+		}
+
+		{
+			// POST with empty ranges array
+			const IoHash& RawHash = CompressedBlobsHashes.front();
+
+			CbObjectWriter Writer;
+			Writer.BeginArray("ranges"sv);
+			Writer.EndArray();
+
+			HttpClient::Response Result = Client.Post(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash),
+													  Writer.Save(),
+													  HttpClient::Accept(ZenContentType::kCbPackage));
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::BadRequest);
+		}
+
+		{
+			// POST with range count exceeding maximum
+			const IoHash& RawHash = CompressedBlobsHashes.front();
+
+			CbObjectWriter Writer;
+			Writer.BeginArray("ranges"sv);
+			for (uint32_t I = 0; I < 257; I++)
+			{
+				Writer.BeginObject();
+				Writer.AddInteger("offset"sv, uint64_t(0));
+				Writer.AddInteger("length"sv, uint64_t(1));
+				Writer.EndObject();
+			}
+			Writer.EndArray();
+
+			HttpClient::Response Result = Client.Post(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash),
+													  Writer.Save(),
+													  HttpClient::Accept(ZenContentType::kCbPackage));
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::BadRequest);
+		}
+
+		{
+			// POST with out-of-bounds range returns length=0
+			const IoHash& RawHash  = CompressedBlobsHashes.front();
+			uint64_t	  BlobSize = CompressedBlobsSizes.front();
+
+			CbObjectWriter Writer;
+			Writer.BeginArray("ranges"sv);
+			Writer.BeginObject();
+			Writer.AddInteger("offset"sv, BlobSize + 100);
+			Writer.AddInteger("length"sv, uint64_t(50));
+			Writer.EndObject();
+			Writer.EndArray();
+
+			HttpClient::Response Result = Client.Post(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash),
+													  Writer.Save(),
+													  HttpClient::Accept(ZenContentType::kCbPackage));
+			REQUIRE(Result);
+			CbPackage	 ResponsePackage = ParsePackageMessage(Result.ResponsePayload);
+			CbObjectView ResponseObject	 = ResponsePackage.GetObject();
+			CbArrayView	 RangeArray		 = ResponseObject["ranges"sv].AsArrayView();
+			REQUIRE_EQ(RangeArray.Num(), uint64_t(1));
+			CbObjectView Range = (*begin(RangeArray)).AsObjectView();
+			CHECK_EQ(Range["offset"sv].AsUInt64(), BlobSize + 100);
+			CHECK_EQ(Range["length"sv].AsUInt64(), uint64_t(0));
+		}
+
 		// Multi-range
 		{
 			uint64_t RangeSizeSum = 0;
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)));
 	}
 }