Binary files a/conversation_test.out and b/conversation_test.out differ

Binary files a/dual_control_test.out and b/dual_control_test.out differ

Binary files a/logger_test.out and b/logger_test.out differ

Binary files a/request_test.out and b/request_test.out differ

Binary files a/session_test.out and b/session_test.out differ

@@ -11,6 +11,7 @@

 #include <memory>

 #include <fstream>

+#include <iostream>

 #include "sys_fstream.h"

@@ -19,10 +20,14 @@ namespace

 class impl : public fstreams_ifc

 {

 public:

-    pstream open_fstream (const std::string &file_path)

+    pstream open_fstream (const std::string &file_path) const override

     {

         return pstream (new std::ifstream (file_path));

     }

+    postream open_ofstream (const std::string &file_path, std::ios_base::open_mode mode) const override {

+        return postream(new std::ofstream(file_path, mode));

+    }

+

 };

 }

@@ -14,16 +14,21 @@

 #include <memory>

 #include <sstream>

+#include <iostream>

 class fstreams_ifc

 {

 public:

     typedef std::shared_ptr<std::istream> pstream;

+    typedef std::shared_ptr<std::ostream> postream;

     virtual ~fstreams_ifc() {}

-    virtual pstream open_fstream (const std::string &file_path)

+    virtual pstream open_fstream (const std::string &file_path) const

     {

         return pstream (new std::istringstream (""));

     }

+    virtual postream open_ofstream(const std::string &file_path, std::ios_base::openmode mode) const {

+        return postream(new std::ostringstream(""));

+    }

 };

 class fstreams

@@ -34,12 +39,17 @@ private:

     delegate delegate_;

 public:

     typedef fstreams_ifc::pstream pstream;

+    typedef fstreams_ifc::postream postream;

     fstreams (const delegate &delegate) : delegate_ (delegate) {}

     fstreams() : fstreams (delegate (new fstreams_ifc)) {}

-    pstream open_fstream (const std::string &file_path)

+    pstream open_fstream (const std::string &file_path) const

     {

         return delegate_->open_fstream (file_path);

     }

+    postream open_ofstream (const std::string &file_path, std::ios_base::openmode mode) const

+    {

+        return delegate_->open_ofstream (file_path, mode);

+    }

     static fstreams create();

 };

@@ -13,6 +13,8 @@

 #include <vector>

 #include <memory>

 #include <fstream>

+#include <iostream>

+#include <functional>

 #include "token.h"

 #include "user.h"

@@ -24,10 +26,12 @@ class tokens_impl : public tokens_ifc

 {

 private:

     fstreams fstreams_;

+    token_generator generate_token_;

 public:

-    tokens_impl (fstreams &fstreams) :

+    tokens_impl (const fstreams &fstreams, const token_generator &generate_token) :

+        generate_token_(generate_token),

         fstreams_ (fstreams) {}

-    std::string token (user &user)

+    std::string token (const user &user) const override

     {

         const std::string file_path (user.home_directory() + "/.dual_control");

         std::vector<char> line (7);

@@ -41,11 +45,17 @@ public:

         stream->getline (line.data(), line.size());

         return std::string (line.data());

     }

+    void create(const user &user) const override {

+        std::string generated_token(generate_token_());

+        std::string file_path(user.home_directory() + "/.dual_control");

+        fstreams::postream stream(fstreams_.open_ofstream(file_path, std::ios_base::trunc));

+        *stream << generated_token << std::endl;

+    }

 };

 }

-tokens tokens::create (fstreams &fstreams)

+tokens tokens::create (const fstreams &fstreams, const tokens_impl::token_generator &generate_token)

 {

     return tokens (tokens::delegate

-                                (new tokens_impl (fstreams)));

+                                (new tokens_impl (fstreams, generate_token)));

 }

@@ -14,6 +14,7 @@

 #include <string>

 #include <memory>

+#include <functional>

 #include "user.h"

 #include "sys_fstream.h"

@@ -21,11 +22,13 @@

 class tokens_ifc

 {

 public:

+    using token_generator = std::function<std::string()>;

     virtual ~tokens_ifc() {}

-    virtual std::string token (user &user)

+    virtual std::string token (const user &user) const

     {

         return "";

     }

+    virtual void create(const user &user) const {}

 };

 class tokens

@@ -39,11 +42,14 @@ public:

         delegate_ (delegate) {}

     tokens() : tokens (

             delegate (new tokens_ifc)) {}

-    std::string token (user &user)

+    std::string token (const user &user) const

     {

         return delegate_->token (user);

     }

-    static tokens create (fstreams &fstreams);

+    void create(const user &user) const {

+        return delegate_->create(user);

+    }

+    static tokens create (const fstreams &fstreams, const tokens_ifc::token_generator &generate_token);

 };

 #endif

@@ -32,12 +32,30 @@ public:

         home_directory_ (home_directory)

     {

     }

-    std::string home_directory()

+    std::string home_directory() const override

     {

         return home_directory_;

     }

 };

