@@ -2,7 +2,7 @@ CXXFLAGS += -fPIC -fno-stack-protector -std=c++14

 CFLAGS += -fPIC -fno-stack-protector

 OBJS = dual_control.o request.o dual_control_integrate.o validator.o conversation.o user.o \

-	   sys_unistd.o sys_pwd.o token.o file_reader.o

+	   sys_unistd.o sys_pwd.o token.o sys_fstream.o

 TESTS = dual_control_test validator_test conversation_test request_test user_test token_test

 TESTOBJS = $(patsubst %,%.o,$(TESTS))

 SRCS := $(OBJS:.o=.cc) $(TESTOBJS:.o=.cc)

deleted file mode 100644

@@ -1,28 +0,0 @@

-#include <fstream>

-

-#include "file_reader.h"

-

-namespace {

-class file_reader_impl : public file_reader_ifc

-{

-public:

-    bool open (std::ifstream &token_file, const std::string &file_path)

-    {

-        token_file.open (file_path);

-        return token_file.good();

-    }

-    std::string getline (std::ifstream &token_file, std::string &line)

-    {

-        std::getline (token_file, line);

-        return line;

-    }

-};

-

-}

-

-file_reader file_reader::create ()

-{

-    return file_reader (file_reader::delegate (new

-                        file_reader_impl ));

-}

-

deleted file mode 100644

@@ -1,58 +0,0 @@

-/* Copyright (C) CJ Affiliate

- *

- * You may use, distribute and modify this code under  the

- * terms of the  GNU General Public License  version 2  or

- * later.

- *

- * You should have received a copy of the license with this

- * file. If not, you will find a copy in the "LICENSE" file

- * at https://github.com/cjdev/dual-control.

- */

-

-#ifndef _FILE_READER_H

-#define _FILE_READER_H

-

-#include <string>

-#include <memory>

-

-#include "user.h"

-

-

-class file_reader_ifc

-{

-public:

-    virtual bool open (std::ifstream &token_file, const std::string &file_path)

-    {

-        return false;

-    }

-    virtual std::string getline (std::ifstream &token_file,

-                                 std::string &line)

-    {

-        return "";

-    }

-};

-

-class file_reader : public file_reader_ifc

-{

-public:

-    typedef std::shared_ptr<file_reader_ifc> delegate;

-private:

-    delegate delegate_;

-public:

-    file_reader (delegate delegate) :

-        delegate_ (delegate) {}

-    file_reader() : delegate_ (delegate (new file_reader_ifc)) {}

-    bool open (std::ifstream &token_file, const std::string &file_path)

-    {

-        return delegate_->open (token_file, file_path);

-    }

-    std::string getline (std::ifstream &token_file, std::string &line)

-    {

-        return delegate_->getline (token_file, line);

-    }

-

-    static file_reader create ();

-};

-

-#endif

-

new file mode 100644

@@ -0,0 +1,23 @@

+#include <memory>

+#include <fstream>

+

+#include "sys_fstream.h"

+

+namespace {

+class impl : public fstreams_ifc {

+    public:

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

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

+        }

+};

+

+

+}

+

+

+fstreams fstreams::create()  {

+    static fstreams singleton(delegate(new impl));

+    return singleton;

+}

+

+

new file mode 100644

@@ -0,0 +1,31 @@

+#ifndef SYS_FSTREAM_H

+#define SYS_FSTREAM_H

+

+#include <memory>

+#include <sstream>

+

+class fstreams_ifc {

+    public:

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

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

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

+        }

+};

+

+class fstreams : public fstreams_ifc {

+    public:

+        typedef std::shared_ptr<fstreams_ifc> delegate;

+    private:

+        delegate delegate_;

+    public:

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

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

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

+            return delegate_->open_fstream(file_path);

+        }

+        static fstreams create();

+};

+

+

+#endif

+

@@ -16,35 +16,36 @@

 #include "token.h"

 #include "user.h"

