@@ -32,6 +32,7 @@ class system init_system()

     class system system (stdlib, time);

     return system;

 }

+

 installer init_installer()

 {

     fstreams fstreams (fstreams::create());

@@ -53,6 +54,6 @@ int main (int argc, char *argv[])

 {

     class system system (init_system());

     installer tool (init_installer());

-    std::string generated_key = tool.install_key();

-    std::cout << generated_key << std::endl;

+    auto generated_key_and_sample_token = tool.install_key();

+    std::cout << generated_key_and_sample_token.first << " " << generated_key_and_sample_token.second << std::endl;

 }

@@ -11,12 +11,14 @@

 #include <string>

 #include <vector>

+#include <utility>

 #include "installer.h"

 #include "token.h"

 #include "sys_unistd.h"

 #include "user.h"

 #include "generator.h"

+#include "base32.h"

 namespace

 {

@@ -34,19 +36,23 @@ public:

           const totp_generator generator) :

         tokens_ (tokens), unistd_ (unistd), directory_ (directory),

         generator_ (generator) {}

-    std::string install_key() const override

+    std::pair<std::string, std::string> install_key() const override

     {

         auto found_user = directory_.get_current_user ();

         if (found_user.empty()) {

-            return "";

+            return {"", ""};

         }

         user user (found_user[0]);

-        std::string key = tokens_.ensure_key(user);

+        std::string key_string = tokens_.ensure_key(user);

+        std::vector<uint8_t> key = base32().decode(key_string);

+        std::string decoded_key (key.begin(), key.end());

+        std::string token = generator_.generate_token(decoded_key);

-        return key;

+        // TODO: fix generator input

+        return {key_string, token};

     }

 };

@@ -15,6 +15,7 @@

 #include <string>

 #include <memory>

 #include <functional>

+#include <utility>

 #include "token.h"

 #include "sys_unistd.h"

@@ -24,9 +25,9 @@

 class installer_ifc

 {

 public:

-    virtual std::string install_key() const

+    virtual std::pair<std::string, std::string> install_key() const

     {

-        return "123456";

+        return {"AAAA", "123456"};

     }

 };

@@ -39,7 +40,7 @@ private:

 public:

     installer (const delegate &delegate = std::make_shared<installer_ifc>()) :

         delegate_ (delegate) {}

-    std::string install_key() const

+    std::pair<std::string, std::string> install_key() const

     {

         return delegate_->install_key();

     }

@@ -13,6 +13,7 @@

 #include <memory>

 #include <string>

 #include <vector>

+#include <tuple>

 #include "installer.h"

 #include "user.h"

@@ -117,23 +118,25 @@ int installs_token()

     //given

     std::string user_name ("user");

     std::string key ("thekey");

+    std::string token ("thetoken");

     auto  test_tokens = std::make_shared<mock_tokens>(key);

     tokens tokens{test_tokens};

     unistd unistd (std::make_shared<fake_unistd> (user_name));

     directory directory (std::make_shared<fake_directory> (user_name));

-    std::shared_ptr<fake_totp_generator> fake_generator =

-        std::make_shared<fake_totp_generator> ();

-    totp_generator generator (fake_generator);

+    std::shared_ptr<fake_totp_generator> fake_generator = std::make_shared<fake_totp_generator> (token);

+    totp_generator generator (fake_generator );

     installer installer = installer::create (tokens, unistd, directory,

                           generator);

     //when

-    std::string result = installer.install_key();

+    std::string actual_key, actual_token;

+    std::tie(actual_key, actual_token) = installer.install_key();

     //then

-    check (test_tokens->captured_token == key, "installed wrong token");

-    check (result == key, "installer returned wrong token");

+    check (test_tokens->captured_token == key, "installed wrong key");

+    check (actual_key == key, "installer returned wrong key");

+    check (actual_token == token, "installer returned wrong token");

     succeed();

 }

@@ -176,12 +179,17 @@ int unistd_does_not_find_user_name_empty_string_case()

                           generator);

     //when

-    auto returned = installer.install_key();

+    std::string actual_key, actual_token;

+    std::tie(actual_key, actual_token) = installer.install_key();

     //then

+    // TODO: rethink this...

     check (test_tokens->captured_token == "",

            "should not have installed a token");

-    check (returned == "", "did not return empty token");

+    check (actual_key == "",

+           "should not have installed a token");

+    check (actual_token == "",

+           "should not have installed a token");

     succeed();

 }

@@ -199,11 +207,13 @@ int directory_finds_no_user_info()

                           generator);

     //when

-    auto returned = installer.install_key();

+    std::string actual_key, actual_token;

+    std::tie(actual_key, actual_token) = installer.install_key();

     //then

-    check (test_tokens->captured_token == "", "installed wrong token");

-    check (returned == "", "did not return empty token");

+    check (test_tokens->captured_token == "", "installed wrong key");

+    check (actual_key == "", "did not return empty token");

+    check (actual_token == "", "did not return an empty token");

     succeed();

 }