+class mock_write_fstreams: public fstreams_ifc {

+    private:

+        mutable std::string captured_filename_;

+        mutable std::shared_ptr<std::ostringstream> capture_stream_;

+    public:

+        postream open_ofstream (const std::string &file_path, std::ios_base::open_mode mode) const override {

+            captured_filename_ = file_path;

+            capture_stream_ = std::make_shared<std::ostringstream>();

+            return capture_stream_;

+        }

+        std::string captured_filename() {

+            return captured_filename_;

+        }

+        std::string captured_written() {

+            return capture_stream_->str();

+        }

+};

+

 class fake_fstreams : public fstreams_ifc

 {

 private:

@@ -48,7 +66,7 @@ public:

                    const std::string &file_contents)

         : expected_file_path_ (expected_file_path),

           file_contents_ (file_contents) {}

-    pstream open_fstream (const std::string &file_path)

+    pstream open_fstream (const std::string &file_path) const override

     {

         if (file_path == expected_file_path_) {

             return fstreams::pstream (new std::istringstream (file_contents_));

@@ -72,7 +90,7 @@ int reads_from_the_right_file ()

     //file_reader test_file_reader (file_reader::delegate (new fake_file_reader));

     user test_user (user::delegate (new fake_user (home_directory)));

     tokens supplier (tokens::create (

-                                      test_streams));

+                                      test_streams,[]{return"";}));

     //when

     std::string actual = supplier.token (test_user);

@@ -92,7 +110,7 @@ int returns_empty_string_if_file_open_fail()

                            "654321")));

     user test_user (user::delegate (new fake_user (home_directory)));

     tokens supplier (tokens::create (

-                                      test_streams));

+                                      test_streams, []{return "";}));

     //when

     std::string actual = supplier.token (test_user);

@@ -102,13 +120,34 @@ int returns_empty_string_if_file_open_fail()

     succeed();

 }

-RESET_VARS_START

-RESET_VARS_END

+int writes_the_token () {

+    // given

+    std::string home_directory("/somedir");

+    user test_user(user::delegate(new fake_user(home_directory)));

+    mock_write_fstreams *mockfs(new mock_write_fstreams);

+    fstreams test_streams{fstreams::delegate(mockfs)};

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

+    tokens tokens(tokens::create(test_streams, [&]{return token;}));

+

+    //when

+    tokens.create(test_user);

+

+   // then

+    std::ostringstream temp;

+    temp << token << std::endl;

+    std::string expected_written = temp.str();

+    std::string expected_filename(home_directory + "/.dual_control");

+    check(mockfs->captured_filename() == expected_filename, "filename does not match");

+    check(mockfs->captured_written() == expected_written, "token does not match");

+   succeed();

+}

+

 int run_tests()

 {

     test (reads_from_the_right_file);

     test (returns_empty_string_if_file_open_fail);

+    test (writes_the_token);

     succeed();

 }

Binary files a/token_test.out and b/token_test.out differ

@@ -27,7 +27,7 @@ public:

     user_impl (const passwd user_info) :

         home_directory_ (std::string (user_info.pw_dir)),

         user_name_ (std::string (user_info.pw_name)) {}

-    std::string home_directory()

+    std::string home_directory() const override

     {

         return home_directory_;

     }

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

     pwd pwd_;

 public:

     directory_impl (unistd &unistd, pwd &pwd) : unistd_ (unistd), pwd_ (pwd) {}

-    std::vector<user> find_user (const std::string &user_name)

+    std::vector<user> find_user (const std::string &user_name) override

     {

         std::vector<char> buffer (unistd_.sysconf (_SC_GETPW_R_SIZE_MAX));

         passwd sys_passwd;

@@ -22,9 +22,9 @@ class user_ifc

 {

 public:

     virtual ~user_ifc() {}

-    virtual std::string home_directory()

+    virtual std::string home_directory() const

     {

-        return "virtual";

+        return "";

     }

 };

@@ -39,7 +39,7 @@ public:

     {

     }

     user() : user (delegate (new user_ifc)) {}

-    std::string home_directory()

+    std::string home_directory() const

     {

         return delegate_-> home_directory();

     }

Binary files a/user_test.out and b/user_test.out differ

@@ -28,7 +28,7 @@ public:

         tokens_ (tokens) {}

     bool validate (const std::string &requester_user_name,

                    const std::string &authorizer_user_name,

-                   const std::string &token)

+                   const std::string &token) override

     {

         std::vector<user> found_user = directory_.find_user (authorizer_user_name);

@@ -27,7 +27,7 @@ public:

     }

     fake_directory() : user_name_ ("_NOT_A_USER") {}

-    std::vector<user> find_user (const std::string &user_name)

+    std::vector<user> find_user (const std::string &user_name) override

     {

         std::vector<user> result;

@@ -46,7 +46,7 @@ private:

 public:

     fake_tokens (const std::string &token) : token_ (token) {}

     fake_tokens() : token_ ("_NOT_A_TOKEN") {}

-    std::string token (user &user)

+    std::string token (const user &user) const override

     {

         return token_;

     }

Binary files a/validator_test.out and b/validator_test.out differ