make cpr a HttpClient implementation detail (#517)

these changes remove cpr from anything which is not `HttpClient` internals.

The goal is to eventually replace cpr with a more direct curl interface to eliminate cpr since it's proven problematic due to their development practices which frequently breaks APIs and prevents us from updating vcpkg. But this PR is limited to refactoring existing cpr code to use `HttpClient` instead.

3 files changed, 451 insertions, 685 deletions

diff --git a/src/zenserver-test/projectclient.cpp b/src/zenserver-test/projectclient.cpp
deleted file mode 100644
index cb493be77..000000000
--- a/src/zenserver-test/projectclient.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-#include "projectclient.h"
-
-#if 0
-
-#	include <zencore/compactbinary.h>
-#	include <zencore/logging.h>
-#	include <zencore/sharedbuffer.h>
-#	include <zencore/string.h>
-#	include <zencore/zencore.h>
-
-#	include <asio.hpp>
-#	include <gsl/gsl-lite.hpp>
-
-namespace zen {
-
-struct ProjectClientConnection
-{
-	ProjectClientConnection(int BasePort) { Connect(BasePort); }
-
-	void Connect(int BasePort)
-	{
-		ZEN_UNUSED(BasePort);
-
-		WideStringBuilder<64> PipeName;
-		PipeName << "\\\\.\\pipe\\zenprj";	// TODO: this should use an instance-specific identifier!
-
-		HANDLE hPipe = CreateFileW(PipeName.c_str(),
-								   GENERIC_READ | GENERIC_WRITE,
-								   0,			   // Sharing doesn't make any sense
-								   nullptr,		   // No security attributes
-								   OPEN_EXISTING,  // Open existing pipe
-								   0,			   // Attributes
-								   nullptr		   // Template file
-		);
-
-		if (hPipe == INVALID_HANDLE_VALUE)
-		{
-			ZEN_WARN("failed while creating named pipe {}", WideToUtf8(PipeName));
-
-			throw std::system_error(GetLastError(), std::system_category(), fmt::format("Failed to open named pipe '{}'", WideToUtf8(PipeName)));
-		}
-
-		// Change to message mode
-		DWORD dwMode  = PIPE_READMODE_MESSAGE;
-		BOOL  Success = SetNamedPipeHandleState(hPipe, &dwMode, nullptr, nullptr);
-
-		if (!Success)
-		{
-			throw std::system_error(GetLastError(),
-									std::system_category(),
-									fmt::format("Failed to change named pipe '{}' to message mode", WideToUtf8(PipeName)));
-		}
-
-		m_hPipe.Attach(hPipe);	// This now owns the handle and will close it
-	}
-
-	~ProjectClientConnection() {}
-
-	CbObject MessageTransaction(CbObject Request)
-	{
-		DWORD dwWrittenBytes = 0;
-
-		MemoryView View = Request.GetView();
-
-		BOOL Success = ::WriteFile(m_hPipe, View.GetData(), gsl::narrow_cast<DWORD>(View.GetSize()), &dwWrittenBytes, nullptr);
-
-		if (!Success)
-		{
-			throw std::system_error(GetLastError(), std::system_category(), "Failed to write pipe message");
-		}
-
-		ZEN_ASSERT(dwWrittenBytes == View.GetSize());
-
-		DWORD dwReadBytes = 0;
-
-		Success = ReadFile(m_hPipe, m_Buffer, sizeof m_Buffer, &dwReadBytes, nullptr);
-
-		if (!Success)
-		{
-			DWORD ErrorCode = GetLastError();
-
-			if (ERROR_MORE_DATA == ErrorCode)
-			{
-				// Response message is larger than our buffer - handle it by allocating a larger
-				// buffer on the heap and read the remainder into that buffer
-
-				DWORD dwBytesAvail = 0, dwLeftThisMessage = 0;
-
-				Success = PeekNamedPipe(m_hPipe, nullptr, 0, nullptr, &dwBytesAvail, &dwLeftThisMessage);
-
-				if (Success)
-				{
-					UniqueBuffer MessageBuffer = UniqueBuffer::Alloc(dwReadBytes + dwLeftThisMessage);
-
-					memcpy(MessageBuffer.GetData(), m_Buffer, dwReadBytes);
-
-					Success = ReadFile(m_hPipe,
-									   reinterpret_cast<uint8_t*>(MessageBuffer.GetData()) + dwReadBytes,
-									   dwLeftThisMessage,
-									   &dwReadBytes,
-									   nullptr);
-
-					if (Success)
-					{
-						return CbObject(SharedBuffer(std::move(MessageBuffer)));
-					}
-				}
-			}
-
-			throw std::system_error(GetLastError(), std::system_category(), "Failed to read pipe message");
-		}
-
-		return CbObject(SharedBuffer::MakeView(MakeMemoryView(m_Buffer)));
-	}
-
-private:
-	static const int kEmbeddedBufferSize = 512 - 16;
-
-	CHandle m_hPipe;
-	uint8_t m_Buffer[kEmbeddedBufferSize];
-};
-
-struct LocalProjectClient::ClientImpl
-{
-	ClientImpl(int BasePort) : m_BasePort(BasePort) {}
-	~ClientImpl() {}
-
-	void Start() {}
-	void Stop() {}
-
-	inline int BasePort() const { return m_BasePort; }
-
-private:
-	int m_BasePort = 0;
-};
-
-LocalProjectClient::LocalProjectClient(int BasePort)
-{
-	m_Impl = std::make_unique<ClientImpl>(BasePort);
-	m_Impl->Start();
-}
-
-LocalProjectClient::~LocalProjectClient()
-{
-	m_Impl->Stop();
-}
-
-CbObject
-LocalProjectClient::MessageTransaction(CbObject Request)
-{
-	ProjectClientConnection Cx(m_Impl->BasePort());
-
-	return Cx.MessageTransaction(Request);
-}
-
-}  // namespace zen
-
-#endif	// 0
diff --git a/src/zenserver-test/projectclient.h b/src/zenserver-test/projectclient.h
deleted file mode 100644
index 8362ee0ee..000000000
--- a/src/zenserver-test/projectclient.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-#pragma once
-
-#include <memory>
-
-#include <zenbase/refcount.h>
-#include <zencore/compactbinary.h>
-
-namespace zen {
-
-/**
- * Client for communication with local project service
- *
- * This is WIP and not yet functional!
- */
-
-class LocalProjectClient : public RefCounted
-{
-public:
-	LocalProjectClient(int BasePort = 0);
-	~LocalProjectClient();
-
-	CbObject MessageTransaction(CbObject Request);
-
-private:
-	struct ClientImpl;
-
-	std::unique_ptr<ClientImpl> m_Impl;
-};
-
-}  // namespace zen
diff --git a/src/zenserver-test/zenserver-test.cpp b/src/zenserver-test/zenserver-test.cpp
index 923d35d13..827a4eb5a 100644
--- a/src/zenserver-test/zenserver-test.cpp
+++ b/src/zenserver-test/zenserver-test.cpp
@@ -38,7 +38,6 @@
 #endif
 
 ZEN_THIRD_PARTY_INCLUDES_START
-#include <cpr/cpr.h>
 #include <tsl/robin_set.h>
 #undef GetObject
 ZEN_THIRD_PARTY_INCLUDES_END
@@ -61,10 +60,6 @@ ZEN_THIRD_PARTY_INCLUDES_END
 
 //////////////////////////////////////////////////////////////////////////
 
-#include "projectclient.h"
-
-//////////////////////////////////////////////////////////////////////////
-
 #if ZEN_WITH_TESTS
 #	define ZEN_TEST_WITH_RUNNER 1
 #	include <zencore/testing.h>
@@ -180,12 +175,12 @@ TEST_CASE("default.single")
 		const int	   ThreadId = zen::GetCurrentThreadId();
 
 		ZEN_INFO("query batch {} started (thread {})", BatchNo, ThreadId);
-		cpr::Session cli;
-		cli.SetUrl(cpr::Url{fmt::format("http://localhost:{}/test/hello", PortNumber)});
+
+		HttpClient Http{fmt::format("http://localhost:{}", PortNumber)};
 
 		for (int i = 0; i < 10000; ++i)
 		{
-			auto res = cli.Get();
+			auto res = Http.Get("/test/hello"sv);
 			++RequestCount;
 		}
 		ZEN_INFO("query batch {} ended (thread {})", BatchNo, ThreadId);
@@ -224,18 +219,20 @@ TEST_CASE("default.loopback")
 
 	SUBCASE("ipv4 endpoint connectivity")
 	{
-		cpr::Session cli;
-		cli.SetUrl(cpr::Url{fmt::format("http://127.0.0.1:{}/test/hello", PortNumber)});
-		auto res = cli.Get();
-		CHECK(!res.error);
+		HttpClient Http{fmt::format("http://127.0.0.1:{}", PortNumber)};
+
+		auto res = Http.Get("/test/hello"sv);
+
+		CHECK(res);
 	}
 
 	SUBCASE("ipv6 endpoint connectivity")
 	{
-		cpr::Session cli;
-		cli.SetUrl(cpr::Url{fmt::format("http://[::1]:{}/test/hello", PortNumber)});
-		auto res = cli.Get();
-		CHECK(!res.error);
+		HttpClient Http{fmt::format("http://[::1]:{}", PortNumber)};
+
+		auto res = Http.Get("/test/hello"sv);
+
+		CHECK(res);
 	}
 }
 
@@ -267,14 +264,14 @@ TEST_CASE("multi.basic")
 
 		ZEN_INFO("query batch {} started (thread {}) for port {}", BatchNo, ThreadId, PortNumber);
 
