Add callback for outer-task in Prefetch

When task is schedulled and cancelled before execution,
no function executed and callback is called. Add callback
for covering such cases.

Relates-To: OLPEDGE-1005

Signed-off-by: Diachenko Mykahilo <[email protected]>

Author: diachenko-mischa

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

@@ -170,8 +170,7 @@ client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
           OLP_SDK_LOG_WARNING_F(kLogTag,
                                 "PrefetchTiles : invalid request, layer=%s",
                                 layer_id.c_str());
-          callback({{ErrorCode::InvalidArgument, "Empty tile key list"}});
-          return EmptyResponse(PrefetchTileNoError());
+          return {{ErrorCode::InvalidArgument, "Empty tile key list"}};
         }
 
         // Get Catalog version first if none set.
@@ -189,8 +188,7 @@ client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
                 kLogTag,
                 "PrefetchTiles: getting catalog version failed, key=%s",
                 request.CreateKey(layer_id).c_str());
-            callback(response.GetError());
-            return EmptyResponse(PrefetchTileNoError());
+            return response.GetError();
           }
 
           request.WithVersion(response.GetResult().GetVersion());
@@ -209,8 +207,7 @@ client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
           OLP_SDK_LOG_WARNING_F(kLogTag,
                                 "PrefetchTiles: tile/level mismatch, key=%s",
                                 key.c_str());
-          callback({{ErrorCode::InvalidArgument, "TileKeys/levels mismatch"}});
-          return EmptyResponse(PrefetchTileNoError());
+          return {{ErrorCode::InvalidArgument, "TileKeys/levels mismatch"}};
         }
 
         OLP_SDK_LOG_DEBUG_F(kLogTag, "PrefetchTiles, subquads=%zu, key=%s",
@@ -221,16 +218,14 @@ client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
             prefetch_repo->GetSubTiles(layer_id, request, sub_quads, context);
 
         if (!sub_tiles.IsSuccessful()) {
-          callback(sub_tiles.GetError());
-          return EmptyResponse(PrefetchTileNoError());
+          return sub_tiles.GetError();
         }
 
         const auto& tiles_result = sub_tiles.GetResult();
         if (tiles_result.empty()) {
           OLP_SDK_LOG_WARNING_F(
               kLogTag, "PrefetchTiles: subtiles empty, key=%s", key.c_str());
-          callback({{ErrorCode::InvalidArgument, "Subquads retrieval failed"}});
-          return EmptyResponse(PrefetchTileNoError());
+          return {{ErrorCode::InvalidArgument, "Subquads retrieval failed"}};
         }
 
         OLP_SDK_LOG_INFO_F(kLogTag, "Prefetch start, key=%s, tiles=%zu",
@@ -324,7 +319,14 @@ client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
       // Because the handling of prefetch tiles responses is performed by the
       // inner-task, no need to set a callback here. Otherwise, the user would
       // be notified with empty results.
-      nullptr);
+      // It is possible to not invoke inner task, when it was cancelled before
+      // execution.
+      [callback](EmptyResponse response) {
+        // Inner task only generates successfull result
+        if (!response.IsSuccessful()) {
+          callback(response.GetError());
+        }
+      });
 
   return token;
 }  // namespace read

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

@@ -2005,6 +2005,67 @@ TEST_F(DataserviceReadVersionedLayerClientTest,
             data_response.GetError().GetErrorCode());
 }
 
+TEST_F(DataserviceReadVersionedLayerClientTest, CancelPendingRequestsPrefetch) {
+  olp::client::HRN hrn(GetTestCatalog());
+
+  auto client =
+      std::make_unique<VersionedLayerClient>(hrn, "testlayer", *settings_);
+  auto prefetch_request = PrefetchTilesRequest();
+  auto data_request =
+      DataRequest().WithPartitionId("269").WithFetchOption(OnlineOnly);
+
+  auto request_started = std::make_shared<std::promise<void>>();
+  auto continue_request = std::make_shared<std::promise<void>>();
+
+  {
+    olp::http::RequestId request_id;
+    NetworkCallback send_mock;
+    CancelCallback cancel_mock;
+
+    std::tie(request_id, send_mock, cancel_mock) = GenerateNetworkMockActions(
+        request_started, continue_request,
+        {olp::http::HttpStatusCode::OK, HTTP_RESPONSE_BLOB_DATA_269});
+
+    EXPECT_CALL(*network_mock_,
+                Send(IsGetRequest(URL_BLOB_DATA_269), _, _, _, _))
+        .Times(1)
+        .WillOnce(testing::Invoke(std::move(send_mock)));
+
+    EXPECT_CALL(*network_mock_, Cancel(request_id))
+        .WillOnce(testing::Invoke(std::move(cancel_mock)));
+  }
+
+  auto data_future = client->GetData(data_request).GetFuture();
+  auto prefetch_future = client->PrefetchTiles(prefetch_request).GetFuture();
+
+  request_started->get_future().get();
+  client->CancelPendingRequests();
+  continue_request->set_value();
+
+  ASSERT_EQ(prefetch_future.wait_for(kWaitTimeout), std::future_status::ready);
+  auto prefetch_response = prefetch_future.get();
+
+  ASSERT_FALSE(prefetch_response.IsSuccessful())
+      << ApiErrorToString(prefetch_response.GetError());
+
+  ASSERT_EQ(static_cast<int>(olp::http::ErrorCode::CANCELLED_ERROR),
+            prefetch_response.GetError().GetHttpStatusCode());
+  ASSERT_EQ(olp::client::ErrorCode::Cancelled,
+            prefetch_response.GetError().GetErrorCode());
+
+  ASSERT_EQ(data_future.wait_for(kWaitTimeout), std::future_status::ready);
+
+  auto data_response = data_future.get();
+
+  ASSERT_FALSE(data_response.IsSuccessful())
+      << ApiErrorToString(data_response.GetError());
+
+  ASSERT_EQ(static_cast<int>(olp::http::ErrorCode::CANCELLED_ERROR),
+            data_response.GetError().GetHttpStatusCode());
+  ASSERT_EQ(olp::client::ErrorCode::Cancelled,
+            data_response.GetError().GetErrorCode());
+}
+
 TEST_F(DataserviceReadVersionedLayerClientTest,
        DISABLED_GetDataWithPartitionIdCancelLookupMetadata) {
   olp::client::HRN hrn(GetTestCatalog());