+#include "sys_fstream.h"

 namespace

 {

 class user_token_supplier_impl : public user_token_supplier_ifc

 {

 private:

-    file_reader file_reader_;

+    fstreams fstreams_;

 public:

-    user_token_supplier_impl (file_reader &file_reader) : file_reader_

-        (file_reader) {}

+    user_token_supplier_impl (fstreams &fstreams) :

+        fstreams_(fstreams) {}

     std::string token (user &user)

     {

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

-        std::ifstream token_file;

-        std::string fetched_token;

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

-        bool token_file_opened = file_reader_.open (token_file, file_path);

+        fstreams::pstream stream(fstreams_.open_fstream(file_path));

-        if (!token_file_opened) {

+        if (!stream->good()) {

             return "";

         }

-        return file_reader_.getline (token_file, fetched_token);

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

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

     }

 };

 }

-user_token_supplier user_token_supplier::create (file_reader &file_reader)

+user_token_supplier user_token_supplier::create (fstreams &fstreams)

 {

     return user_token_supplier (user_token_supplier::delegate

-                                (new user_token_supplier_impl (file_reader)));

+                                (new user_token_supplier_impl (fstreams)));

 }

@@ -16,7 +16,7 @@

 #include <memory>

 #include "user.h"

-#include "file_reader.h"

+#include "sys_fstream.h"

 class user_token_supplier_ifc

 {

@@ -43,7 +43,7 @@ public:

     {

         return delegate_->token (user);

     }

-    static user_token_supplier create (file_reader &file_reader);

+    static user_token_supplier create (fstreams &fstreams);

 };

 #endif

@@ -15,36 +15,12 @@

 #include <cstdio>

 #include <sys/stat.h>

 #include <fstream>

+#include <sstream>

 #include "token.h"

 #include "test_util.h"

 #include "user.h"

-#include "file_reader.h"

-

-class fake_file_reader : public file_reader_ifc

-{

-private:

-    std::string file_path_;

-public:

-    bool open (std::ifstream &token_file, const std::string &file_path)

-    {

-        file_path_ = file_path;

-        return true;

-    }

-    std::string getline (std::ifstream &token_file, std::string &fetched_token)

-    {

-        return file_path_;

-    }

-};

-

-class file_reader_with_open_fail : public file_reader_ifc

-{

-public:

-    bool open (std::ifstream &token_file, std::string &fetched_token)

-    {

-        return false;

-    }

-};

+#include "sys_fstream.h"

 class fake_user : public user_ifc

 {

@@ -62,32 +38,57 @@ public:

     }

 };

+class fake_fstreams : public fstreams_ifc {

+    private:

+        std::string expected_file_path_;

+        std::string file_contents_;

+    public:

+        fake_fstreams(const std::string &expected_file_path, const std::string &file_contents)

+            : expected_file_path_(expected_file_path),

+              file_contents_(file_contents) {}

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

+            if (file_path == expected_file_path_) {

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

+            } else {

+                return fstreams_ifc::open_fstream(file_path);

+            }

+

+        }

+};

+

 int reads_from_the_right_file ()

 {

     //given

     std::string home_directory = "/somedir";

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

+    // hardcoded file name is .dual_control in the user's home directory

+    std::string token_file = home_directory + "/.dual_control";

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

+    fstreams test_streams(fstreams::delegate(new fake_fstreams(token_file, token)));

+

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

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

     user_token_supplier supplier (user_token_supplier::create (

-                                      test_file_reader));

+                                      test_streams));

     //when

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

     //then

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

-    check (actual == expected, "read wrong file");

+    check (actual == token, "token does not match");

     succeed();

 }

 int returns_empty_string_if_file_open_fail()

 {

     //given

-    file_reader test_file_reader (file_reader::delegate (new

-                                  file_reader_with_open_fail));

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

+    std::string home_directory = "/somedir";

+    // hardcoded file name is .dual_control in the user's home directory

+    std::string token_file = home_directory + "/.not_dual_control";

+    fstreams test_streams(fstreams::delegate(new fake_fstreams(token_file, "654321")));

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

     user_token_supplier supplier (user_token_supplier::create (

-                                      test_file_reader));

+                                      test_streams));

+

     //when

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