new file mode 100644

@@ -0,0 +1,38 @@

+#include <string>

+#include <vector>

+

+#include "installer.h"

+#include "token.h"

+#include "sys_unistd.h"

+#include "user.h"

+

+namespace {

+

+class impl : public installer_ifc {

+    private:

+        tokens tokens_;

+        unistd unistd_;

+        directory directory_;

+        generator generator_;

+    public:

+        impl(const tokens &tokens, const unistd &unistd,

+            const directory &directory, const installer_ifc::generator &generator) :

+            tokens_(tokens), unistd_(unistd), directory_(directory), generator_(generator) {}

+        std::string install_token() const override {

+            std::string user_name = unistd_.getlogin();

+            auto found_user = directory_.find_user(user_name);

+            user user(found_user[0]);

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

+            tokens_.save(user, token);

+            return "123456";

+        }

+};

+

+}

+

+

+installer installer::create(const tokens &tokens, const unistd &unistd,

+        const directory &directory, const installer_ifc::generator &generator) {

+    return installer(std::make_shared<impl>(tokens, unistd, directory, generator));

+}

+

@@ -2,12 +2,37 @@

 #define INSTALLER_H_

 #include <string>

+#include <memory>

+#include <functional>

-class installer {

+#include "token.h"

+#include "sys_unistd.h"

+#include "user.h"

+

+

+class installer_ifc {

     public:

-        std::string install_token() {

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

+        virtual std::string install_token() const {

             return "123456";

         }

 };

+class installer {

+    public:

+        using delegate = std::shared_ptr<installer_ifc>;

+    private:

+        delegate delegate_;

+    public:

+        installer(const delegate &delegate = std::make_shared<installer_ifc>()) : delegate_(delegate) {}

+        std::string install_token() const {

+            return delegate_->install_token();

+        }

+        static installer create(const tokens &tokens, const unistd &unistd,

+            const directory &directory, const installer_ifc::generator &generator);

+};

+

+

+

+

 #endif

@@ -1,19 +1,76 @@

+#include <functional>

+#include <memory>

+#include <string>

+#include <vector>

+

 #include "installer.h"

+#include "user.h"

+#include "token.h"

+#include "test_util.h"

+

+class mock_tokens : public tokens_ifc {

+    public:

+        mutable std::string captured_token;

+        void save (const user &user, const std::string &token) const override {

+            captured_token = token;

+        }

+};

+

+class fake_unistd : public unistd_ifc {

+    private:

+        std::string user_name_;

+    public:

+        fake_unistd(const std::string &user_name) : user_name_(user_name) {}

+        const char *getlogin() const override {

+            return user_name_.c_str();

+        }

+};

-int first_test() {

+class fake_directory : public directory_ifc {

+    private:

+        std::string expected_user_name_;

+    public:

+        fake_directory(const std::string &expected_user_name) : expected_user_name_(expected_user_name) {

+        }

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

+            std::vector<user> rval;

+            if (user_name == expected_user_name_) {

+                rval.push_back(user());

+            }

+            return rval;

+        }

+

+};

+

+int installs_token() {

     //given

-/*    generator generator

-    tokens tokens

-    installer installer //= create (generator, tokens);

+    user user;

+    std::string user_name("user");

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

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

+    tokens tokens{test_tokens};

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

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

+    installer_ifc::generator generator = [&] { return token; };

+

+    installer installer = installer::create (tokens, unistd, directory, generator);

     //when

     installer.install_token();

     //then

-    tokens.captured user == expected user

-    token.captured  token == generated token

-*/

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

+    succeed();

 }

-int main(int argc, char *argv[]) {return 0;}

+

+

+int run_tests() {

+    test(installs_token);

+    succeed();

+}

+

+int main(int argc, char *argv[]) {

+    return !run_tests();

+}

@@ -19,7 +19,7 @@ class impl : public pwd_ifc

 {

 public:

     int getpwnam_r (const char *user_name, passwd *out, char *buffer,

-                    size_t buffer_sz, passwd **result)

+                    size_t buffer_sz, passwd **result) const override

     {

         return ::getpwnam_r (user_name, out, buffer, buffer_sz, result);

     }

@@ -20,7 +20,7 @@ class pwd_ifc

 public:

     virtual ~pwd_ifc() {}

     virtual int getpwnam_r (const char *user_name, passwd *out, char *buffer,

-                            size_t buffer_sz, passwd **result)

+                            size_t buffer_sz, passwd **result) const

     {

         *result = 0;

         return 0;

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

     pwd (const delegate delegate) : delegate_ (delegate) {}

     pwd() : delegate_ (delegate (new pwd_ifc)) {}

     int getpwnam_r (const char *user_name, passwd *out, char *buffer,

-                    size_t buffer_sz, passwd **result)

+                    size_t buffer_sz, passwd **result) const

     {

         return delegate_-> getpwnam_r (user_name, out, buffer, buffer_sz, result);

     }

@@ -17,7 +17,7 @@ namespace

 class impl : public unistd_ifc

 {

 public:

-    long int sysconf (int name)

+    long int sysconf (int name) const override

     {

         return ::sysconf (name);

     }

@@ -20,10 +20,13 @@ class unistd_ifc

 {

 public:

     virtual ~unistd_ifc() {}

-    virtual long int sysconf (int name)

+    virtual long int sysconf (int name) const

     {

         return -1;

     }

+    virtual const char *getlogin() const {

+        return "";

+    }

 };

 class unistd

@@ -37,10 +40,13 @@ private:

 public:

     unistd (delegate delegate): delegate_ (delegate) {}

     unistd() : delegate_ (delegate (new unistd_ifc)) {}

-    long int sysconf (int name)

+    long int sysconf (int name) const

     {

         return delegate_->sysconf (name);

     }

+    const char *getlogin() const {

+        return delegate_->getlogin();

+    }

     static unistd create();

 };

@@ -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) override

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

     {

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

         passwd sys_passwd;

@@ -50,7 +50,7 @@ class directory_ifc

 {

 public:

     virtual ~directory_ifc() {}

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

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

     {

         return std::vector<user>();

     }

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

     directory (delegate delegate) : delegate_

         (delegate) {}

     directory() : directory (delegate (new directory_ifc)) {}

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

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

     {

         return delegate_->find_user (user_name);

     }

@@ -23,7 +23,7 @@ public:

     fake_pwd (const std::string expected_user_name) : expected_user_name_

         (expected_user_name), home_directory_ ("/somehome") {}

     int getpwnam_r (const char *user_name, passwd *out, char *buffer,

-                    size_t buffer_sz, passwd **result)

+                    size_t buffer_sz, passwd **result) const override

     {

         if (expected_user_name_ == user_name)  {

             out->pw_dir = const_cast<char *> (home_directory_.c_str());

@@ -45,7 +45,7 @@ private:

 public:

     match_buffer_pwd (long int buffer_sz) : expected_buffer_sz_ (buffer_sz) {}

     int getpwnam_r (const char *user_name, passwd *out, char *buffer,

-                    size_t buffer_sz, passwd **result)

+                    size_t buffer_sz, passwd **result) const override

     {

         if (expected_buffer_sz_ == buffer_sz && buffer != 0) {

@@ -64,7 +64,7 @@ class stub_pwnam_err_pwd : public pwd_ifc

 {

 public:

     int getpwnam_r (const char *user_name, passwd *out, char *buffer,

-                    size_t buffer_sz, passwd **result)

+                    size_t buffer_sz, passwd **result) const override

     {

         *result = out;

         return 3;

@@ -81,7 +81,7 @@ public:

     fake_unistd (int expected_name, long int return_value = 0)

         : expected_name_ (expected_name),

           return_value_ (return_value) {}

-    long int sysconf (int name)

+    long int sysconf (int name) const override

     {

         if (name == expected_name_) {

             return return_value_;

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

     }

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

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

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

     {

         std::vector<user> result;