Merge branch 'main' into sb/memory-cid-storesb/memory-cid-store

1 files changed, 137 insertions, 18 deletions

diff --git a/src/zenserver-test/buildstore-tests.cpp b/src/zenserver-test/buildstore-tests.cpp
index cf9b10896..1f2157993 100644
--- a/src/zenserver-test/buildstore-tests.cpp
+++ b/src/zenserver-test/buildstore-tests.cpp
@@ -148,8 +148,6 @@ TEST_CASE("buildstore.blobs")
 	}
 
 	{
-		// Single-range Get
-
 		ZenServerInstance Instance(TestEnv);
 
 		const uint16_t PortNumber =
@@ -158,6 +156,7 @@ TEST_CASE("buildstore.blobs")
 
 		HttpClient Client(Instance.GetBaseUri() + "/builds/");
 
+		// Single-range Get
 		{
 			const IoHash& RawHash  = CompressedBlobsHashes.front();
 			uint64_t	  BlobSize = CompressedBlobsSizes.front();
@@ -183,20 +182,63 @@ TEST_CASE("buildstore.blobs")
 			MemoryView RangeView   = Payload.GetView();
 			CHECK(ActualRange.EqualBytes(RangeView));
 		}
-	}
 
-	{
-		// Single-range Post
+		{
+			// 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);
+		}
 
-		ZenServerInstance Instance(TestEnv);
+		{
+			// GET with out-of-bounds range
+			const IoHash& RawHash  = CompressedBlobsHashes.front();
+			uint64_t	  BlobSize = CompressedBlobsSizes.front();
 
-		const uint16_t PortNumber =
-			Instance.SpawnServerAndWaitUntilReady(fmt::format("--buildstore-enabled --system-dir {}", SystemRootPath));
-		CHECK(PortNumber != 0);
+			HttpClient::KeyValueMap Headers;
+			Headers.Entries.insert({"Range", fmt::format("bytes={}-{}", BlobSize + 100, BlobSize + 200)});
 
-		HttpClient Client(Instance.GetBaseUri() + "/builds/");
+			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;
 
 			const IoHash& RawHash  = CompressedBlobsHashes.front();
@@ -259,19 +301,96 @@ TEST_CASE("buildstore.blobs")
 				Offset += Range.second;
 			}
 		}
-	}
 
-	{
-		// Multi-range
+		{
+			// POST with wrong accept type
+			const IoHash& RawHash = CompressedBlobsHashes.front();
 
-		ZenServerInstance Instance(TestEnv);
+			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();
 
-		const uint16_t PortNumber =
-			Instance.SpawnServerAndWaitUntilReady(fmt::format("--buildstore-enabled --system-dir {}", SystemRootPath));
-		CHECK(PortNumber != 0);
+			HttpClient::Response Result = Client.Post(fmt::format("{}/{}/{}/blobs/{}", Namespace, Bucket, BuildId, RawHash),
+													  Writer.Save(),
+													  HttpClient::Accept(ZenContentType::kBinary));
+			CHECK_EQ(Result.StatusCode, HttpResponseCode::BadRequest);
+		}
 
-		HttpClient Client(Instance.GetBaseUri() + "/builds/");
+		{
+			// 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;