timeout support when create client or make request

test/core/CMakeLists.txt

@@ -77,7 +77,8 @@ add_executable(core_ut
   sts_model_assumerole_result_ut.cc
   sts_model_getcalleridentity_request_ut.cc
   sts_model_getcalleridentity_result_ut.cc
-  )
+  timeout_ut.cc
+)
 
 set_target_properties(core_ut
   PROPERTIES

test/core/clientconfiguration_ut.cc

@@ -1,5 +1,6 @@
 #include "gtest/gtest.h"
 #include "alibabacloud/core/ClientConfiguration.h"
+#include "alibabacloud/core/AlibabaCloud.h"
 
 using namespace std;
 using namespace AlibabaCloud;
@@ -28,4 +29,11 @@ TEST(ClientConfiguration, basic) {
   EXPECT_TRUE(config.proxy().port() == port);
   EXPECT_TRUE(config.proxy().user() == user);
   EXPECT_TRUE(config.proxy().password() == password);
+
+  EXPECT_TRUE(config.connectTimeout() == kDefaultConnectTimeout);
+  EXPECT_TRUE(config.readTimeout() == kDefaultReadTimeout);
+  config.setConnectTimeout(1222);
+  config.setReadTimeout(23333);
+  EXPECT_TRUE(config.connectTimeout() == 1222);
+  EXPECT_TRUE(config.readTimeout() == 23333);
 }

test/core/curlhttpclient_ut.cc

@@ -10,10 +10,6 @@
 #include "../src/CurlHttpClient.h"
 
 using namespace std;
-using ::testing::Return;
-using ::testing::DoAll;
-using ::testing::SetArgReferee;
-using ::testing::ReturnPointee;
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::DefaultValue;
@@ -27,6 +23,64 @@ class mockCurlHttpClient : public CurlHttpClient {
   MOCK_METHOD1(makeRequest, HttpResponseOutcome (const HttpRequest &request));
 };
 
+TEST(CurlHttpClient, connectTimeout) {
+  CurlHttpClient client;
+  HttpRequest request;
+
+  Url url;
+  url.setScheme("http");
+  url.setHost("192.168.100.100");
+
+  request.setMethod(HttpRequest::Method::Get);
+  request.setUrl(url);
+  request.setConnectTimeout(100);
+  request.setReadTimeout(1000);
+  request.setHeader("Content-Type", "text/html");
+  HttpClient::HttpResponseOutcome out = client.makeRequest(request);
+  string errmsg = "Timeout (connectTimeout: 100ms, readTimeout: 1000ms) when connect or read data: GET http://192.168.100.100/";
+  EXPECT_TRUE(out.error().errorCode() == "OperationTimeoutError");
+  EXPECT_TRUE(out.error().errorMessage() == errmsg);
+}
+
+TEST(CurlHttpClient, defaultTimeout) {
+  CurlHttpClient client;
+  HttpRequest request;
+
+  Url url;
+  url.setScheme("http");
+  url.setHost("192.168.100.100");
+
+  request.setMethod(HttpRequest::Method::Get);
+  request.setUrl(url);
+  request.setHeader("Content-Type", "text/html");
+  HttpClient::HttpResponseOutcome out = client.makeRequest(request);
+  string errmsg = "Timeout (connectTimeout: 5000ms, readTimeout: 10000ms) when connect or read data: GET http://192.168.100.100/";
+  EXPECT_TRUE(out.error().errorCode() == "OperationTimeoutError");
+  EXPECT_TRUE(out.error().errorMessage() == errmsg);
+}
+
+TEST(CurlHttpClient, readTimeout) {
+  CurlHttpClient client;
+  HttpRequest request;
+
+  Url url;
+  url.setScheme("http");
+  url.setHost("127.0.0.1");
+  url.setPort(8021);
+  url.setPath("/readTimeoutTest");
+  url.setQuery("timeout=500");
+
+  request.setMethod(HttpRequest::Method::Get);
+  request.setUrl(url);
+  request.setConnectTimeout(233);
+  request.setReadTimeout(500);
+  request.setHeader("Content-Type", "text/html");
+  HttpClient::HttpResponseOutcome out = client.makeRequest(request);
+  string errmsg = "Timeout (connectTimeout: 233ms, readTimeout: 500ms) when connect or read data: GET http://127.0.0.1:8021/readTimeoutTest?timeout=500";
+
+  EXPECT_TRUE(out.error().errorCode() == "OperationTimeoutError");
+  EXPECT_TRUE(out.error().errorMessage() == errmsg);
+}
 
 TEST(CurlHttpClient, http_get) {
   CurlHttpClient client;

test/core/httprequest_ut.cc

@@ -18,13 +18,20 @@ TEST(HttpRequest, basic) {
   url.setQuery("key=value&key2=value2");
   url.setFragment("fragid1");
 
-  HttpRequest http_request(url, HttpRequest::Method::Post);
+  HttpRequest req(url, HttpRequest::Method::Post);
 
-  EXPECT_TRUE(http_request.method() == HttpRequest::Method::Post);
-  http_request.setMethod(HttpRequest::Method::Get);
-  EXPECT_TRUE(http_request.method() == HttpRequest::Method::Get);
+  EXPECT_TRUE(req.method() == HttpRequest::Method::Post);
+  req.setMethod(HttpRequest::Method::Get);
+  EXPECT_TRUE(req.method() == HttpRequest::Method::Get);
 
-  http_request.setUrl(url);
-  Url rUrl = http_request.url();
+  req.setUrl(url);
+  Url rUrl = req.url();
   EXPECT_TRUE(rUrl.toString() == src);
+
+  EXPECT_TRUE(req.connectTimeout() == 5000);
+  EXPECT_TRUE(req.readTimeout() == 10000);
+  req.setConnectTimeout(12345);
+  req.setReadTimeout(3335);
+  EXPECT_TRUE(req.connectTimeout() == 12345);
+  EXPECT_TRUE(req.readTimeout() == 3335);
 }

test/core/servicerequest_ut.cc

@@ -4,6 +4,7 @@
 #include <string.h>
 #include "gtest/gtest.h"
 #include "alibabacloud/core/ServiceRequest.h"
+#include "alibabacloud/core/AlibabaCloud.h"
 
 using namespace std;
 using namespace AlibabaCloud;
@@ -30,6 +31,7 @@ namespace {
     using ServiceRequest::setResourcePath;
     using ServiceRequest::setProduct;
     using ServiceRequest::setVersion;
+
   };
 
   TEST(ServiceRequest, basic) {
@@ -81,5 +83,12 @@ namespace {
     ServiceRequest::ParameterCollection pc = sr1.parameters();
     EXPECT_TRUE(pc.at("km") == "vm");
     EXPECT_TRUE(pc.at("kn") == "vn");
+
+    EXPECT_TRUE(sr1.connectTimeout() == kInvalidTimeout);
+    EXPECT_TRUE(sr1.readTimeout() == kInvalidTimeout);
+    sr1.setConnectTimeout(1234);
+    sr1.setReadTimeout(22233);
+    EXPECT_TRUE(sr1.connectTimeout() == 1234);
+    EXPECT_TRUE(sr1.readTimeout() == 22233);
   }
 }

test/core/timeout_ut.cc

@@ -0,0 +1,277 @@
+
+#include <iostream>
+#include <stdio.h>
+#include "gtest/gtest.h"
+#include "../../core/src/Utils.h"
+#include "alibabacloud/core/Config.h"
+#include "alibabacloud/core/AlibabaCloud.h"
+#include "alibabacloud/core/CommonClient.h"
+#include "alibabacloud/core/CommonResponse.h"
+#include "alibabacloud/core/CommonRequest.h"
+#include "alibabacloud/core/SimpleCredentialsProvider.h"
+
+
+#include "alibabacloud/core/RoaServiceClient.h"
+#include "alibabacloud/core/RpcServiceClient.h"
+
+using namespace std;
+using namespace AlibabaCloud;
+
+const std::string unreachableDomain = "192.168.111.111";
+const std::string timeoutErrorCode = "OperationTimeoutError";
+
+const std::string defaultErrorMessage =
+  "Timeout (connectTimeout: 5000ms, readTimeout: 10000ms) when connect or read data: GET http://192.168.111.111/";
+
+long kClientConnectTimeout = 12;
+long kClientReadTimeout = 234;
+const std::string clientErrorMessage =
+  "Timeout (connectTimeout: 12ms, readTimeout: 234ms) when connect or read data: GET http://192.168.111.111/";
+
+long kRequestConnectTimeout = 33;
+long kRequestReadTimeout = 724;
+const std::string requestErrorMessage =
+  "Timeout (connectTimeout: 33ms, readTimeout: 724ms) when connect or read data: GET http://192.168.111.111/";
+
+TEST(timeout, DefaultCommonClientROA) {
+  ClientConfiguration configuration("cn-hangzhou");
+  CommonClient client("key", "secret", configuration);
+  CommonRequest request(CommonRequest::RoaPattern);
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage() == defaultErrorMessage);
+}
+
+TEST(timeout, DefaultCommonClientRPC) {
+  ClientConfiguration configuration("cn-hangzhou");
+  CommonClient client("key", "secret", configuration);
+  CommonRequest request(CommonRequest::RpcPattern);
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(defaultErrorMessage) == 0);
+}
+
+
+TEST(timeout, clientCommonClientROA) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  CommonClient client("key", "secret", configuration);
+
+  CommonRequest request(CommonRequest::RoaPattern);
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage() == clientErrorMessage);
+}
+
+TEST(timeout, clientCommonClientRPC) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  CommonClient client("key", "secret", configuration);
+
+  CommonRequest request(CommonRequest::RpcPattern);
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(clientErrorMessage) == 0);
+}
+
+TEST(timeout, requestCommonClientROA) {
+  ClientConfiguration configuration("cn-hangzhou");
+  CommonClient client("key", "secret", configuration);
+
+  CommonRequest request(CommonRequest::RoaPattern);
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage() == requestErrorMessage);
+}
+
+TEST(timeout, requestCommonClientRPC) {
+  ClientConfiguration configuration("cn-hangzhou");
+  CommonClient client("key", "secret", configuration);
+
+  CommonRequest request(CommonRequest::RpcPattern);
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(requestErrorMessage) == 0);
+}
+
+TEST(timeout, clientRequestCommonClientROA) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  CommonClient client("key", "secret", configuration);
+
+  CommonRequest request(CommonRequest::RoaPattern);
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage() == requestErrorMessage);
+}
+
+TEST(timeout, clientRequestCommonClientRPC) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  CommonClient client("key", "secret", configuration);
+
+  CommonRequest request(CommonRequest::RpcPattern);
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+
+  request.setScheme("http");
+  request.setDomain(unreachableDomain);
+  auto out = client.commonResponse(request);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(requestErrorMessage) == 0);
+}
+
+class TestRoaClient : public RoaServiceClient {
+ public:
+  TestRoaClient(const std::string & servicename, const std::shared_ptr<CredentialsProvider> &credentialsProvider,
+    const ClientConfiguration &configuration,
+    const std::shared_ptr<Signer> &signer = std::make_shared<HmacSha1Signer>()):
+  RoaServiceClient(servicename, credentialsProvider, configuration, signer)
+  {}
+
+  JsonOutcome makeRequest(const std::string &endpoint, const RoaServiceRequest &msg, HttpRequest::Method method = HttpRequest::Method::Get)const {
+    return RoaServiceClient::makeRequest(endpoint, msg, method);
+  }
+};
+
+TEST(timeout, roaClientDefault) {
+  ClientConfiguration configuration("cn-hangzhou");
+  const Credentials credentials("key", "secret");
+  TestRoaClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RoaServiceRequest request("product", "version");
+  request.setScheme("http");
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(defaultErrorMessage) == 0);
+}
+
+TEST(timeout, roaClientclient) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  const Credentials credentials("key", "secret");
+  TestRoaClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RoaServiceRequest request("product", "version");
+  request.setScheme("http");
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(clientErrorMessage) == 0);
+}
+
+TEST(timeout, roaClientrequest) {
+  ClientConfiguration configuration("cn-hangzhou");
+  const Credentials credentials("key", "secret");
+  TestRoaClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RoaServiceRequest request("product", "version");
+  request.setScheme("http");
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(requestErrorMessage) == 0);
+}
+
+TEST(timeout, roaClientclientrequest) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  const Credentials credentials("key", "secret");
+  TestRoaClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RoaServiceRequest request("product", "version");
+  request.setScheme("http");
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(requestErrorMessage) == 0);
+}
+
+
+class TestRpcClient : public RpcServiceClient {
+ public:
+  TestRpcClient(const std::string & servicename, const std::shared_ptr<CredentialsProvider> &credentialsProvider,
+  const ClientConfiguration &configuration,
+  const std::shared_ptr<Signer> &signer = std::make_shared<HmacSha1Signer>()):
+  RpcServiceClient(servicename, credentialsProvider, configuration, signer)
+  {}
+
+  JsonOutcome makeRequest(const std::string &endpoint, const RpcServiceRequest &msg, HttpRequest::Method method = HttpRequest::Method::Get)const {
+    return RpcServiceClient::makeRequest(endpoint, msg, method);
+  }
+};
+
+TEST(timeout, rpcClientDefault) {
+  ClientConfiguration configuration("cn-hangzhou");
+  const Credentials credentials("key", "secret");
+  TestRpcClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RpcServiceRequest request("product", "version", "aciton");
+  request.setScheme("http");
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(defaultErrorMessage) == 0);
+}
+
+TEST(timeout, rpcClientclient) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  const Credentials credentials("key", "secret");
+  TestRpcClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RpcServiceRequest request("product", "version", "aciton");
+  request.setScheme("http");
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(clientErrorMessage) == 0);
+}
+
+TEST(timeout, rpcClientrequest) {
+  ClientConfiguration configuration("cn-hangzhou");
+  const Credentials credentials("key", "secret");
+  TestRpcClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RpcServiceRequest request("product", "version", "aciton");
+  request.setScheme("http");
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(requestErrorMessage) == 0);
+}
+
+TEST(timeout, rpcClientclientrequest) {
+  ClientConfiguration configuration("cn-hangzhou");
+  configuration.setConnectTimeout(kClientConnectTimeout);
+  configuration.setReadTimeout(kClientReadTimeout);
+  const Credentials credentials("key", "secret");
+  TestRpcClient client("any-service", std::make_shared<SimpleCredentialsProvider>(credentials), configuration);
+  RpcServiceRequest request("product", "version", "aciton");
+  request.setScheme("http");
+  request.setConnectTimeout(kRequestConnectTimeout);
+  request.setReadTimeout(kRequestReadTimeout);
+  auto out = client.makeRequest(unreachableDomain, request, HttpRequest::Method::Get);
+  EXPECT_TRUE(out.error().errorCode() == timeoutErrorCode);
+  EXPECT_TRUE(out.error().errorMessage().find(requestErrorMessage) == 0);
+}