Support auth token (#90)

README.md

@@ -123,6 +123,9 @@ const auto response = influxdb->execute("SHOW DATABASES");
 An underlying transport is fully configurable by passing an URI:
 ```
 [protocol]://[username:password@]host:port[?db=database]
+
+# Auth token:
+[protocol]://[token@]host:port[?db=database]
 ```
 <br>
 List of supported transport is following:

src/HTTP.cxx

@@ -96,6 +96,11 @@ namespace influxdb::transports
         session.SetAuth(cpr::Authentication{user, pass, cpr::AuthMode::BASIC});
     }
 
+    void HTTP::setAuthToken(const std::string& token)
+    {
+        session.SetHeader(cpr::Header{{"Authorization", "Token " + token}});
+    }
+
     void HTTP::send(std::string&& lineprotocol)
     {
         session.SetUrl(cpr::Url{endpointUrl + "/write"});

src/HTTP.h

@@ -64,6 +64,10 @@ namespace influxdb::transports
         /// \param pass password
         void setBasicAuthentication(const std::string& user, const std::string& pass);
 
+        /// Sets the API token for authentication
+        /// \param token API token
+        void setAuthToken(const std::string& token);
+
         /// Sets proxy
         void setProxy(const Proxy& proxy) override;
 

src/InfluxDBFactory.cxx

@@ -42,10 +42,14 @@ namespace influxdb
         std::unique_ptr<Transport> withHttpTransport(const http::url& uri)
         {
             auto transport = std::make_unique<transports::HTTP>(uri.url);
-            if (!uri.user.empty())
+            if (!uri.user.empty() && !uri.password.empty())
             {
                 transport->setBasicAuthentication(uri.user, uri.password);
             }
+            else if (!uri.password.empty())
+            {
+                transport->setAuthToken(uri.password);
+            }
             return transport;
         }
 

src/UriParser.h

@@ -115,8 +115,15 @@ namespace http
         const auto search = ExtractSearch(in);
         const auto path = ExtractPath(in);
         std::string userpass = ExtractUserpass(in);
-        const auto password = ExtractPassword(userpass);
-        const auto user = userpass;
+
+        auto [password, user] = [](auto str)
+        {
+            if (str.find(":") != std::string::npos)
+            {
+                return std::make_pair(ExtractPassword(str), str);
+            }
+            return std::make_pair(str, std::string{""});
+        }(userpass);
         const auto port = ExtractPort(in);
         const auto host = in;
 

test/CMakeLists.txt

@@ -37,6 +37,7 @@ add_unittest(InfluxDBTest DEPENDS InfluxDB)
 add_unittest(InfluxDBFactoryTest DEPENDS InfluxDB)
 add_unittest(ProxyTest DEPENDS InfluxDB)
 add_unittest(HttpTest DEPENDS InfluxDB-Core InfluxDB-Internal InfluxDB-BoostSupport CprMock Threads::Threads)
+add_unittest(UriParserTest)
 
 add_unittest(NoBoostSupportTest)
 target_sources(NoBoostSupportTest PRIVATE ${PROJECT_SOURCE_DIR}/src/NoBoostSupport.cxx)
@@ -53,6 +54,7 @@ add_custom_target(unittest PointTest
     COMMAND InfluxDBFactoryTest
     COMMAND ProxyTest
     COMMAND HttpTest
+    COMMAND UriParserTest
     COMMAND NoBoostSupportTest
     COMMAND $<$<AND:$<BOOL:${INFLUXCXX_WITH_BOOST}>,$<NOT:$<PLATFORM_ID:Windows>>>:BoostSupportTest>
 

test/HttpTest.cxx

@@ -225,6 +225,14 @@ namespace influxdb::test
         http.setBasicAuthentication("user0", "pass0");
     }
 
+    TEST_CASE("Set auth token sets auth header", "[HttpTest]")
+    {
+        auto http = createHttp();
+
+        REQUIRE_CALL(sessionMock, SetHeader(_)).WITH(_1.at("Authorization") == "Token not-a-real-api-token");
+        http.setAuthToken("not-a-real-api-token");
+    }
+
     TEST_CASE("Set proxy without authentication", "[HttpTest]")
     {
         auto http = createHttp();

test/UriParserTest.cxx

@@ -0,0 +1,83 @@
+// MIT License
+//
+// Copyright (c) 2020-2023 offa
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "UriParser.h"
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/trompeloeil.hpp>
+
+namespace influxdb::test
+{
+    namespace
+    {
+        http::url parse(std::string in)
+        {
+            return http::ParseHttpUrl(in);
+        }
+    }
+
+
+    TEST_CASE("Parse url", "[UriParserTest]")
+    {
+        const std::string input{"https://xyz.com/fghi/jklm"};
+        const auto url = parse(input);
+
+        CHECK(url.protocol == "https");
+        CHECK(url.user == "");
+        CHECK(url.password == "");
+        CHECK(url.host == "xyz.com");
+        CHECK(url.path == "/fghi/jklm");
+        CHECK(url.search == "");
+        CHECK(url.url == input);
+        CHECK(url.port == 0);
+    }
+
+    TEST_CASE("Parse protocol", "[UriParserTest]")
+    {
+        CHECK(parse("http://xyz.com").protocol == "http");
+        CHECK(parse("https://xyz.com").protocol == "https");
+        CHECK(parse("udp://xyz.com").protocol == "udp");
+        CHECK(parse("unix://xyz.com").protocol == "unix");
+    }
+
+    TEST_CASE("Parse param", "[UriParserTest]")
+    {
+        CHECK(parse("http://xyz.com/aaa?param=value").search == "param=value");
+    }
+
+    TEST_CASE("Parse port", "[UriParserTest]")
+    {
+        CHECK(parse("http://xyz.com:12345").port == 12345);
+    }
+
+    TEST_CASE("Parse basic auth", "[UriParserTest]")
+    {
+        const auto url = parse("https://aaa:bbb@host0");
+        CHECK(url.user == "aaa");
+        CHECK(url.password == "bbb");
+    }
+
+    TEST_CASE("Parse auth token", "[UriParserTest]")
+    {
+        CHECK(parse("http://token@xyz.com").password == "token");
+    }
+
+}