@@ -1,8 +1,9 @@

 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

-TESTS = dual_control_test validator_test conversation_test request_test

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

+	   sys_unistd.o sys_pwd.o

+TESTS = dual_control_test validator_test conversation_test request_test user_test

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

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

new file mode 100644

@@ -0,0 +1,35 @@

+/* 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.

+ */

+

+#include "sys_pwd.h"

+

+#include <pwd.h>

+

+namespace

+{

+class impl : public pwd_ifc

+{

+public:

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

+                    size_t buffer_sz, passwd **result)

+    {

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

+    }

+

+};

+static pwd system_pwd (pwd::delegate (new impl));

+}

+

+pwd pwd::system()

+{

+    return system_pwd;

+}

+

new file mode 100644

@@ -0,0 +1,49 @@

+/* 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 _SYS_PWD_H

+#define _SYS_PWD_H

+

+#include <memory>

+#include <pwd.h>

+

+class pwd_ifc

+{

+public:

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

+                            size_t buffer_sz, passwd **result)

+    {

+        *result = 0;

+        return 0;

+    };

+};

+

+class pwd : public pwd_ifc

+{

+public:

+    typedef std::shared_ptr<pwd_ifc> delegate;

+

+private:

+    delegate delegate_;

+

+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)

+    {

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

+    }

+    static pwd system();

+};

+

+#endif

+

new file mode 100644

@@ -0,0 +1,32 @@

+/* 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.

+ */

+

+#include "sys_unistd.h"

+#include <unistd.h>

+

+namespace

+{

+class impl : public unistd_ifc

+{

+public:

+    long int sysconf (int name)

+    {

+        return ::sysconf (name);

+    }

+};

+static unistd sys_unistd (unistd::delegate (new impl));

+}

+

+unistd unistd::system()

+{

+    return sys_unistd;

+}

+

new file mode 100644

@@ -0,0 +1,47 @@

+/* 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 _SYS_UNISTD_H_

+#define _SYS_UNISTD_H_

+

+#include <memory>

+

+#include <unistd.h>

+

+class unistd_ifc

+{

+public:

+    virtual long int sysconf (int name)

+    {

+        return -1;

+    }

+};

+

+class unistd : public unistd_ifc

+{

+public:

+    typedef std::shared_ptr<unistd_ifc> delegate;

+

+private:

+    delegate delegate_;

+

+public:

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

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

+    long int sysconf (int name)

+    {

+        return delegate_->sysconf (name);

+    }

+    static unistd system();

+};

+

+#endif

+

@@ -11,25 +11,44 @@

 #include <memory>

 #include <vector>

-#include <string>

-#include <pwd.h>

-#include <unistd.h>

-#include <iostream>

 #include "user.h"

-#include "test_support.h"

+#include "sys_unistd.h"

+#include "sys_pwd.h"

-user::user (struct passwd *sys_info) : info (sys_info)

+namespace

 {

+class directory_impl : public directory_ifc

+{

+private:

+    unistd unistd_;

+    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<char> buffer (unistd_.sysconf (_SC_GETPW_R_SIZE_MAX));

+        passwd sys_passwd;

+        passwd *found_passwd (0);

+        int result = pwd_.getpwnam_r (user_name.c_str(), &sys_passwd,

+                                      buffer.data(), buffer.size(), &found_passwd);

+        std::vector<user> return_value;

+

+        if (!result && found_passwd) {

+            return_value.push_back (user());

+        }

+

+        return return_value;

+    }

+};

 }

-std::string user::home_directory()

+directory directory::create (unistd &unistd, pwd &pwd)

 {

-    return info->pw_dir;

+    return directory (delegate (new directory_impl (unistd, pwd)));

 }

-// concrete user implementation

-

+/*

 class concrete_user : public user

 {

 private:

@@ -65,4 +84,5 @@ const std::shared_ptr<user> create_user (const std::string &user_name)

     return rval;

 }

+*/

@@ -14,7 +14,9 @@

 #include <vector>

 #include <string>

 #include <memory>

-#include <pwd.h>

+

+#include "sys_unistd.h"

+#include "sys_pwd.h"

 class user_ifc

 {

@@ -43,19 +45,20 @@ public:

 class directory : public directory_ifc

 {

+public:

+    typedef std::shared_ptr<directory_ifc> delegate;

 private:

-    std::shared_ptr<directory_ifc> delegate_;

+    delegate delegate_;

 public:

-    directory (std::shared_ptr<directory_ifc> delegate) : delegate_

+    directory (delegate delegate) : delegate_

         (delegate) {}

-    directory() : directory (std::shared_ptr<directory_ifc>

-                                 (new directory_ifc)) {}

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

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

     {

         return delegate_->find_user (user_name);

     }

-    static directory create();

+    static directory create (unistd &unistd, pwd &pwd);

 };

 #endif

@@ -9,87 +9,162 @@

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

  */

-#include <memory>

-#include <iostream>

 #include "user.h"

 #include "test_util.h"

+#include "sys_pwd.h"

+#include "sys_unistd.h"

-bool gets_home_directory()

+class fake_pwd : public pwd_ifc

+{

+private:

+    std::string expected_user_name_;

+public:

+    fake_pwd (const std::string expected_user_name) : expected_user_name_

+        (expected_user_name) {}

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

+                    size_t buffer_sz, passwd **result)

+    {

+        if (expected_user_name_ == user_name)  {

+            *result = out;

+        } else {

+            *result = 0;

+        }

+

+        return 0;

+    }

+};

