Add use_local_time to AuthenticationSettings (#765)

Add use_local_time parameter to AuthenticationSettings to
control if AuthenticationClient will try to get time from server
or use local machine time instead.

Resolves: OLPEDGE-1762

Signed-off-by: Serhii Lozynskyi <[email protected]>

Author: meravingen123

olp-cpp-sdk-authentication/include/olp/authentication/AuthenticationSettings.h

@@ -77,6 +77,12 @@ struct AUTHENTICATION_API AuthenticationSettings {
    * in-memory cache.
    */
   size_t token_cache_limit{100u};
+
+  /**
+   * @brief Uses system system time in authentication requests rather than
+   * requesting time from authentication server.
+   */
+  bool use_system_time{false};
 };
 
 }  // namespace authentication

olp-cpp-sdk-authentication/src/AuthenticationClient.cpp

@@ -329,6 +329,7 @@ class AuthenticationClient::Impl final {
   using TimeResponse = client::ApiResponse<time_t, client::ApiError>;
   using TimeCallback = std::function<void(TimeResponse)>;
 
+  client::CancellationToken GetTime(TimeCallback callback);
   client::CancellationToken GetTimeFromServer(TimeCallback callback);
   static TimeResponse ParseTimeResponse(std::stringstream& payload);
 
@@ -530,7 +531,7 @@ client::CancellationToken AuthenticationClient::Impl::SignInClient(
   };
 
   context.ExecuteOrCancelled(
-      [&]() { return GetTimeFromServer(std::move(time_callback)); }, []() {});
+      [&]() { return GetTime(std::move(time_callback)); });
   return client::CancellationToken(
       [context]() mutable { context.CancelOperation(); });
 }
@@ -556,6 +557,15 @@ AuthenticationClient::Impl::ParseTimeResponse(std::stringstream& payload) {
   return timestamp_it->value.GetUint();
 }
 
+client::CancellationToken AuthenticationClient::Impl::GetTime(TimeCallback callback) {
+  if (settings_.use_system_time) {
+    callback(
+        std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()));
+    return client::CancellationToken();
+  }
+  return GetTimeFromServer(std::move(callback));
+}
+
 client::CancellationToken AuthenticationClient::Impl::GetTimeFromServer(
     TimeCallback callback) {
   std::weak_ptr<http::Network> weak_network(settings_.network_request_handler);

tests/integration/olp-cpp-sdk-authentication/AuthenticationClientTest.cpp

@@ -42,6 +42,8 @@ const std::string kTimestampUrl =
 const std::string kIntrospectUrl =
     R"(https://authentication.server.url/app/me)";
 
+constexpr auto kTokenEndpointUrl = "https://authentication.server.url";
+
 constexpr unsigned int kExpirtyTime = 3600;
 constexpr unsigned int kMaxExpiryTime = kExpirtyTime + 30;
 constexpr unsigned int kMinExpiryTime = kExpirtyTime - 10;
@@ -116,8 +118,7 @@ class AuthenticationClientTest : public ::testing::Test {
   AuthenticationClientTest()
       : key_("key"), secret_("secret"), scope_("scope") {}
   void SetUp() {
-    client_ = std::make_unique<AuthenticationClient>(
-        "https://authentication.server.url");
+    client_ = std::make_unique<AuthenticationClient>(kTokenEndpointUrl);
 
     network_ = std::make_shared<NetworkMock>();
     task_scheduler_ =
@@ -222,6 +223,65 @@ class AuthenticationClientTest : public ::testing::Test {
   const std::string scope_;
 };
 
+TEST_F(AuthenticationClientTest, SignInClientUseLocalTime) {
+  AuthenticationSettings settings;
+  settings.network_request_handler = network_;
+  settings.use_system_time = true;
+  settings.token_endpoint_url = kTokenEndpointUrl;
+
+  auto client = std::make_unique<AuthenticationClient>(std::move(settings));
+
+  AuthenticationCredentials credentials(key_, secret_);
+  std::promise<AuthenticationClient::SignInClientResponse> request;
+  auto request_future = request.get_future();
+
+  EXPECT_CALL(*network_, Send(IsGetRequest(kTimestampUrl), _, _, _, _))
+      .Times(0);
+
+  EXPECT_CALL(*network_, Send(_, _, _, _, _))
+      .WillOnce([&](olp::http::NetworkRequest /*request*/,
+                    olp::http::Network::Payload payload,
+                    olp::http::Network::Callback callback,
+                    olp::http::Network::HeaderCallback /*header_callback*/,
+                    olp::http::Network::DataCallback data_callback) {
+        olp::http::RequestId request_id(5);
+        if (payload) {
+          *payload << kResponseWithScope;
+        }
+        callback(olp::http::NetworkResponse()
+                     .WithRequestId(request_id)
+                     .WithStatus(olp::http::HttpStatusCode::OK));
+        if (data_callback) {
+          auto raw = const_cast<char*>(kResponseWithScope.c_str());
+          data_callback(reinterpret_cast<uint8_t*>(raw), 0,
+                        kResponseWithScope.size());
+        }
+
+        return olp::http::SendOutcome(request_id);
+      });
+
+  AuthenticationClient::SignInProperties properties;
+  properties.scope = scope_;
+  std::time_t now = std::time(nullptr);
+  client->SignInClient(
+      credentials, properties,
+      [&](const AuthenticationClient::SignInClientResponse& response) {
+        request.set_value(response);
+      });
+  request_future.wait();
+
+  AuthenticationClient::SignInClientResponse response = request_future.get();
+  EXPECT_TRUE(response.IsSuccessful());
+  EXPECT_FALSE(response.GetResult().GetAccessToken().empty());
+  EXPECT_EQ(kResponseToken, response.GetResult().GetAccessToken());
+  EXPECT_GE(now + kMaxExpiryTime, response.GetResult().GetExpiryTime());
+  EXPECT_LT(now + kMinExpiryTime, response.GetResult().GetExpiryTime());
+  EXPECT_EQ("bearer", response.GetResult().GetTokenType());
+  EXPECT_TRUE(response.GetResult().GetRefreshToken().empty());
+  EXPECT_TRUE(response.GetResult().GetUserIdentifier().empty());
+  EXPECT_EQ(response.GetResult().GetScope(), scope_);
+}
+
 TEST_F(AuthenticationClientTest, SignInClientScope) {
   AuthenticationCredentials credentials(key_, secret_);
   std::promise<AuthenticationClient::SignInClientResponse> request;