-		cpr::Session cli;
-		cli.SetUrl(cpr::Url{fmt::format("http://localhost:{}/test/hello", PortNumber)});
+		HttpClient Http{fmt::format("http://localhost:{}", PortNumber)};
 
 		for (int i = 0; i < 10000; ++i)
 		{
-			auto res = cli.Get();
+			auto res = Http.Get("/test/hello"sv);
 			++RequestCount;
 		}
+
 		ZEN_INFO("query batch {} ended (thread {})", BatchNo, ThreadId);
 	};
 
@@ -306,14 +303,10 @@ TEST_CASE("project.basic")
 
 	const uint16_t PortNumber = Instance1.SpawnServerAndWaitUntilReady();
 
-	std::atomic<uint64_t> RequestCount{0};
-
-	zen::Stopwatch timer;
-
 	std::mt19937_64 mt;
 
 	zen::StringBuilder<64> BaseUri;
-	BaseUri << fmt::format("http://localhost:{}/prj/test", PortNumber);
+	BaseUri << fmt::format("http://localhost:{}", PortNumber);
 
 	std::filesystem::path BinPath  = zen::GetRunningExecutablePath();
 	std::filesystem::path RootPath = BinPath.parent_path().parent_path();
@@ -322,6 +315,8 @@ TEST_CASE("project.basic")
 	SUBCASE("build store init")
 	{
 		{
+			HttpClient Http{BaseUri};
+
 			{
 				zen::CbObjectWriter Body;
 				Body << "id"
@@ -333,38 +328,38 @@ TEST_CASE("project.basic")
 					 << "/zooom";
 
 				zen::BinaryWriter MemOut;
-				Body.Save(MemOut);
+				IoBuffer		  BodyBuf = Body.Save().GetBuffer().AsIoBuffer();
 
-				auto Response = cpr::Post(cpr::Url{BaseUri.c_str()}, cpr::Body{(const char*)MemOut.Data(), MemOut.Size()});
-				CHECK(Response.status_code == 201);
+				auto Response = Http.Post("/prj/test"sv, BodyBuf);
+				CHECK(Response.StatusCode == HttpResponseCode::Created);
 			}
 
 			{
-				auto Response = cpr::Get(cpr::Url{BaseUri.c_str()});
-				CHECK(Response.status_code == 200);
+				auto Response = Http.Get("/prj/test"sv);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
 
-				zen::CbObjectView ResponseObject = zen::CbFieldView(Response.text.data()).AsObjectView();
+				CbObject ResponseObject = Response.AsObject();
 
 				CHECK(ResponseObject["id"].AsString() == "test"sv);
 				CHECK(ResponseObject["root"].AsString() == PathToUtf8(RootPath.c_str()));
 			}
 		}
 
-		BaseUri << "/oplog/foobar";
+		BaseUri << "/prj/test/oplog/foobar";
 
 		{
+			HttpClient Http{BaseUri};
+
 			{
-				zen::StringBuilder<64> PostUri;
-				PostUri << BaseUri;
-				auto Response = cpr::Post(cpr::Url{PostUri.c_str()});
-				CHECK(Response.status_code == 201);
+				auto Response = Http.Post(""sv);
+				CHECK(Response.StatusCode == HttpResponseCode::Created);
 			}
 
 			{
-				auto Response = cpr::Get(cpr::Url{BaseUri.c_str()});
-				CHECK(Response.status_code == 200);
+				auto Response = Http.Get(""sv);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
 
-				zen::CbObjectView ResponseObject = zen::CbFieldView(Response.text.data()).AsObjectView();
+				CbObject ResponseObject = Response.AsObject();
 
 				CHECK(ResponseObject["id"].AsString() == "foobar"sv);
 				CHECK(ResponseObject["project"].AsString() == "test"sv);
@@ -406,34 +401,34 @@ TEST_CASE("project.basic")
 			zen::BinaryWriter MemOut;
 			legacy::SaveCbPackage(OpPackage, MemOut);
 
+			HttpClient Http{BaseUri};
+
 			{
-				zen::StringBuilder<64> PostUri;
-				PostUri << BaseUri << "/new";
-				auto Response = cpr::Post(cpr::Url{PostUri.c_str()}, cpr::Body{(const char*)MemOut.Data(), MemOut.Size()});
+				auto Response = Http.Post("/new", IoBufferBuilder::MakeFromMemory(MemOut.GetView()));
 
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 201);
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::Created);
 			}
 
 			// Read file data
 
 			{
 				zen::StringBuilder<128> ChunkGetUri;
-				ChunkGetUri << BaseUri << "/" << ChunkId;
-				auto Response = cpr::Get(cpr::Url{ChunkGetUri.c_str()});
+				ChunkGetUri << "/" << ChunkId;
+				auto Response = Http.Get(ChunkGetUri);
 
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 200);
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
 			}
 
 			{
 				zen::StringBuilder<128> ChunkGetUri;
-				ChunkGetUri << BaseUri << "/" << ChunkId << "?offset=1&size=10";
-				auto Response = cpr::Get(cpr::Url{ChunkGetUri.c_str()});
+				ChunkGetUri << "/" << ChunkId << "?offset=1&size=10";
+				auto Response = Http.Get(ChunkGetUri);
 
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 200);
-				CHECK(Response.text.size() == 10);
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
+				CHECK(Response.ResponsePayload.GetSize() == 10);
 			}
 
 			ZEN_INFO("+++++++");
@@ -467,49 +462,47 @@ TEST_CASE("project.basic")
 			zen::BinaryWriter MemOut;
 			legacy::SaveCbPackage(OpPackage, MemOut);
 
+			HttpClient Http{BaseUri};
+
 			{
-				zen::StringBuilder<64> PostUri;
-				PostUri << BaseUri << "/new";
-				auto Response = cpr::Post(cpr::Url{PostUri.c_str()}, cpr::Body{(const char*)MemOut.Data(), MemOut.Size()});
+				auto Response = Http.Post("/new", IoBufferBuilder::MakeFromMemory(MemOut.GetView()));
 
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 201);
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::Created);
 			}
 
 			// Read file data, it is raw and uncompressed
 			{
 				zen::StringBuilder<128> ChunkGetUri;
-				ChunkGetUri << BaseUri << "/" << ChunkId;
-				auto Response = cpr::Get(cpr::Url{ChunkGetUri.c_str()});
+				ChunkGetUri << "/" << ChunkId;
+				auto Response = Http.Get(ChunkGetUri);
 
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 200);
-				IoBuffer Data(IoBuffer::Wrap, Response.text.data(), Response.text.length());
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
+
+				IoBuffer Data		   = Response.ResponsePayload;
 				IoBuffer ReferenceData = IoBufferBuilder::MakeFromFile(RootPath / BinPath);
 				CHECK(ReferenceData.GetSize() == Data.GetSize());
 				CHECK(ReferenceData.GetView().EqualBytes(Data.GetView()));
 			}
 
 			{
-				IoBuffer Payload = MakeCbObjectPayload([&](CbObjectWriter& Writer) { Writer.AddString("method"sv, "snapshot"sv); });
-				zen::StringBuilder<64> PostUri;
-				PostUri << BaseUri << "/rpc";
-				auto Response = cpr::Post(cpr::Url{PostUri.c_str()},
-										  cpr::Body{(const char*)Payload.Data(), Payload.Size()},
-										  cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 200);
+				IoBuffer Payload  = MakeCbObjectPayload([&](CbObjectWriter& Writer) { Writer.AddString("method"sv, "snapshot"sv); });
+				auto	 Response = Http.Post("/rpc"sv, Payload, {{"Content-Type", "application/x-ue-cb"}});
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
 			}
 
 			// Read chunk data, it is now compressed
 			{
 				zen::StringBuilder<128> ChunkGetUri;
-				ChunkGetUri << BaseUri << "/" << ChunkId;
-				auto Response = cpr::Get(cpr::Url{ChunkGetUri.c_str()}, cpr::Header{{"Accept-Type", "application/x-ue-comp"}});
+				ChunkGetUri << "/" << ChunkId;
+				auto Response = Http.Get(ChunkGetUri, {{"Accept-Type", "application/x-ue-comp"}});
+
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
 
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 200);
-				IoBuffer		 Data(IoBuffer::Wrap, Response.text.data(), Response.text.length());
+				IoBuffer		 Data = Response.ResponsePayload;
 				IoHash			 RawHash;
 				uint64_t		 RawSize;
 				CompressedBuffer Compressed = CompressedBuffer::FromCompressed(SharedBuffer(Data), RawHash, RawSize);
@@ -526,24 +519,19 @@ TEST_CASE("project.basic")
 
 		SUBCASE("test chunk not found error")
 		{
+			HttpClient Http{BaseUri};
+
 			for (size_t I = 0; I < 65; I++)
 			{
 				zen::StringBuilder<128> PostUri;
-				PostUri << BaseUri << "/f77c781846caead318084604/info";
-				auto Response = cpr::Get(cpr::Url{PostUri.c_str()});
+				PostUri << "/f77c781846caead318084604/info";
+				auto Response = Http.Get(PostUri);
 
-				REQUIRE(!Response.error);
-				CHECK(Response.status_code == 404);
+				REQUIRE(!Response.Error);
+				CHECK(Response.StatusCode == HttpResponseCode::NotFound);
 			}
 		}
 	}