+

+class match_buffer_pwd : public pwd_ifc

+{

+private:

+    long int expected_buffer_sz_;

+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)

+    {

+

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

+            *result = out;

+        } else {

+            *result = 0;

+        }

+

+        return 0;

+    }

+};

+

+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)

+    {

+        *result = out;

+        return 3;

+    }

+

+};

+

+class fake_unistd : public unistd_ifc

+{

+private:

+    int expected_name_;

+    long int return_value_;

+public:

+    fake_unistd (int expected_name, long int return_value = 0)

+        : expected_name_ (expected_name),

+          return_value_ (return_value) {}

+    long int sysconf (int name)

+    {

+        if (name == expected_name_) {

+            return return_value_;

+        }

+

+        return -1;

+    }

+};

+

+int find_user_happy()

 {

     //given

-    const char *expected_home_directory = "home/msmith";

-    struct passwd test_passwd;

-    test_passwd.pw_dir = const_cast<char *> (expected_home_directory);

-    user test_user (&test_passwd);

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

+    pwd test_pwd (pwd::delegate (new fake_pwd (user_name)));

+    unistd test_unistd (unistd::delegate (new fake_unistd (

+            _SC_GETPW_R_SIZE_MAX)));

+    directory directory (directory::create (test_unistd, test_pwd));

     //when

-    std::string actual_home_directory = test_user.home_directory();

+    std::vector<user> results = directory.find_user (user_name);

     //then

-    check (expected_home_directory == actual_home_directory,

-           "directories do not match");

-    return expected_home_directory == actual_home_directory;

+    check (!results.empty(), "user should have been found");

+    succeed();

 }

-std::shared_ptr<struct passwd> fake_passwd;

-int fake_getpwnam_r (const char *nam, struct passwd *pwd, char *buffer,

-                     size_t bufsize, struct passwd **result)

+int user_not_found()

 {

-    if (fake_passwd) {

-        *pwd = *fake_passwd;

-        *result = pwd;

-        return 0;

-    }

+    //given

+    pwd test_pwd (pwd::delegate (new fake_pwd ("user")));

+    unistd test_unistd (unistd::delegate (new fake_unistd (

+            _SC_GETPW_R_SIZE_MAX)));

+    directory directory (directory::create (test_unistd, test_pwd));

+

+    //when

+    std::vector<user> results = directory.find_user ("not_user");

+

+    //then

+    check (results.empty(), "user should not have been found");

+    succeed();

-    return -1;

 }

-bool create_user_succeeds()

+int find_user_passes_buffer_and_size()

 {

-    // given

-    std::string username ("msmith");

-    std::string home_directory ("this is my home");

-    fake_passwd.reset (new struct passwd);

-    fake_passwd->pw_dir = const_cast<char *> (home_directory.c_str());

+    //given

+    long int buffer_sz = 5976;

+    unistd test_unistd (unistd::delegate (new fake_unistd (_SC_GETPW_R_SIZE_MAX,

+                                          buffer_sz)));

+    pwd match_pwd (pwd::delegate (new match_buffer_pwd (buffer_sz)));

+    directory directory (directory::create (test_unistd, match_pwd));

-    // when

-    std::shared_ptr<user> user (create_user (username));

+    //when

+    std::vector<user> results = directory.find_user ("does_not_matter");

     // then

-    check (user, "user should be returned");

-    check (user->home_directory() == home_directory,

-           "home directory does not match");

-

+    check (!results.empty(), "match failed");

     succeed();

-

 }

-bool create_user_nonexistent()

+int find_user_fails_on_pwnam_r_error_and_result_ok()

 {

-    // given

-    std::string username ("msmith");

+    //given

+    unistd test_unistd (unistd::delegate (new fake_unistd (

+            _SC_GETPW_R_SIZE_MAX)));

+    pwd stub_pwd (pwd::delegate (new stub_pwnam_err_pwd));

+    directory directory (directory::create (test_unistd, stub_pwd));

-    // when

-    std::shared_ptr<user> user (create_user (username));

+    //when

+    std::vector<user> results = directory.find_user ("does_not_matter");

     // then

-    check (!user, "no user should be returned");

-

+    check (results.empty(), "did not check return");

     succeed();

 }

 RESET_VARS_START

-fake_passwd.reset ((struct passwd *)0);

 RESET_VARS_END

 int run_tests()

 {

-    test (gets_home_directory);

-    test (create_user_succeeds);

-    test (create_user_nonexistent);

+    test (find_user_happy);

+    test (user_not_found);

+    test (find_user_passes_buffer_and_size);

+    test (find_user_fails_on_pwnam_r_error_and_result_ok);

     succeed();

 }

-int main (int argc, char *argv[])

+

+int main (int argc, char **argv)

 {

     return !run_tests();

 }