feat: send transactions (#64)

* feat: TX Send

- add 'Transactions::send()' method.
- add 'Transactions::send()' Paths method.
- add mock test for 'send' method.
- add test for 'send' Path method.

* fix: remove trailing slash

* fix: remove trailing slash from tests

* fix: correct jsonTransaction string

- updates to correct json example for tx post/"send" body.

* fix: set content-type on post

* test: add json post test

Author: sleepdefic1t

src/api/paths.cpp

@@ -227,6 +227,19 @@ std::pair<std::string, std::string> Ark::Client::API::Paths::Transactions::searc
   return {uri, parameterBuffer.c_str()};
 }
 
+/***/
+
+std::pair<std::string, std::string> Ark::Client::API::Paths::Transactions::send(Host& newHost, std::string& jsonTransaction) {
+  char uri[96] = {};
+  snprintf(
+    uri,
+    sizeof(uri),
+    "%s%s",
+    newHost.toString().c_str(),
+    Ark::Client::API::Paths::Transactions::base());
+  return {uri, jsonTransaction.c_str()};
+}
+
 /******/
 
 /**
@@ -345,5 +358,3 @@ std::pair<std::string, std::string> Ark::Client::API::Paths::Wallets::search(
   }
   return {uri, parameterBuffer.c_str()};
 }
-
-/***/

src/api/transactions/transactions.cpp

@@ -36,3 +36,11 @@ std::string Ark::Client::API::Transactions::search(const std::map<std::string, s
   const auto searchPathPair = Ark::Client::API::Paths::Transactions::search(this->host_, bodyParameters, limit, page);
   return http_->post(searchPathPair.first.c_str(), searchPathPair.second.c_str());
 }
+
+/***/
+
+std::string Ark::Client::API::Transactions::send(std::string& jsonTransaction) {
+  const auto pathPair = Ark::Client::API::Paths::Transactions::send(this->host_, jsonTransaction);
+  return http_->post(pathPair.first.c_str(), pathPair.second.c_str());
+};
+

src/http/iot/http.cpp

@@ -85,7 +85,9 @@ class PlatformHTTP : public AbstractHTTP {
       httpClient.setReuse(true);
       httpClient.setTimeout(3000);
       httpClient.begin(toHttpStr(request).c_str());
-      httpClient.addHeader("Content-Type", "application/x-www-form-urlencoded");
+      (body[0] == '{') // set the header content-type
+        ? httpClient.addHeader("Content-Type", "application/json")
+        : httpClient.addHeader("Content-Type", "application/x-www-form-urlencoded");
       httpClient.POST(body);
       return httpClient.getString().c_str();
     }

src/http/os/http.cpp

@@ -69,6 +69,13 @@ class PlatformHTTP : public AbstractHTTP {
       curl_easy_setopt(curl, CURLOPT_URL, request);      // Set the URL that is about to receive our POST
       curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body);  // Now specify the POST json data ex: "username=baldninja"
 
+      /* set the header content-type */
+      curl_slist *header_list = nullptr;
+      header_list = (body[0] == '{')
+        ? curl_slist_append(header_list, "Content-Type: application/json")
+        : curl_slist_append(header_list, "Content-Type: application/x-www-form-urlencoded");
+      curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header_list);
+      
       /* skip https verification */
       curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);  // Do NOT verify peer
       curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);  // Do NOT verify host

src/include/cpp-client/api/paths.h

@@ -94,6 +94,8 @@ extern std::pair<std::string, std::string> search(Host& newHost,
                                                   const std::map<std::string, std::string>& bodyParameters,
                                                   int limit = 5, int page = 1);
 /***/
+extern std::pair<std::string, std::string> send(Host& newHost, std::string& jsonTransaction);
+/***/
 };  // namespace Transactions
 
 /***/

src/include/cpp-client/api/transactions/transactions.h

@@ -34,6 +34,8 @@ class ITransactions : public API::Base {
   virtual std::string types() = 0;
   virtual std::string search(const std::map<std::string, std::string>& body_parameters, int limit = 5,
                              int page = 1) = 0;
+  virtual std::string send(std::string& jsonTransaction) = 0;
+
 };
 /**/
 class Transactions : public ITransactions {
@@ -46,6 +48,7 @@ class Transactions : public ITransactions {
   std::string allUnconfirmed(int limit = 2, int page = 1) override;
   std::string types() override;
   std::string search(const std::map<std::string, std::string>& body_parameters, int limit = 5, int page = 1) override;
+  std::string send(std::string& jsonTransaction) override;
 };
 /**/
 };  // namespace API

test/api/paths.cpp

@@ -106,6 +106,11 @@ TEST(paths, test_transactions) {  // NOLINT
   const auto search = Ark::Client::API::Paths::Transactions::search(testHost, searchBody, 5, 1);
   ASSERT_STREQ("0.0.0.0:4003/api/v2/transactions/search?limit=5&page=1", search.first.c_str());
   ASSERT_STREQ("id=dummy", search.second.c_str());
+
+  std::string jsonTransaction = "{\"id\":\"5ab523d18ac948da82700a71fc0b3c9e764fc0cba91927cb1aa63354564ad23f\",\"signature\":\"3045022100a6da60f9b3e20c80f491d168b8c51a85e0ec56a2448f9e10fc4bcc05a2bf79b8022078fa21b7d46e14c62d38f07e408fdb52f7b6a671894c6d0762913ca4a55e7a99\",\"timestamp\":4076176416,\"type\":0,\"fee\":10000000,\"senderPublicKey\":\"02f21aca9b6d224ea86a1689f57910534af21c3cc9f80602fed252c13e275f0699\",\"amount\":1,\"recipientId\":\"DHQ4Fjsyiop3qBR4otAjAu6cBHkgRELqGA\",\"vendorField\":\"7ad0eeb302ee7d9b4e58cf52daa9ece7922ad92d14f0407e3881597bf3c9c1c6\"}";
+  const auto send = Ark::Client::API::Paths::Transactions::send(testHost, jsonTransaction);
+  ASSERT_STREQ("0.0.0.0:4003/api/v2/transactions", send.first.c_str());
+  ASSERT_STREQ(jsonTransaction.c_str(), send.second.c_str());
 }
 
 /***/

