diff options
Diffstat (limited to 'src/zenserver-test/zenserver-test.cpp')
| -rw-r--r-- | src/zenserver-test/zenserver-test.cpp | 944 |
1 files changed, 451 insertions, 493 deletions
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"); |