-
-	const uint64_t Elapsed = timer.GetElapsedTimeMs();
-
-	ZEN_INFO("{} requests in {} ({})",
-			 RequestCount.load(),
-			 zen::NiceTimeSpanMs(Elapsed),
-			 zen::NiceRate(RequestCount, (uint32_t)Elapsed, "req"));
 }
 
 namespace utils {
@@ -664,33 +652,32 @@ TEST_CASE("zcache.basic")
 
 		// Populate with some simple data
 
+		HttpClient Http{BaseUri};
+
 		for (int i = 0; i < kIterationCount; ++i)
 		{
 			zen::CbObjectWriter Cbo;
 			Cbo << "index" << i;
 
-			zen::BinaryWriter MemOut;
-			Cbo.Save(MemOut);
+			IoBuffer Payload = Cbo.Save().GetBuffer().AsIoBuffer();
+			Payload.SetContentType(HttpContentType::kCbObject);
 
 			zen::IoHash Key = HashKey(i);
 
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", BaseUri, "test", Key)},
-											cpr::Body{(const char*)MemOut.Data(), MemOut.Size()},
-											cpr::Header{{"Content-Type", "application/x-ue-cb"}});
+			HttpClient::Response Result = Http.Put(fmt::format("/test/{}", Key), Payload);
 
-			CHECK(Result.status_code == 201);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		// Retrieve data
 
 		for (int i = 0; i < kIterationCount; ++i)
 		{
-			zen::IoHash Key = zen::IoHash::HashBuffer(&i, sizeof i);
+			zen::IoHash Key = HashKey(i);
 
-			cpr::Response Result =
-				cpr::Get(cpr::Url{fmt::format("{}/{}/{}", BaseUri, "test", Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			HttpClient::Response Result = Http.Get(fmt::format("/test/{}", Key), {{"Accept", "application/x-ue-cbpkg"}});
 
-			CHECK(Result.status_code == 200);
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 
 		// Ensure bad bucket identifiers are rejected
@@ -699,16 +686,14 @@ TEST_CASE("zcache.basic")
 			zen::CbObjectWriter Cbo;
 			Cbo << "index" << 42;
 
-			zen::BinaryWriter MemOut;
-			Cbo.Save(MemOut);
+			IoBuffer Payload = Cbo.Save().GetBuffer().AsIoBuffer();
+			Payload.SetContentType(HttpContentType::kCbObject);
 
 			zen::IoHash Key = HashKey(442);
 
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", BaseUri, "te!st", Key)},
-											cpr::Body{(const char*)MemOut.Data(), MemOut.Size()},
-											cpr::Header{{"Content-Type", "application/x-ue-cb"}});
+			HttpClient::Response Result = Http.Put(fmt::format("/te!st/{}", Key), Payload);
 
-			CHECK(Result.status_code == 400);
+			CHECK(Result.StatusCode == HttpResponseCode::BadRequest);
 		}
 	}
 
@@ -721,20 +706,33 @@ TEST_CASE("zcache.basic")
 
 		const std::string BaseUri = fmt::format("http://localhost:{}/z$", PortNumber);
 
+		HttpClient Http{BaseUri};
+
 		// Retrieve data again
 
 		for (int i = 0; i < kIterationCount; ++i)
 		{
 			zen::IoHash Key = HashKey(i);
 
-			cpr::Response Result =
-				cpr::Get(cpr::Url{fmt::format("{}/{}/{}", BaseUri, "test", Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			HttpClient::Response Result = Http.Get(fmt::format("/{}/{}", "test", Key), {{"Accept", "application/x-ue-cbpkg"}});
 
-			CHECK(Result.status_code == 200);
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 	}
 }
 
+IoBuffer
+SerializeToBuffer(const zen::CbPackage& Package)
+{
+	BinaryWriter MemStream;
+
+	Package.Save(MemStream);
+
+	IoBuffer Buffer = zen::IoBuffer(zen::IoBuffer::Clone, MemStream.Data(), MemStream.Size());
+	Buffer.SetContentType(HttpContentType::kCbPackage);
+	return Buffer;
+};
+
 TEST_CASE("zcache.cbpackage")
 {
 	using namespace std::literals;
@@ -757,14 +755,6 @@ TEST_CASE("zcache.cbpackage")
 		return Package;
 	};
 
-	auto SerializeToBuffer = [](zen::CbPackage Package) -> zen::IoBuffer {
-		zen::BinaryWriter MemStream;
-
-		Package.Save(MemStream);
-
-		return zen::IoBuffer(zen::IoBuffer::Clone, MemStream.Data(), MemStream.Size());
-	};
-
 	auto IsEqual = [](zen::CbPackage Lhs, zen::CbPackage Rhs) -> bool {
 		std::span<const zen::CbAttachment> LhsAttachments = Lhs.GetAttachments();
 		std::span<const zen::CbAttachment> RhsAttachments = Rhs.GetAttachments();
@@ -803,29 +793,26 @@ TEST_CASE("zcache.cbpackage")
 		const uint16_t	  PortNumber = Instance1.SpawnServerAndWaitUntilReady();
 		const std::string BaseUri	 = fmt::format("http://localhost:{}/z$", PortNumber);
 
+		HttpClient Http{BaseUri};
+
 		const std::string_view Bucket = "mosdef"sv;
 		zen::IoHash			   Key;
 		zen::CbPackage		   ExpectedPackage = CreateTestPackage(Key);
 
 		// PUT
 		{
-			zen::IoBuffer Body	 = SerializeToBuffer(ExpectedPackage);
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)Body.Data(), Body.Size()},
-											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 201);
+			zen::IoBuffer		 Body	= SerializeToBuffer(ExpectedPackage);
+			HttpClient::Response Result = Http.Put(fmt::format("/{}/{}", Bucket, Key), Body);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		// GET
 		{
-			cpr::Response Result =
-				cpr::Get(cpr::Url{fmt::format("{}/{}/{}", BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
-
-			zen::IoBuffer Response(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
+			HttpClient::Response Result = Http.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 
 			zen::CbPackage Package;
-			const bool	   Ok = Package.TryLoad(Response);
+			const bool	   Ok = Package.TryLoad(Result.ResponsePayload);
 			CHECK(Ok);
 			CHECK(IsEqual(Package, ExpectedPackage));
 		}
@@ -855,38 +842,35 @@ TEST_CASE("zcache.cbpackage")
 		zen::IoHash			   Key;
 		zen::CbPackage		   ExpectedPackage = CreateTestPackage(Key);
 
+		HttpClient LocalHttp{LocalBaseUri};
+		HttpClient RemoteHttp{RemoteBaseUri};
+
 		// Store the cache record package in the local instance
 		{
-			zen::IoBuffer Body	 = SerializeToBuffer(ExpectedPackage);
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", LocalBaseUri, Bucket, Key)},
-											cpr::Body{(const char*)Body.Data(), Body.Size()},
-											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
+			zen::IoBuffer		 Body	= SerializeToBuffer(ExpectedPackage);
+			HttpClient::Response Result = LocalHttp.Put(fmt::format("/{}/{}", Bucket, Key), Body);
 
-			CHECK(Result.status_code == 201);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		// The cache record can be retrieved as a package from the local instance
 		{
-			cpr::Response Result =
-				cpr::Get(cpr::Url{fmt::format("{}/{}/{}", LocalBaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = LocalHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 
-			zen::IoBuffer  Body(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
 			zen::CbPackage Package;
-			const bool	   Ok = Package.TryLoad(Body);
+			const bool	   Ok = Package.TryLoad(Result.ResponsePayload);
 			CHECK(Ok);
 			CHECK(IsEqual(Package, ExpectedPackage));
 		}
 
 		// The cache record can be retrieved as a package from the remote instance
 		{
-			cpr::Response Result =
-				cpr::Get(cpr::Url{fmt::format("{}/{}/{}", RemoteBaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = RemoteHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 
-			zen::IoBuffer  Body(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
 			zen::CbPackage Package;
-			const bool	   Ok = Package.TryLoad(Body);
+			const bool	   Ok = Package.TryLoad(Result.ResponsePayload);
 			CHECK(Ok);
 			CHECK(IsEqual(Package, ExpectedPackage));
 		}
@@ -912,29 +896,28 @@ TEST_CASE("zcache.cbpackage")
 		const auto LocalBaseUri	 = fmt::format("http://localhost:{}/z$", LocalPortNumber);
 		const auto RemoteBaseUri = fmt::format("http://localhost:{}/z$", RemotePortNumber);
 
+		HttpClient LocalHttp{LocalBaseUri};
+		HttpClient RemoteHttp{RemoteBaseUri};
+
 		const std::string_view Bucket = "mosdef"sv;
 		zen::IoHash			   Key;
 		zen::CbPackage		   ExpectedPackage = CreateTestPackage(Key);
 
 		// Store the cache record package in upstream cache
 		{
-			zen::IoBuffer Body	 = SerializeToBuffer(ExpectedPackage);
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", RemoteBaseUri, Bucket, Key)},
-											cpr::Body{(const char*)Body.Data(), Body.Size()},
-											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
+			zen::IoBuffer		 Body	= SerializeToBuffer(ExpectedPackage);
+			HttpClient::Response Result = RemoteHttp.Put(fmt::format("/{}/{}", Bucket, Key), Body);
 
-			CHECK(Result.status_code == 201);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		// The cache record can be retrieved as a package from the local cache
 		{
-			cpr::Response Result =
-				cpr::Get(cpr::Url{fmt::format("{}/{}/{}", LocalBaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = LocalHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 
-			zen::IoBuffer  Body(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
 			zen::CbPackage Package;
-			const bool	   Ok = Package.TryLoad(Body);
+			const bool	   Ok = Package.TryLoad(Result.ResponsePayload);
 			CHECK(Ok);
 			CHECK(IsEqual(Package, ExpectedPackage));
 		}
@@ -946,7 +929,7 @@ TEST_CASE("zcache.policy")
 	using namespace std::literals;
 	using namespace utils;
 
-	auto GenerateData = [](uint64_t Size, zen::IoHash& OutHash) -> zen::UniqueBuffer {
+	auto GenerateData = [](uint64_t Size, zen::IoHash& OutHash) -> zen::IoBuffer {
 		auto	 Buf  = zen::UniqueBuffer::Alloc(Size);
 		uint8_t* Data = reinterpret_cast<uint8_t*>(Buf.GetData());
 		for (uint64_t Idx = 0; Idx < Size; Idx++)
@@ -954,7 +937,7 @@ TEST_CASE("zcache.policy")
 			Data[Idx] = Idx % 256;
 		}
 		OutHash = zen::IoHash::HashBuffer(Data, Size);
-		return Buf;
+		return Buf.MoveToShared().AsIoBuffer();
 	};
 
 	auto GeneratePackage = [](zen::IoHash& OutRecordKey, zen::IoHash& OutAttachmentKey) -> zen::CbPackage {
@@ -977,13 +960,6 @@ TEST_CASE("zcache.policy")
 		return Package;
 	};
 
-	auto ToBuffer = [](zen::CbPackage Package) -> zen::IoBuffer {
-		zen::BinaryWriter MemStream;
-		Package.Save(MemStream);
-
-		return zen::IoBuffer(zen::IoBuffer::Clone, MemStream.Data(), MemStream.Size());
-	};
-
 	SUBCASE("query - 'local' does not query upstream (binary)")
 	{
 		ZenConfig		  UpstreamCfg = ZenConfig::New(TestEnv.GetNewPortNumber());
@@ -998,26 +974,26 @@ TEST_CASE("zcache.policy")
 		const std::string_view Bucket = "legacy"sv;
 
 		zen::IoHash Key;
-		auto		BinaryValue = GenerateData(1024, Key);
+		IoBuffer	BinaryValue = GenerateData(1024, Key);
+
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient RemoteHttp{UpstreamCfg.BaseUri};
 
-		// Store binary cache value upstream
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", UpstreamCfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)BinaryValue.GetData(), BinaryValue.GetSize()},
-											cpr::Header{{"Content-Type", "application/octet-stream"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = RemoteHttp.Put(fmt::format("/{}/{}", Bucket, Key), BinaryValue);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}?Policy=QueryLocal,Store", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/octet-stream"}});
-			CHECK(Result.status_code == 404);
+			HttpClient::Response Result =
+				LocalHttp.Get(fmt::format("/{}/{}?Policy=QueryLocal,Store", Bucket, Key), {{"Accept", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::NotFound);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}?Policy=Query,Store", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/octet-stream"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result =
+				LocalHttp.Get(fmt::format("/{}/{}?Policy=Query,Store", Bucket, Key), {{"Accept", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 	}
 
@@ -1035,26 +1011,27 @@ TEST_CASE("zcache.policy")
 		const auto Bucket = "legacy"sv;
 
 		zen::IoHash Key;
-		auto		BinaryValue = GenerateData(1024, Key);
+		IoBuffer	BinaryValue = GenerateData(1024, Key);
+
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient RemoteHttp{UpstreamCfg.BaseUri};
 
 		// Store binary cache value locally
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}?Policy=Query,StoreLocal", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)BinaryValue.GetData(), BinaryValue.GetSize()},
-											cpr::Header{{"Content-Type", "application/octet-stream"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = LocalHttp.Put(fmt::format("/{}/{}?Policy=Query,StoreLocal", Bucket, Key),
+														BinaryValue,
+														{{"Content-Type", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", UpstreamCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/octet-stream"}});
-			CHECK(Result.status_code == 404);
+			HttpClient::Response Result = RemoteHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::NotFound);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/octet-stream"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = LocalHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 	}
 
@@ -1071,30 +1048,31 @@ TEST_CASE("zcache.policy")
 		const auto Bucket = "legacy"sv;
 
 		zen::IoHash Key;
-		auto		BinaryValue = GenerateData(1024, Key);
+		IoBuffer	BinaryValue = GenerateData(1024, Key);
+
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient RemoteHttp{UpstreamCfg.BaseUri};
 
 		// Store binary cache value locally and upstream
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}?Policy=Query,Store", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)BinaryValue.GetData(), BinaryValue.GetSize()},
-											cpr::Header{{"Content-Type", "application/octet-stream"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = LocalHttp.Put(fmt::format("/{}/{}?Policy=Query,Store", Bucket, Key),
+														BinaryValue,
+														{{"Content-Type", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", UpstreamCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/octet-stream"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = RemoteHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/octet-stream"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = LocalHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/octet-stream"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 	}
 
-	SUBCASE("query - 'local' does not query upstream (cppackage)")
+	SUBCASE("query - 'local' does not query upstream (cbpackage)")
 	{
 		ZenConfig		  UpstreamCfg = ZenConfig::New(TestEnv.GetNewPortNumber());
 		ZenServerInstance UpstreamInst(TestEnv);
@@ -1109,30 +1087,31 @@ TEST_CASE("zcache.policy")
 		zen::IoHash	   Key;
 		zen::IoHash	   PayloadId;
 		zen::CbPackage Package = GeneratePackage(Key, PayloadId);
-		auto		   Buf	   = ToBuffer(Package);
+		IoBuffer	   Buf	   = SerializeToBuffer(Package);
+
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient RemoteHttp{UpstreamCfg.BaseUri};
 
 		// Store package upstream
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", UpstreamCfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
-											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = RemoteHttp.Put(fmt::format("/{}/{}", Bucket, Key), Buf);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}?Policy=QueryLocal,Store", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 404);
+			HttpClient::Response Result =
+				LocalHttp.Get(fmt::format("/{}/{}?Policy=QueryLocal,Store", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::NotFound);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}?Policy=Query,Store", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result =
+				LocalHttp.Get(fmt::format("/{}/{}?Policy=Query,Store", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 	}
 
-	SUBCASE("store - 'local' does not store upstream (cbpackge)")
+	SUBCASE("store - 'local' does not store upstream (cbpackage)")
 	{
 		ZenConfig		  UpstreamCfg = ZenConfig::New(TestEnv.GetNewPortNumber());
 		ZenServerInstance UpstreamInst(TestEnv);
@@ -1147,26 +1126,25 @@ TEST_CASE("zcache.policy")
 		zen::IoHash	   Key;
 		zen::IoHash	   PayloadId;
 		zen::CbPackage Package = GeneratePackage(Key, PayloadId);
-		auto		   Buf	   = ToBuffer(Package);
+		IoBuffer	   Buf	   = SerializeToBuffer(Package);
 
-		// Store packge locally
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient RemoteHttp{UpstreamCfg.BaseUri};
+
+		// Store package locally
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}?Policy=Query,StoreLocal", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
-											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = LocalHttp.Put(fmt::format("/{}/{}?Policy=Query,StoreLocal", Bucket, Key), Buf);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", UpstreamCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 404);
+			HttpClient::Response Result = RemoteHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::NotFound);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = LocalHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 	}
 
@@ -1185,26 +1163,25 @@ TEST_CASE("zcache.policy")
 		zen::IoHash	   Key;
 		zen::IoHash	   PayloadId;
 		zen::CbPackage Package = GeneratePackage(Key, PayloadId);
-		auto		   Buf	   = ToBuffer(Package);
+		IoBuffer	   Buf	   = SerializeToBuffer(Package);
+
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient RemoteHttp{UpstreamCfg.BaseUri};
 
 		// Store package locally and upstream
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}?Policy=Query,Store", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
-											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = LocalHttp.Put(fmt::format("/{}/{}?Policy=Query,Store", Bucket, Key), Buf);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", UpstreamCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = RemoteHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}", LocalCfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 200);
+			HttpClient::Response Result = LocalHttp.Get(fmt::format("/{}/{}", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 		}
 	}
 
@@ -1219,44 +1196,41 @@ TEST_CASE("zcache.policy")
 		zen::IoHash	   Key;
 		zen::IoHash	   PayloadId;
 		zen::CbPackage Package = GeneratePackage(Key, PayloadId);
-		auto		   Buf	   = ToBuffer(Package);
+		IoBuffer	   Buf	   = SerializeToBuffer(Package);
+
+		HttpClient Http{Cfg.BaseUri};
 
 		// Store package
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", Cfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
-											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = Http.Put(fmt::format("/{}/{}", Bucket, Key), Buf);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		// Get package
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}?Policy=Default,SkipData", Cfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
-			CHECK(IsHttpSuccessCode(Result.status_code));
-			IoBuffer  Buffer(IoBuffer::Wrap, Result.text.c_str(), Result.text.size());
+			HttpClient::Response Result =
+				Http.Get(fmt::format("/{}/{}?Policy=Default,SkipData", Bucket, Key), {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result);
 			CbPackage ResponsePackage;
-			CHECK(ResponsePackage.TryLoad(Buffer));
+			CHECK(ResponsePackage.TryLoad(Result.ResponsePayload));
 			CHECK(ResponsePackage.GetAttachments().size() == 0);
 		}
 
 		// Get record
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}?Policy=Default,SkipData", Cfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/x-ue-cb"}});
-			CHECK(IsHttpSuccessCode(Result.status_code));
-			IoBuffer Buffer(IoBuffer::Wrap, Result.text.c_str(), Result.text.size());
-			CbObject ResponseObject = zen::LoadCompactBinaryObject(Buffer);
-			CHECK((bool)ResponseObject);
+			HttpClient::Response Result =
+				Http.Get(fmt::format("/{}/{}?Policy=Default,SkipData", Bucket, Key), {{"Accept", "application/x-ue-cb"}});
+			CHECK(Result);
+			CbObject ResponseObject = zen::LoadCompactBinaryObject(Result.ResponsePayload);
+			CHECK(ResponseObject);
 		}
 
 		// Get payload
 		{
-			cpr::Response Result =
-				cpr::Get(cpr::Url{fmt::format("{}/{}/{}/{}?Policy=Default,SkipData", Cfg.BaseUri, Bucket, Key, PayloadId)},
-						 cpr::Header{{"Accept", "application/x-ue-comp"}});
-			CHECK(IsHttpSuccessCode(Result.status_code));
-			CHECK(Result.text.size() == 0);
+			HttpClient::Response Result =
+				Http.Get(fmt::format("/{}/{}/{}?Policy=Default,SkipData", Bucket, Key, PayloadId), {{"Accept", "application/x-ue-comp"}});
+			CHECK(Result);
+			CHECK(Result.ResponsePayload.GetSize() == 0);
 		}
 	}
 
@@ -1269,22 +1243,22 @@ TEST_CASE("zcache.policy")
 		const auto Bucket = "test"sv;
 
 		zen::IoHash Key;
-		auto		BinaryValue = GenerateData(1024, Key);
+		IoBuffer	BinaryValue = GenerateData(1024, Key);
+
+		HttpClient Http{Cfg.BaseUri};
 
 		// Store binary cache value
 		{
-			cpr::Response Result = cpr::Put(cpr::Url{fmt::format("{}/{}/{}", Cfg.BaseUri, Bucket, Key)},
-											cpr::Body{(const char*)BinaryValue.GetData(), BinaryValue.GetSize()},
-											cpr::Header{{"Content-Type", "application/octet-stream"}});
-			CHECK(Result.status_code == 201);
+			HttpClient::Response Result = Http.Put(fmt::format("/{}/{}", Bucket, Key), BinaryValue);
+			CHECK(Result.StatusCode == HttpResponseCode::Created);
 		}
 
 		// Get package
 		{
-			cpr::Response Result = cpr::Get(cpr::Url{fmt::format("{}/{}/{}?Policy=Default,SkipData", Cfg.BaseUri, Bucket, Key)},
-											cpr::Header{{"Accept", "application/octet-stream"}});
-			CHECK(IsHttpSuccessCode(Result.status_code));
-			CHECK(Result.text.size() == 0);
+			HttpClient::Response Result =
+				Http.Get(fmt::format("/{}/{}?Policy=Default,SkipData", Bucket, Key), {{"Accept", "application/octet-stream"}});
+			CHECK(Result);
+			CHECK(Result.ResponsePayload.GetSize() == 0);
 		}
 	}
 }
@@ -1323,6 +1297,8 @@ TEST_CASE("zcache.rpc")
 												std::vector<CbPackage>* OutPackages = nullptr) -> std::vector<CacheKey> {
 		std::vector<zen::CacheKey> OutKeys;
 
+		HttpClient Http{BaseUri};
+
 		for (uint32_t Key = 1; Key <= Num; ++Key)
 		{
 			zen::IoHash KeyHash;
@@ -1336,12 +1312,11 @@ TEST_CASE("zcache.rpc")
 			CbPackage Package;
 			CHECK(Request.Format(Package));
 
-			IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-			cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-											 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-											 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+			IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+			Body.SetContentType(HttpContentType::kCbPackage);
+			HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
-			CHECK(Result.status_code == 200);
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 			if (OutPackages)
 			{
 				OutPackages->emplace_back(std::move(Package));
@@ -1377,18 +1352,18 @@ TEST_CASE("zcache.rpc")
 		CbObjectWriter RequestWriter;
 		CHECK(Request.Format(RequestWriter));
 
-		BinaryWriter Body;
-		RequestWriter.Save(Body);
+		IoBuffer Body = RequestWriter.Save().GetBuffer().AsIoBuffer();
+		Body.SetContentType(HttpContentType::kCbObject);
 
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cb"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+		HttpClient Http{BaseUri};
+
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
 		GetCacheRecordResult OutResult;
 
-		if (Result.status_code == 200)
+		if (Result.StatusCode == HttpResponseCode::OK)
 		{
-			CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+			CbPackage Response = ParsePackageMessage(Result.ResponsePayload);
 			CHECK(!Response.IsNull());
 			OutResult.Response = std::move(Response);
 			CHECK(OutResult.Result.Parse(OutResult.Response));
@@ -1542,6 +1517,9 @@ TEST_CASE("zcache.rpc")
 		const size_t			   NumRecords = 4;
 		std::vector<zen::CacheKey> Keys		  = PutCacheRecords(LocalCfg.BaseUri, Namespace, Bucket, NumRecords, PayloadSize);
 
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient UpstreamHttp{UpstreamCfg.BaseUri};
+
 		for (const zen::CacheKey& CacheKey : Keys)
 		{
 			cacherequests::PutCacheRecordsRequest Request = {.AcceptMagic = kCbPkgMagic, .Namespace = std::string(Namespace)};
@@ -1550,14 +1528,13 @@ TEST_CASE("zcache.rpc")
 			CbPackage Package;
 			CHECK(Request.Format(Package));
 
-			IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-			cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", LocalCfg.BaseUri)},
-											 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-											 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+			IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+			Body.SetContentType(HttpContentType::kCbPackage);
+			HttpClient::Response Result = LocalHttp.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
-			CHECK(Result.status_code == 200);
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 			cacherequests::PutCacheRecordsResult ParsedResult;
-			CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+			CbPackage							 Response = ParsePackageMessage(Result.ResponsePayload);
 			CHECK(!Response.IsNull());
 			CHECK(ParsedResult.Parse(Response));
 			for (bool ResponseSuccess : ParsedResult.Success)
@@ -1610,6 +1587,9 @@ TEST_CASE("zcache.rpc")
 		const size_t			   NumRecords = 4;
 		std::vector<zen::CacheKey> Keys		  = PutCacheRecords(LocalCfg.BaseUri, Namespace, Bucket, NumRecords, PayloadSize);
 
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient UpstreamHttp{UpstreamCfg.BaseUri};
+
 		for (const zen::CacheKey& CacheKey : Keys)
 		{
 			cacherequests::PutCacheRecordsRequest Request = {.AcceptMagic = kCbPkgMagic, .Namespace = std::string(Namespace)};
@@ -1618,14 +1598,14 @@ TEST_CASE("zcache.rpc")
 			CbPackage Package;
 			CHECK(Request.Format(Package));
 
-			IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-			cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", LocalCfg.BaseUri)},
-											 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-											 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+			IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+			Body.SetContentType(HttpContentType::kCbPackage);
+
+			HttpClient::Response Result = LocalHttp.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
-			CHECK(Result.status_code == 200);
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 			cacherequests::PutCacheRecordsResult ParsedResult;
-			CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+			CbPackage							 Response = ParsePackageMessage(Result.ResponsePayload);
 			CHECK(!Response.IsNull());
 			CHECK(ParsedResult.Parse(Response));
 			CHECK(Request.Requests.size() == ParsedResult.Success.size());
@@ -1680,6 +1660,9 @@ TEST_CASE("zcache.rpc")
 		ZenServerInstance LocalServer(TestEnv);
 		SpawnServer(LocalServer, LocalCfg);
 
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient UpstreamHttp{UpstreamCfg.BaseUri};
+
 		size_t					   PayloadSize = 1024;
 		std::string_view		   Namespace("ue4.ddc"sv);
 		std::string_view		   Bucket("mastodon"sv);
@@ -1694,14 +1677,13 @@ TEST_CASE("zcache.rpc")
 			CbPackage Package;
 			CHECK(Request.Format(Package));
 
-			IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-			cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", LocalCfg.BaseUri)},
-											 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-											 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+			IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+			Body.SetContentType(HttpContentType::kCbPackage);
+			HttpClient::Response Result = LocalHttp.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
-			CHECK(Result.status_code == 200);
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 			cacherequests::PutCacheRecordsResult ParsedResult;
-			CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+			CbPackage							 Response = ParsePackageMessage(Result.ResponsePayload);
 			CHECK(!Response.IsNull());
 			CHECK(ParsedResult.Parse(Response));
 			for (bool ResponseSuccess : ParsedResult.Success)
@@ -1748,6 +1730,9 @@ TEST_CASE("zcache.rpc")
 		ZenServerInstance LocalServer(TestEnv);
 		SpawnServer(LocalServer, LocalCfg);
 
+		HttpClient LocalHttp{LocalCfg.BaseUri};
+		HttpClient UpstreamHttp{UpstreamCfg.BaseUri};
+
 		size_t					   PayloadSize = 1024;
 		std::string_view		   Namespace("ue4.ddc"sv);
 		std::string_view		   Bucket("mastodon"sv);
@@ -1758,14 +1743,13 @@ TEST_CASE("zcache.rpc")
 
 		for (const CbPackage& Package : Packages)
 		{
-			IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-			cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", LocalCfg.BaseUri)},
-											 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-											 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+			IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+			Body.SetContentType(HttpContentType::kCbPackage);
+			HttpClient::Response Result = LocalHttp.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
-			CHECK(Result.status_code == 200);
+			CHECK(Result.StatusCode == HttpResponseCode::OK);
 			cacherequests::PutCacheRecordsResult ParsedResult;
-			CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+			CbPackage							 Response = ParsePackageMessage(Result.ResponsePayload);
 			CHECK(!Response.IsNull());
 			CHECK(ParsedResult.Parse(Response));
 			for (bool ResponseSuccess : ParsedResult.Success)
@@ -2082,14 +2066,14 @@ TEST_CASE("zcache.failing.upstream")
 		CbPackage Package;
 		CHECK(Request.Format(Package));
 
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+		HttpClient Http{BaseUri};
+
+		IoBuffer			 Body	= FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
-		if (Result.status_code != 200)
+		if (Result.StatusCode != HttpResponseCode::OK)
 		{
-			ZEN_DEBUG("PutCacheRecords failed with {}, reason '{}'", Result.status_code, Result.reason);
+			ZEN_DEBUG("PutCacheRecords failed with {}, reason '{}'", ToString(Result.StatusCode), Result.ErrorMessage(""));
 			OutKeys.clear();
 		}
 
@@ -2118,18 +2102,18 @@ TEST_CASE("zcache.failing.upstream")
 		CbObjectWriter RequestWriter;
 		CHECK(Request.Format(RequestWriter));
 
-		BinaryWriter Body;
-		RequestWriter.Save(Body);
+		IoBuffer Body = RequestWriter.Save().GetBuffer().AsIoBuffer();
+		Body.SetContentType(HttpContentType::kCbObject);
 
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cb"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+		HttpClient Http{BaseUri};
+
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
 		GetCacheRecordResult OutResult;
 
-		if (Result.status_code == 200)
+		if (Result.StatusCode == HttpResponseCode::OK)
 		{
-			CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+			CbPackage Response = ParsePackageMessage(Result.ResponsePayload);
 			if (!Response.IsNull())
 			{
 				OutResult.Response = std::move(Response);
@@ -2139,7 +2123,7 @@ TEST_CASE("zcache.failing.upstream")
 		}
 		else
 		{
-			ZEN_DEBUG("GetCacheRecords with {}, reason '{}'", Result.reason, Result.status_code);
+			ZEN_DEBUG("GetCacheRecords with {}, reason '{}'", ToString(Result.StatusCode), Result.ErrorMessage(""));
 		}
 
 		return OutResult;
@@ -2339,14 +2323,16 @@ TEST_CASE("zcache.rpc.partialchunks")
 		CbPackage Package;
 		CHECK(Request.Format(Package));
 
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+		HttpClient Http{BaseUri};
+
+		IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+		Body.SetContentType(HttpContentType::kCbPackage);
 
-		if (Result.status_code != 200)
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
+
+		if (Result.StatusCode != HttpResponseCode::OK)
 		{
-			ZEN_DEBUG("PutCacheRecords failed with {}, reason '{}'", Result.status_code, Result.reason);
+			ZEN_DEBUG("PutCacheRecords failed with {}, reason '{}'", ToString(Result.StatusCode), Result.ErrorMessage(""));
 			Keys.clear();
 		}
 
@@ -2379,14 +2365,16 @@ TEST_CASE("zcache.rpc.partialchunks")
 			.Requests	   = {{.Key = Key, .ValueId = ValueId, .RawOffset = Options.Offset, .RawSize = Options.Size}}};
 		CbPackage Package;
 		CHECK(Request.Format(Package));
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
+		IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+		Body.SetContentType(HttpContentType::kCbPackage);
+
+		HttpClient Http{BaseUri};
 
-		CHECK(Result.status_code == 200);
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
 
-		CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+		CHECK(Result.StatusCode == HttpResponseCode::OK);
+
+		CbPackage Response = ParsePackageMessage(Result.ResponsePayload);
 		bool	  Loaded   = !Response.IsNull();
 		CHECK_MESSAGE(Loaded, "GetCacheChunks response failed to load.");
 		cacherequests::GetCacheChunksResult GetCacheChunksResult;
@@ -2481,6 +2469,14 @@ TEST_CASE("zcache.rpc.partialchunks")
 										RpcAcceptOptions::kAllowPartialCacheChunks});
 }
 
+IoBuffer
+FormatPackageBody(const CbPackage& Package)
+{
+	IoBuffer Body = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
+	Body.SetContentType(HttpContentType::kCbPackage);
+	return Body;
+}
+
 TEST_CASE("zcache.rpc.allpolicies")
 {
 	using namespace std::literals;
@@ -2495,6 +2491,7 @@ TEST_CASE("zcache.rpc.allpolicies")
 	SpawnServer(LocalServer, LocalCfg);
 
 	const auto BaseUri = fmt::format("http://localhost:{}/z$", LocalServer.GetBasePort());
+	HttpClient Http{BaseUri};
 
 	std::string_view TestVersion   = "F72150A02AE34B57A9EC91D36BA1CE08"sv;
 	std::string_view TestBucket	   = "allpoliciestest"sv;
@@ -2711,11 +2708,9 @@ TEST_CASE("zcache.rpc.allpolicies")
 
 		CbPackage Package;
 		CHECK(Request.Format(Package));
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
-		CHECK_MESSAGE(Result.status_code == 200, "PutCacheRecords unexpectedly failed.");
+		IoBuffer			 Body	= FormatPackageBody(Package);
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
+		CHECK_MESSAGE(Result.StatusCode == HttpResponseCode::OK, "PutCacheRecords unexpectedly failed.");
 	}
 
 	// PutCacheValues
@@ -2735,11 +2730,9 @@ TEST_CASE("zcache.rpc.allpolicies")
 		CbPackage Package;
 		CHECK(Request.Format(Package));
 
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
-		CHECK_MESSAGE(Result.status_code == 200, "PutCacheValues unexpectedly failed.");
+		IoBuffer			 Body	= FormatPackageBody(Package);
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
+		CHECK_MESSAGE(Result.StatusCode == HttpResponseCode::OK, "PutCacheValues unexpectedly failed.");
 	}
 
 	for (KeyData& KeyData : KeyDatas)
@@ -2772,12 +2765,10 @@ TEST_CASE("zcache.rpc.allpolicies")
 
 		CbPackage Package;
 		CHECK(Request.Format(Package));
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
-		CHECK_MESSAGE(Result.status_code == 200, "GetCacheRecords unexpectedly failed.");
-		CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+		IoBuffer			 Body	= FormatPackageBody(Package);
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
+		CHECK_MESSAGE(Result.StatusCode == HttpResponseCode::OK, "GetCacheRecords unexpectedly failed.");
+		CbPackage Response = ParsePackageMessage(Result.ResponsePayload);
 		bool	  Loaded   = !Response.IsNull();
 		CHECK_MESSAGE(Loaded, "GetCacheRecords response failed to load.");
 		cacherequests::GetCacheRecordsResult RequestResult;
@@ -2852,12 +2843,10 @@ TEST_CASE("zcache.rpc.allpolicies")
 		CbPackage Package;
 		CHECK(GetCacheValuesRequest.Format(Package));
 
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
-		CHECK_MESSAGE(Result.status_code == 200, "GetCacheValues unexpectedly failed.");
-		IoBuffer  MessageBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
+		IoBuffer			 Body	= FormatPackageBody(Package);
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
+		CHECK_MESSAGE(Result.StatusCode == HttpResponseCode::OK, "GetCacheValues unexpectedly failed.");
+		IoBuffer  MessageBuffer(Result.ResponsePayload);
 		CbPackage Response = ParsePackageMessage(MessageBuffer);
 		bool	  Loaded   = !Response.IsNull();
 		CHECK_MESSAGE(Loaded, "GetCacheValues response failed to load.");
@@ -2922,12 +2911,10 @@ TEST_CASE("zcache.rpc.allpolicies")
 		CbPackage Package;
 		CHECK(GetCacheChunksRequest.Format(Package));
 
-		IoBuffer	  Body	 = FormatPackageMessageBuffer(Package).Flatten().AsIoBuffer();
-		cpr::Response Result = cpr::Post(cpr::Url{fmt::format("{}/$rpc", BaseUri)},
-										 cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}, {"Accept", "application/x-ue-cbpkg"}},
-										 cpr::Body{(const char*)Body.GetData(), Body.GetSize()});
-		CHECK_MESSAGE(Result.status_code == 200, "GetCacheChunks unexpectedly failed.");
-		CbPackage Response = ParsePackageMessage(zen::IoBuffer(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size()));
+		IoBuffer			 Body	= FormatPackageBody(Package);
+		HttpClient::Response Result = Http.Post("/$rpc", Body, {{"Accept", "application/x-ue-cbpkg"}});
+		CHECK_MESSAGE(Result.StatusCode == HttpResponseCode::OK, "GetCacheChunks unexpectedly failed.");
+		CbPackage Response = ParsePackageMessage(Result.ResponsePayload);
 		bool	  Loaded   = !Response.IsNull();
 		CHECK_MESSAGE(Loaded, "GetCacheChunks response failed to load.");
 		cacherequests::GetCacheChunksResult GetCacheChunksResult;
@@ -3058,20 +3045,23 @@ TEST_CASE("http.basics")
 	ZenServerInstance& Instance = Servers.GetInstance(0);
 	const std::string  BaseUri	= Instance.GetBaseUri();
 
+	HttpClient Http{BaseUri};
+
 	{
-		cpr::Response r = cpr::Get(cpr::Url{fmt::format("{}/testing/hello", BaseUri)});
-		CHECK(IsHttpSuccessCode(r.status_code));
+		HttpClient::Response r = Http.Get("/testing/hello");
+		CHECK(r);
 	}
 
 	{
-		cpr::Response r = cpr::Post(cpr::Url{fmt::format("{}/testing/hello", BaseUri)});
-		CHECK_EQ(r.status_code, 404);
+		HttpClient::Response r = Http.Post("/testing/hello");
+		CHECK_EQ(r.StatusCode, HttpResponseCode::NotFound);
 	}
 
 	{
-		cpr::Response r = cpr::Post(cpr::Url{fmt::format("{}/testing/echo", BaseUri)}, cpr::Body{"yoyoyoyo"});
-		CHECK_EQ(r.status_code, 200);
-		CHECK_EQ(r.text, "yoyoyoyo");
+		IoBuffer			 Body{IoBuffer::Wrap, "yoyoyoyo", 8};
+		HttpClient::Response r = Http.Post("/testing/echo", Body);
+		CHECK_EQ(r.StatusCode, HttpResponseCode::OK);
+		CHECK(r.ResponsePayload.GetView().EqualBytes(Body.GetView()));
 	}
 }
 
@@ -3178,12 +3168,6 @@ CreateOplogOp(const Oid& Id, const std::span<const std::pair<Oid, CompressedBuff
 	return Object.Save();
 };
 
-cpr::Body
-AsBody(const IoBuffer& Payload)
-{
-	return cpr::Body{(const char*)Payload.GetData(), Payload.Size()};
-};
-
 enum CbWriterMeta
 {
 	BeginObject,
@@ -3286,46 +3270,40 @@ TEST_CASE("project.remote")
 		Ops.insert({Id, OpCoreHash});
 	};
 
-	auto MakeProject = [](cpr::Session& Session, std::string_view UrlBase, std::string_view ProjectName) {
+	auto MakeProject = [](std::string_view UrlBase, std::string_view ProjectName) {
 		CbObjectWriter Project;
 		Project.AddString("id"sv, ProjectName);
 		Project.AddString("root"sv, ""sv);
 		Project.AddString("engine"sv, ""sv);
 		Project.AddString("project"sv, ""sv);
 		Project.AddString("projectfile"sv, ""sv);
-		IoBuffer	ProjectPayload = Project.Save().GetBuffer().AsIoBuffer();
-		std::string ProjectRequest = fmt::format("{}/prj/{}", UrlBase, ProjectName);
-		Session.SetUrl({ProjectRequest});
-		Session.SetBody(cpr::Body{(const char*)ProjectPayload.GetData(), ProjectPayload.GetSize()});
-		cpr::Response Response = Session.Post();
-		CHECK(IsHttpSuccessCode(Response.status_code));
+		IoBuffer ProjectPayload = Project.Save().GetBuffer().AsIoBuffer();
+		ProjectPayload.SetContentType(HttpContentType::kCbObject);
+
+		HttpClient			 Http{UrlBase};
+		HttpClient::Response Response = Http.Post(fmt::format("/prj/{}", ProjectName), ProjectPayload);
+		CHECK(Response);
 	};
 
-	auto MakeOplog = [](cpr::Session& Session, std::string_view UrlBase, std::string_view ProjectName, std::string_view OplogName) {
-		std::string CreateOplogRequest = fmt::format("{}/prj/{}/oplog/{}", UrlBase, ProjectName, OplogName);
-		Session.SetUrl({CreateOplogRequest});
-		Session.SetBody(cpr::Body{});
-		cpr::Response Response = Session.Post();
-		CHECK(IsHttpSuccessCode(Response.status_code));
+	auto MakeOplog = [](std::string_view UrlBase, std::string_view ProjectName, std::string_view OplogName) {
+		HttpClient			 Http{UrlBase};
+		HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}", ProjectName, OplogName), IoBuffer{});
+		CHECK(Response);
 	};
 
-	auto MakeOp = [](cpr::Session&	  Session,
-					 std::string_view UrlBase,
-					 std::string_view ProjectName,
-					 std::string_view OplogName,
-					 const CbPackage& OpPackage) {
-		std::string CreateOpRequest = fmt::format("{}/prj/{}/oplog/{}/new", UrlBase, ProjectName, OplogName);
-		Session.SetUrl({CreateOpRequest});
+	auto MakeOp = [](std::string_view UrlBase, std::string_view ProjectName, std::string_view OplogName, const CbPackage& OpPackage) {
 		zen::BinaryWriter MemOut;
 		legacy::SaveCbPackage(OpPackage, MemOut);
-		Session.SetBody(cpr::Body{(const char*)MemOut.Data(), MemOut.Size()});
-		cpr::Response Response = Session.Post();
-		CHECK(IsHttpSuccessCode(Response.status_code));
+		IoBuffer Body{IoBuffer::Wrap, MemOut.GetData(), MemOut.GetSize()};
+		Body.SetContentType(HttpContentType::kCbPackage);
+
+		HttpClient			 Http{UrlBase};
+		HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/new", ProjectName, OplogName), Body);
+		CHECK(Response);
 	};
 
-	cpr::Session Session;
-	MakeProject(Session, Servers.GetInstance(0).GetBaseUri(), "proj0");
-	MakeOplog(Session, Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0");
+	MakeProject(Servers.GetInstance(0).GetBaseUri(), "proj0");
+	MakeOplog(Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0");
 
 	std::unordered_map<Oid, uint32_t, Oid::Hasher> SourceOps;
 	for (const Oid& OpId : OpIds)
@@ -3333,7 +3311,7 @@ TEST_CASE("project.remote")
 		CbPackage OpPackage = CreateOplogPackage(OpId, Attachments[OpId]);
 		CHECK(OpPackage.GetAttachments().size() == Attachments[OpId].size());
 		AddOp(OpPackage.GetObject(), SourceOps);
-		MakeOp(Session, Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0", OpPackage);
+		MakeOp(Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0", OpPackage);
 	}
 
 	std::vector<IoHash> AttachmentHashes;
@@ -3351,47 +3329,45 @@ TEST_CASE("project.remote")
 		Write(Writer);
 		IoBuffer Result = Writer.Save().GetBuffer().AsIoBuffer();
 		Result.MakeOwned();
+		Result.SetContentType(HttpContentType::kCbObject);
 		return Result;
 	};
 
-	auto ValidateAttachments = [&MakeCbObjectPayload, &AttachmentHashes, &Servers, &Session](int			  ServerIndex,
-																							 std::string_view Project,
-																							 std::string_view Oplog) {
-		std::string GetChunksRequest = fmt::format("{}/prj/{}/oplog/{}/rpc", Servers.GetInstance(ServerIndex).GetBaseUri(), Project, Oplog);
-		Session.SetUrl({GetChunksRequest});
-		IoBuffer Payload = MakeCbObjectPayload([&AttachmentHashes](CbObjectWriter& Writer) {
-			Writer << "method"sv
-				   << "getchunks"sv;
-			Writer << "chunks"sv << BeginArray;
-			for (const IoHash& Chunk : AttachmentHashes)
+	auto ValidateAttachments =
+		[&MakeCbObjectPayload, &AttachmentHashes, &Servers](int ServerIndex, std::string_view Project, std::string_view Oplog) {
+			HttpClient Http{Servers.GetInstance(ServerIndex).GetBaseUri()};
+
+			IoBuffer Payload = MakeCbObjectPayload([&AttachmentHashes](CbObjectWriter& Writer) {
+				Writer << "method"sv
+					   << "getchunks"sv;
+				Writer << "chunks"sv << BeginArray;
+				for (const IoHash& Chunk : AttachmentHashes)
+				{
+					Writer << Chunk;
+				}
+				Writer << EndArray;	 // chunks
+			});
+
+			HttpClient::Response Response =
+				Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", Project, Oplog), Payload, {{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Response);
+			CbPackage ResponsePackage = ParsePackageMessage(Response.ResponsePayload);
+			CHECK(ResponsePackage.GetAttachments().size() == AttachmentHashes.size());
+			for (auto A : ResponsePackage.GetAttachments())
 			{
-				Writer << Chunk;
+				CHECK(IoHash::HashBuffer(A.AsCompressedBinary().DecompressToComposite()) == A.GetHash());
 			}
-			Writer << EndArray;	 // chunks
-		});
-		Session.SetBody(AsBody(Payload));
-		Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}, {"Accept", "application/x-ue-cbpkg"}});
-		cpr::Response Response = Session.Post();
-		CHECK(IsHttpSuccessCode(Response.status_code));
-		CbPackage ResponsePackage = ParsePackageMessage(IoBuffer(IoBuffer::Wrap, Response.text.data(), Response.text.size()));
-		CHECK(ResponsePackage.GetAttachments().size() == AttachmentHashes.size());
-		for (auto A : ResponsePackage.GetAttachments())
-		{
-			CHECK(IoHash::HashBuffer(A.AsCompressedBinary().DecompressToComposite()) == A.GetHash());
-		}
-	};
+		};
 
-	auto ValidateOplog = [&SourceOps, &AddOp, &Servers, &Session](int ServerIndex, std::string_view Project, std::string_view Oplog) {
+	auto ValidateOplog = [&SourceOps, &AddOp, &Servers](int ServerIndex, std::string_view Project, std::string_view Oplog) {
 		std::unordered_map<Oid, uint32_t, Oid::Hasher> TargetOps;
 		std::vector<CbObject>						   ResultingOplog;
 
-		std::string GetOpsRequest =
-			fmt::format("{}/prj/{}/oplog/{}/entries", Servers.GetInstance(ServerIndex).GetBaseUri(), Project, Oplog);
-		Session.SetUrl({GetOpsRequest});
-		cpr::Response Response = Session.Get();
-		CHECK(IsHttpSuccessCode(Response.status_code));
+		HttpClient			 Http{Servers.GetInstance(ServerIndex).GetBaseUri()};
+		HttpClient::Response Response = Http.Get(fmt::format("/prj/{}/oplog/{}/entries", Project, Oplog));
+		CHECK(Response);
 
-		IoBuffer	Payload(IoBuffer::Wrap, Response.text.data(), Response.text.size());
+		IoBuffer	Payload(Response.ResponsePayload);
 		CbObject	OplogResonse = LoadCompactBinaryObject(Payload);
 		CbArrayView EntriesArray = OplogResonse["entries"sv].AsArrayView();
 
@@ -3408,19 +3384,20 @@ TEST_CASE("project.remote")
 		CHECK(SourceOps == TargetOps);
 	};
 
-	auto WaitForCompletion = [&Session](ZenServerInstance& Server, const cpr::Response& Response) {
-		CHECK(IsHttpSuccessCode(Response.status_code));
-		uint64_t JobId = ParseInt<uint64_t>(Response.text).value_or(0);
+	auto HttpWaitForCompletion = [](ZenServerInstance& Server, const HttpClient::Response& Response) {
+		REQUIRE(Response);
+		const uint64_t JobId = ParseInt<uint64_t>(Response.AsText()).value_or(0);
 		CHECK(JobId != 0);
-		Session.SetUrl(fmt::format("{}/admin/jobs/{}", Server.GetBaseUri(), JobId));
-		Session.SetHeader(cpr::Header{{"Accept", std::string(ToString(ZenContentType::kCbObject))}});
+
+		HttpClient Http{Server.GetBaseUri()};
+
 		while (true)
 		{
-			cpr::Response StatusResponse = Session.Get();
-			CHECK(IsHttpSuccessCode(StatusResponse.status_code));
-			CbObject ResponseObject =
-				LoadCompactBinaryObject(IoBuffer(IoBuffer::Wrap, StatusResponse.text.data(), StatusResponse.text.size()));
-			std::string_view Status = ResponseObject["Status"sv].AsString();
+			HttpClient::Response StatusResponse =
+				Http.Get(fmt::format("/admin/jobs/{}", JobId), {{"Accept", ToString(ZenContentType::kCbObject)}});
+			CHECK(StatusResponse);
+			CbObject		 ResponseObject = StatusResponse.AsObject();
+			std::string_view Status			= ResponseObject["Status"sv].AsString();
 			CHECK(Status != "Aborted"sv);
 			if (Status == "Complete"sv)
 			{
@@ -3434,9 +3411,6 @@ TEST_CASE("project.remote")
 	{
 		ScopedTemporaryDirectory TempDir;
 		{
-			std::string SaveOplogRequest = fmt::format("{}/prj/{}/oplog/{}/rpc", Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0");
-			Session.SetUrl({SaveOplogRequest});
-
 			IoBuffer Payload = MakeCbObjectPayload([&AttachmentHashes, path = TempDir.Path().string()](CbObjectWriter& Writer) {
 				Writer << "method"sv
 					   << "export"sv;
@@ -3456,17 +3430,15 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(0), Response);
+
+			HttpClient Http{Servers.GetInstance(0).GetBaseUri()};
+
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj0", "oplog0"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(0), Response);
 		}
 		{
-			MakeProject(Session, Servers.GetInstance(1).GetBaseUri(), "proj0_copy");
-			MakeOplog(Session, Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
-			std::string LoadOplogRequest =
-				fmt::format("{}/prj/{}/oplog/{}/rpc", Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
-			Session.SetUrl({LoadOplogRequest});
+			MakeProject(Servers.GetInstance(1).GetBaseUri(), "proj0_copy");
+			MakeOplog(Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
 
 			IoBuffer Payload = MakeCbObjectPayload([&AttachmentHashes, path = TempDir.Path().string()](CbObjectWriter& Writer) {
 				Writer << "method"sv
@@ -3484,11 +3456,11 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
 
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(1), Response);
+			HttpClient Http{Servers.GetInstance(1).GetBaseUri()};
+
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj0_copy", "oplog0_copy"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(1), Response);
 		}
 		ValidateAttachments(1, "proj0_copy", "oplog0_copy");
 		ValidateOplog(1, "proj0_copy", "oplog0_copy");
@@ -3498,9 +3470,6 @@ TEST_CASE("project.remote")
 	{
 		ScopedTemporaryDirectory TempDir;
 		{
-			std::string SaveOplogRequest = fmt::format("{}/prj/{}/oplog/{}/rpc", Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0");
-			Session.SetUrl({SaveOplogRequest});
-
 			IoBuffer Payload = MakeCbObjectPayload([&](CbObjectWriter& Writer) {
 				Writer << "method"sv
 					   << "export"sv;
@@ -3521,17 +3490,15 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(0), Response);
+
+			HttpClient Http{Servers.GetInstance(0).GetBaseUri()};
+
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj0", "oplog0"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(0), Response);
 		}
 		{
-			MakeProject(Session, Servers.GetInstance(1).GetBaseUri(), "proj0_copy");
-			MakeOplog(Session, Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
-			std::string LoadOplogRequest =
-				fmt::format("{}/prj/{}/oplog/{}/rpc", Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
-			Session.SetUrl({LoadOplogRequest});
+			MakeProject(Servers.GetInstance(1).GetBaseUri(), "proj0_copy");
+			MakeOplog(Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
 			IoBuffer Payload = MakeCbObjectPayload([&](CbObjectWriter& Writer) {
 				Writer << "method"sv
 					   << "import"sv;
@@ -3548,10 +3515,11 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(1), Response);
+
+			HttpClient Http{Servers.GetInstance(1).GetBaseUri()};
+
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj0_copy", "oplog0_copy"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(1), Response);
 		}
 		ValidateAttachments(1, "proj0_copy", "oplog0_copy");
 		ValidateOplog(1, "proj0_copy", "oplog0_copy");
@@ -3561,8 +3529,6 @@ TEST_CASE("project.remote")
 	{
 		ScopedTemporaryDirectory TempDir;
 		{
-			std::string SaveOplogRequest = fmt::format("{}/prj/{}/oplog/{}/rpc", Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0");
-			Session.SetUrl({SaveOplogRequest});
 			IoBuffer Payload = MakeCbObjectPayload([&](CbObjectWriter& Writer) {
 				Writer << "method"sv
 					   << "export"sv;
@@ -3583,17 +3549,14 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(0), Response);
+
+			HttpClient			 Http{Servers.GetInstance(0).GetBaseUri()};
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj0", "oplog0"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(0), Response);
 		}
 		{
-			MakeProject(Session, Servers.GetInstance(1).GetBaseUri(), "proj0_copy");
-			MakeOplog(Session, Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
-			std::string LoadOplogRequest =
-				fmt::format("{}/prj/{}/oplog/{}/rpc", Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
-			Session.SetUrl({LoadOplogRequest});
+			MakeProject(Servers.GetInstance(1).GetBaseUri(), "proj0_copy");
+			MakeOplog(Servers.GetInstance(1).GetBaseUri(), "proj0_copy", "oplog0_copy");
 			IoBuffer Payload = MakeCbObjectPayload([&](CbObjectWriter& Writer) {
 				Writer << "method"sv
 					   << "import"sv;
@@ -3610,10 +3573,10 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(1), Response);
+
+			HttpClient			 Http{Servers.GetInstance(1).GetBaseUri()};
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj0_copy", "oplog0_copy"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(1), Response);
 		}
 		ValidateAttachments(1, "proj0_copy", "oplog0_copy");
 		ValidateOplog(1, "proj0_copy", "oplog0_copy");
@@ -3625,11 +3588,8 @@ TEST_CASE("project.remote")
 		{
 			std::string ExportSourceUri = Servers.GetInstance(0).GetBaseUri();
 			std::string ExportTargetUri = Servers.GetInstance(1).GetBaseUri();
-			MakeProject(Session, ExportTargetUri, "proj0_copy");
-			MakeOplog(Session, ExportTargetUri, "proj0_copy", "oplog0_copy");
-
-			std::string SaveOplogRequest = fmt::format("{}/prj/{}/oplog/{}/rpc", ExportSourceUri, "proj0", "oplog0");
-			Session.SetUrl({SaveOplogRequest});
+			MakeProject(ExportTargetUri, "proj0_copy");
+			MakeOplog(ExportTargetUri, "proj0_copy", "oplog0_copy");
 
 			IoBuffer Payload = MakeCbObjectPayload([&](CbObjectWriter& Writer) {
 				Writer << "method"sv
@@ -3652,10 +3612,10 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(0), Response);
+
+			HttpClient			 Http{Servers.GetInstance(0).GetBaseUri()};
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj0", "oplog0"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(0), Response);
 		}
 		ValidateAttachments(1, "proj0_copy", "oplog0_copy");
 		ValidateOplog(1, "proj0_copy", "oplog0_copy");
@@ -3663,10 +3623,8 @@ TEST_CASE("project.remote")
 		{
 			std::string ImportSourceUri = Servers.GetInstance(1).GetBaseUri();
 			std::string ImportTargetUri = Servers.GetInstance(2).GetBaseUri();
-			MakeProject(Session, ImportTargetUri, "proj1");
-			MakeOplog(Session, ImportTargetUri, "proj1", "oplog1");
-			std::string LoadOplogRequest = fmt::format("{}/prj/{}/oplog/{}/rpc", ImportTargetUri, "proj1", "oplog1");
-			Session.SetUrl({LoadOplogRequest});
+			MakeProject(ImportTargetUri, "proj1");
+			MakeOplog(ImportTargetUri, "proj1", "oplog1");
 
 			IoBuffer Payload = MakeCbObjectPayload([&](CbObjectWriter& Writer) {
 				Writer << "method"sv
@@ -3686,10 +3644,10 @@ TEST_CASE("project.remote")
 				}
 				Writer << EndObject;  // "params"
 			});
-			Session.SetBody(AsBody(Payload));
-			Session.SetHeader(cpr::Header{{"Content-Type", "application/x-ue-cb"}});
-			cpr::Response Response = Session.Post();
-			WaitForCompletion(Servers.GetInstance(2), Response);
+
+			HttpClient			 Http{Servers.GetInstance(2).GetBaseUri()};
+			HttpClient::Response Response = Http.Post(fmt::format("/prj/{}/oplog/{}/rpc", "proj1", "oplog1"), Payload);
+			HttpWaitForCompletion(Servers.GetInstance(2), Response);
 		}
 		ValidateAttachments(2, "proj1", "oplog1");
 		ValidateOplog(2, "proj1", "oplog1");