/* 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 "user.h"
 #include "test_util.h"

 #include "sys_pwd.h"
 #include "sys_unistd.h"
 

 class fake_pwd : public pwd_ifc
 {
 private:
     std::string expected_user_name_;

     std::string home_directory_;

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

     {
         if (expected_user_name_ == user_name)  {

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

             *result = out;
         } else {

             *result = 0;
         }

 
         return 0;
     }

 };
 

 class match_buffer_pwd : public pwd_ifc
 {
 private:
     long int expected_buffer_sz_;

     std::string charbuf_;

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

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

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

             *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) const override

     {
         *result = out;
         return 3;
     }

 
 };
 

 class fake_unistd : public unistd_ifc
 {
 private:

     int expected_sysconf_name_;
     const char *expected_username_;

     long int return_value_;
 public:

     fake_unistd (int expected_sysconf_name, long int return_value = 0,
                  const char *expected_username = "<unspecified>")

         : expected_sysconf_name_ (expected_sysconf_name),
           expected_username_ (expected_username),

           return_value_ (return_value) {}

     long int sysconf (int name) const override

     {

         if (name == expected_sysconf_name_) {

             return return_value_;

         }

 
         return -1;
     }

     const char *getlogin() const override
     {

         return expected_username_;
     }

 };

 int find_user_happy()
 {

     //given

     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::vector<user> results = directory.find_user (user_name);

 
     //then

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

     succeed();

 }
 

 int user_not_found()
 {

     //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();

 }
 

 int find_user_passes_buffer_and_size()
 {

     //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::vector<user> results = directory.find_user ("does_not_matter");

 
     // then

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

     succeed();
 }
 

 int find_user_fails_on_pwnam_r_error_and_result_ok()
 {

     //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::vector<user> results = directory.find_user ("does_not_matter");

 
     // then

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

     succeed();
 }
 

 int get_current_user_happy_path()
 {
     //given
     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,
                                           0, user_name.c_str())));

     directory directory (directory::create (test_unistd, test_pwd));
 
     //when
     std::vector<user> results = directory.get_current_user();
 
     //then
     check (!results.empty(), "user should have been found");

     check (! (results[0].home_directory() == user_name),
            "user should have been found");

     succeed();
 }
 
 int get_current_user_nullptr_path()
 {
     //given

     pwd test_pwd (pwd::delegate (new fake_pwd ("<unspecified>")));
     unistd test_unistd (unistd::delegate (new fake_unistd (_SC_GETPW_R_SIZE_MAX,
                                           0, nullptr)));

     directory directory (directory::create (test_unistd, test_pwd));
 
     //when
     std::vector<user> results = directory.get_current_user();
 
     //then
     check (results.empty(), "user should have been found");
     succeed();
 }
 

 int run_tests()
 {
     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);

     test (get_current_user_happy_path);
     test (get_current_user_nullptr_path);

     succeed();
 }

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

     return !run_tests();
 }