test/api/transactions.cpp

@@ -575,3 +575,67 @@ TEST(api, test_transactions_search) {  // NOLINT
   const char* signature = data["signature"];
   ASSERT_STREQ("dummy", signature);
 }
+
+/* test_transactions_transactions_send
+ *
+ * Expected Response:
+ * {
+ *  "data": {
+ *      "accept": [
+ *          "dummy"
+ *      ],
+ *      "broadcast": [
+ *          "dummy"
+ *      ],
+ *      "excess": [],
+ *      "invalid": []
+ *  },
+ *  "errors": null
+ * }
+ */
+TEST(api, test_transactions_send) {  // NOLINT
+    Ark::Client::Connection<MockApi> connection("167.114.29.55", 4003);
+
+    auto apiVersion = connection.api.version();
+    ASSERT_EQ(2, apiVersion);
+
+    const std::string response = R"({
+        "data": {
+            "accept": [
+                "dummy"
+            ],
+            "broadcast": [
+                "dummy"
+            ],
+            "excess": [],
+            "invalid": []
+            },
+            "errors": null
+        })";
+
+    EXPECT_CALL(connection.api.transactions, send(_)).Times(1).WillOnce(Return(response));
+
+    std::string jsonTransaction = "{\"transactions\":[{\"type\":0,\"amount\":1,\"fee\":10000000,\"id\":\"bc5bb5cd23521c041fca17b5f78d6f3621fc07ab8f6581aff1b6eb86fa4bafe2\",\"recipientId\":\"DNSrsDUq5injGBdNXPV7v7u1Qy9LZfWEdM\",\"senderPublicKey\":\"0216fa03d378b6ad01325e186ad2cbb9d18976d5b27d0ca74b4f92bb6bf9a6d4d9\",\"signature\":\"3044022014204515b82cdd47513377d3e80e6b5f4fd1ab0fb6b4c181e09a7a30428d542502205ba076a332997053e1d31b506777a99f93bcb11294cd678ebe2da313eb02cae2\",\"timestamp\":58351951,\"vendorField\":\"7ad0eeb302ee7d9b4e58cf52daa9ece7922ad92d14f0407e3881597bf3c9c1c6\"}]}";
+    
+    const auto transaction = connection.api.transactions.send(jsonTransaction);
+
+    DynamicJsonBuffer jsonBuffer(transaction.size());
+    JsonObject& root = jsonBuffer.parseObject(transaction);
+
+    JsonObject& data = root["data"];
+
+    std::string accept = data["accept"];
+    ASSERT_TRUE(accept.length() != 0);
+
+    std::string broadcast = data["broadcast"];
+    ASSERT_TRUE(broadcast.length() != 0);
+
+    std::string excess = data["excess"];
+    ASSERT_TRUE(excess.length() == 2);
+
+    std::string invalid = data["invalid"];
+    ASSERT_TRUE(invalid.length() == 2);
+
+    std::string errors = data["errors"];
+    ASSERT_TRUE(errors.length() == 0 );
+}

test/http/http.cpp

@@ -20,7 +20,8 @@ TEST(api, test_http_get) { // NOLINT
     ASSERT_TRUE(obj.containsKey("data"));
 }
 
-TEST(api, test_http_post) { // NOLINT
+// Tests POSTing of HTTP body.
+TEST(api, test_http_post_body) { // NOLINT
     // Create the HTTP object
     const auto http = Ark::Client::makeHTTP();
 
@@ -40,6 +41,27 @@ TEST(api, test_http_post) { // NOLINT
     ASSERT_TRUE(obj.containsKey("meta"));
 }
 
+// Tests POSTing of JSON.
+TEST(api, test_http_post_json) { // NOLINT
+    // Create the HTTP object
+    const auto http = Ark::Client::makeHTTP();
+
+    // Create a Request URL and an empty Transaction JSON.
+    const auto request = "167.114.29.55:4003/api/v2/transactions";
+    const auto txJson = "{\"transactions\":[]}";
+
+    // Post the 'request' and 'txJson' for a response using HTTP
+    const auto response = http->post(request, txJson);
+
+    // Create a JSON object of the result
+    DynamicJsonBuffer jsonBuffer(response.length());
+    JsonObject& obj = jsonBuffer.parseObject(response.c_str());
+
+    // Test JSON object for the "message" key.
+    // The correct response will include the following
+    ASSERT_STREQ("child \"transactions\" fails because [\"transactions\" must contain at least 1 items]", obj["message"]);
+}
+
 // This tests the use of "http://" in single-line HTTP requests.
 TEST(api, test_http_request_strings) { // NOLINT
 

test/mocks/mock_api.h

@@ -62,6 +62,7 @@ class MockTransactions : public Ark::Client::API::ITransactions {
   MOCK_METHOD2(allUnconfirmed, std::string(int, int));
   MOCK_METHOD0(types, std::string());
   MOCK_METHOD3(search, std::string(const std::map<std::string, std::string>&, int, int));
+  MOCK_METHOD1(send, std::string(std::string&));
 };
 
 class MockVotes : public Ark::Client::API::IVotes {