cacherequests helpers test only (#551)

* don't use cacherequests utils in cache_cmd.cpp
* make zenutil/cacherequests code into test code helpers only

1 files changed, 101 insertions, 25 deletions

diff --git a/src/zen/cmds/cache_cmd.cpp b/src/zen/cmds/cache_cmd.cpp
index 5948a7f1d..85dcd7648 100644
--- a/src/zen/cmds/cache_cmd.cpp
+++ b/src/zen/cmds/cache_cmd.cpp
@@ -2,6 +2,7 @@
 
 #include "cache_cmd.h"
 
+#include <zencore/compactbinarybuilder.h>
 #include <zencore/compress.h>
 #include <zencore/except.h>
 #include <zencore/filesystem.h>
@@ -13,7 +14,7 @@
 #include <zenhttp/httpclient.h>
 #include <zenhttp/httpcommon.h>
 #include <zenhttp/packageformat.h>
-#include <zenutil/cache/cacherequests.h>
+#include <zenstore/cache/cachepolicy.h>
 
 #include <memory>
 #include <random>
@@ -432,32 +433,109 @@ CacheGenerateCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 
 	HttpClient Http(m_HostName);
 
-	auto GeneratePutCacheValueRequest([this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
-		cacherequests::PutCacheValuesRequest Request({.AcceptMagic = kCbPkgMagic, .Namespace = m_Namespace});
-		for (std::uint64_t ValueSize : BatchSizes)
-		{
-			uint64_t	KeyBase	  = KeyDistribution(Generator);
-			std::string KeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, ValueSize);
-			IoHash		ValueKey  = IoHash::HashBuffer(KeyString.c_str(), KeyString.length());
+	auto GeneratePutCacheValueRequest(
+		[this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) -> CbPackage {
+			CbPackage Package;
 
-			Request.Requests.emplace_back(cacherequests::PutCacheValueRequest{.Key	= {.Bucket = m_Bucket, .Hash = ValueKey},
-																			  .Body = CompressBlob(CreateRandomBlob(ValueSize))});
-		}
-		return Request;
-	});
+			CbObjectWriter Writer;
+			Writer << "Method"
+				   << "PutCacheValues";
+			Writer << "Accept" << kCbPkgMagic;
+
+			Writer.BeginObject("Params");
+			{
+				Writer << "DefaultPolicy" << WriteToString<128>(CachePolicy::Default);
+				Writer << "Namespace" << m_Namespace;
+
+				Writer.BeginArray("Requests");
+
+				for (std::uint64_t ValueSize : BatchSizes)
+				{
+					Writer.BeginObject();
+					{
+						uint64_t	KeyBase	  = KeyDistribution(Generator);
+						std::string KeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, ValueSize);
+						IoHash		ValueKey  = IoHash::HashBuffer(KeyString.c_str(), KeyString.length());
+
+						Writer.BeginObject("Key");
+						{
+							Writer << "Bucket" << m_Bucket;
+							Writer << "Hash" << ValueKey;
+						}
+						Writer.EndObject();	 // Key
+
+						CompressedBuffer Payload = CompressBlob(CreateRandomBlob(ValueSize));
+						Writer.AddBinaryAttachment("RawHash", Payload.DecodeRawHash());
+						Package.AddAttachment(CbAttachment(Payload, Payload.DecodeRawHash()));
+					}
+					Writer.EndObject();
+				}
+				Writer.EndArray();	// Requests
+			}
+			Writer.EndObject();	 // Params
+
+			Package.SetObject(Writer.Save());
+
+			return Package;
+		});
 
 	auto GeneratePutCacheRecordRequest([this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
-		cacherequests::PutCacheRecordsRequest Request({.AcceptMagic = kCbPkgMagic, .Namespace = m_Namespace});
-		uint64_t							  KeyBase		  = KeyDistribution(Generator);
-		std::string							  RecordKeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, BatchSizes.size());
-		IoHash								  RecordKey		  = IoHash::HashBuffer(RecordKeyString.c_str(), RecordKeyString.length());
+		CbPackage Package;
+
+		CbObjectWriter Writer;
+		Writer << "Method"
+			   << "PutCacheRecords";
+		Writer << "Accept" << kCbPkgMagic;
 
-		Request.Requests.emplace_back(cacherequests::PutCacheRecordRequest{.Key = {.Bucket = m_Bucket, .Hash = RecordKey}});
-		for (std::uint64_t ValueSize : BatchSizes)
+		Writer.BeginObject("Params");
 		{
-			Request.Requests.back().Values.push_back({.Id = Oid::NewOid(), .Body = CompressBlob(CreateRandomBlob(ValueSize))});
+			Writer << "DefaultPolicy" << WriteToString<128>(CachePolicy::Default);
+			Writer << "Namespace" << m_Namespace;
+
+			Writer.BeginArray("Requests");
+			{
+				Writer.BeginObject();
+				{
+					Writer.BeginObject("Record");
+					{
+						uint64_t	KeyBase			= KeyDistribution(Generator);
+						std::string RecordKeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, BatchSizes.size());
+						IoHash		RecordKey		= IoHash::HashBuffer(RecordKeyString.c_str(), RecordKeyString.length());
+
+						Writer.BeginObject("Key");
+						{
+							Writer << "Bucket" << m_Bucket;
+							Writer << "Hash" << RecordKey;
+						}
+						Writer.EndObject();	 // Key
+
+						Writer.BeginArray("Values");
+						for (std::uint64_t ValueSize : BatchSizes)
+						{
+							Writer.BeginObject();
+							{
+								Writer.AddObjectId("Id", Oid::NewOid());
+
+								CompressedBuffer Payload = CompressBlob(CreateRandomBlob(ValueSize));
+								Writer.AddBinaryAttachment("RawHash", Payload.DecodeRawHash());
+								Package.AddAttachment(CbAttachment(Payload, Payload.DecodeRawHash()));
+								Writer.AddInteger("RawSize", Payload.DecodeRawSize());
+							}
+							Writer.EndObject();
+						}
+						Writer.EndArray();	// Values
+					}
+					Writer.EndObject();	 // Record
+				}
+				Writer.EndObject();
+			}
+			Writer.EndArray();	// Requests
 		}
-		return Request;
+		Writer.EndObject();	 // Params
+
+		Package.SetObject(Writer.Save());
+
+		return Package;
 	});
 
 	WorkerThreadPool WorkerPool(gsl::narrow<int>(Max((std::thread::hardware_concurrency() / 2u), 2u)));
@@ -480,13 +558,11 @@ CacheGenerateCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 				CbPackage Package;
 				if (m_MaxAttachmentCount > 0 && SizeCount > 0)
 				{
-					auto Request = GeneratePutCacheRecordRequest(BatchSizes, RequestIndex);
-					ZEN_ASSERT(Request.Format(Package));
+					Package = GeneratePutCacheRecordRequest(BatchSizes, RequestIndex);
 				}
 				else
 				{
-					auto Request = GeneratePutCacheValueRequest(BatchSizes, RequestIndex);
-					ZEN_ASSERT(Request.Format(Package));
+					Package = GeneratePutCacheValueRequest(BatchSizes, RequestIndex);
 				}
 
 				if (HttpClient::Response Response = Http.Post("/z$/$rpc", Package, HttpClient::Accept(ZenContentType::kCbPackage));