Add GetPartitions with CancellableFuture in VersionedLayerClient

Add the GetPartitions method which returns CancellableFuture in
the dataservice-read VersionedLayerClient class.
Also, added integration tests.

Relates-To: OLPEDGE-958
Signed-off-by: Diachenko Mykahilo <[email protected]>

Author: diachenko-mischa

olp-cpp-sdk-dataservice-read/include/olp/dataservice/read/VersionedLayerClient.h

@@ -149,6 +149,20 @@ class DATASERVICE_READ_API VersionedLayerClient final {
   client::CancellationToken GetPartitions(PartitionsRequest partitions_request,
                                           PartitionsResponseCallback callback);
 
+  /**
+   * @brief Fetches a list of partitions for the given generic layer
+   * asynchronously.
+   * @param partitions_request Contains the complete set of the request
+   * parameters.
+   * @note GetLayerId value of the \c PartitionsRequest is ignored, and the
+   * parameter from the constructor is used instead.
+   * @return \c CancellableFuture of type \c PartitionsResponse, which when
+   * complete will contain the data or an error. Alternatively, the
+   * \c CancellableFuture can be used to cancel this request.
+   */
+  client::CancellableFuture<PartitionsResponse> GetPartitions(
+      PartitionsRequest partitions_request);
+
   /**
    * @brief Pre-fetches a set of tiles asychronously.
    *

olp-cpp-sdk-dataservice-read/src/VersionedLayerClient.cpp

@@ -50,6 +50,11 @@ client::CancellationToken VersionedLayerClient::GetPartitions(
                               std::move(callback));
 }
 
+client::CancellableFuture<PartitionsResponse>
+VersionedLayerClient::GetPartitions(PartitionsRequest partitions_request) {
+  return impl_->GetPartitions(std::move(partitions_request));
+}
+
 client::CancellationToken VersionedLayerClient::PrefetchTiles(
     PrefetchTilesRequest request, PrefetchTilesResponseCallback callback) {
   return impl_->PrefetchTiles(std::move(request), std::move(callback));

olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.cpp

@@ -106,6 +106,17 @@ client::CancellationToken VersionedLayerClientImpl::GetPartitions(
   return token;
 }
 
+client::CancellableFuture<PartitionsResponse>
+VersionedLayerClientImpl::GetPartitions(PartitionsRequest partitions_request) {
+  auto promise = std::make_shared<std::promise<PartitionsResponse>>();
+  auto cancel_token = GetPartitions(std::move(partitions_request),
+                                    [promise](PartitionsResponse response) {
+                                      promise->set_value(std::move(response));
+                                    });
+  return client::CancellableFuture<PartitionsResponse>(std::move(cancel_token),
+                                                       std::move(promise));
+}
+
 client::CancellationToken VersionedLayerClientImpl::GetData(
     DataRequest request, DataResponseCallback callback) {
   auto add_task = [&](DataRequest& request, DataResponseCallback callback) {

olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.h

@@ -62,6 +62,9 @@ class VersionedLayerClientImpl {
       PartitionsRequest partitions_request,
       PartitionsResponseCallback callback);
 
+  virtual client::CancellableFuture<PartitionsResponse> GetPartitions(
+      PartitionsRequest partitions_request);
+
   virtual client::CancellationToken PrefetchTiles(
       PrefetchTilesRequest request, PrefetchTilesResponseCallback callback);
 

tests/integration/olp-cpp-sdk-dataservice-read/VersionedLayerClientTest.cpp

@@ -931,6 +931,53 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetPartitionsNoError) {
   ASSERT_EQ(4u, response.GetResult().GetPartitions().size());
 }
 
+TEST_F(DataserviceReadVersionedLayerClientTest,
+       GetPartitionsCancellableFutureNoError) {
+  auto catalog = olp::client::HRN::FromString(
+      GetArgument("dataservice_read_test_catalog"));
+  auto layer = GetArgument("dataservice_read_test_layer");
+
+  auto catalog_client =
+      std::make_unique<olp::dataservice::read::VersionedLayerClient>(
+          catalog, layer, *settings_);
+
+  auto request = olp::dataservice::read::PartitionsRequest();
+  auto cancellable_future = catalog_client->GetPartitions(request);
+  auto future = cancellable_future.GetFuture();
+  ASSERT_NE(future.wait_for(kWaitTimeout), std::future_status::timeout);
+  PartitionsResponse response = future.get();
+
+  ASSERT_TRUE(response.IsSuccessful()) << response.GetError().GetMessage();
+  ASSERT_EQ(4u, response.GetResult().GetPartitions().size());
+}
+
+TEST_F(DataserviceReadVersionedLayerClientTest,
+       GetPartitionsCancellableFutureCancellation) {
+  auto catalog = olp::client::HRN::FromString(
+      GetArgument("dataservice_read_test_catalog"));
+  auto layer = GetArgument("dataservice_read_test_layer");
+
+  settings_->task_scheduler->ScheduleTask(
+      []() { std::this_thread::sleep_for(std::chrono::seconds(1)); });
+
+  auto catalog_client =
+      std::make_unique<olp::dataservice::read::VersionedLayerClient>(
+          catalog, layer, *settings_);
+
+  auto request = olp::dataservice::read::PartitionsRequest();
+  auto cancellable_future = catalog_client->GetPartitions(request);
+  auto future = cancellable_future.GetFuture();
+
+  cancellable_future.GetCancellationToken().cancel();
+
+  ASSERT_EQ(std::future_status::ready, future.wait_for(kWaitTimeout));
+
+  auto response = future.get();
+  EXPECT_FALSE(response.IsSuccessful());
+  EXPECT_EQ(response.GetError().GetErrorCode(),
+            olp::client::ErrorCode::Cancelled);
+}
+
 TEST_F(DataserviceReadVersionedLayerClientTest, GetEmptyPartitions) {
   auto catalog = olp::client::HRN::FromString(
       GetArgument("dataservice_read_test_catalog"));