etcutils 1.0.0

data/tests/test_etc_utils.rb

@@ -0,0 +1,107 @@
+require 'etcutils_test_helper'
+require "#{$eu_user}/etc_utils"
+
+class EtcUtilsTest < Test::Unit::TestCase
+  SG_MAP = Hash.new.tap do |h|
+    h[:pw] = { :file => PASSWD,  :ext => 'd'  }
+    h[:gr] = { :file => GROUP,   :ext => 'p'  }
+  end
+
+  def test_constants
+    assert_equal(EtcUtils, EU)
+    assert_equal('1.0.0', EU::VERSION)
+
+    # User DB Files
+    [:passwd, :group, :shadow, :gshadow].each do |m|
+      a = m.to_s.downcase
+      if File.exists?(f = "/etc/#{a}")
+        assert_equal(eval("EU::#{a.upcase}"), f)
+        assert EU.send("has_#{a}?"), "EtcUtils.has_#{a}? should be true."
+      end
+    end
+
+    assert_equal(EU::SHELL, '/bin/bash')
+  end
+
+  def test_reflective_methods
+    assert_not_nil(EU.me, "EU.me should not be nil")
+    assert_equal(EU.me.class, EtcUtils::Passwd, "EU.me should return EtcUtils::Passwd class")
+    assert_equal(EU.me.uid, EU.getlogin.uid)
+  end
+
+  # This could fail if there are less than 5 entries in either /etc/group or /etc/passwd
+  # This could also fail if the user cannot read from these files
+  def test_pw_gr_star_ent
+    assert_nothing_raised do
+      EU.setXXent
+    end
+
+    assert_not_nil EU.getpwent, "Should be able to read from /etc/passwd"
+    assert_not_nil EU.getgrent, "Should be able to read from /etc/group"
+    3.times do
+      EU.getpwent
+      EU.getgrent
+    end
+
+    assert_not_equal(0, (EU.getpwent).uid, "EU.getpwent should iterate through /etc/passwd")
+    assert_not_equal(0, (EU.getgrent).gid, "EU.getgrent should iterate through /etc/group")
+
+    assert_nothing_raised do
+      EU.setXXent
+    end
+
+    assert_equal(0, (EU.getpwent).uid, "EU.setXXent should reset all user DB files (/etc/passwd)")
+    assert_equal(0, (EU.getgrent).gid, "EU.setXXent should reset all user DB files (/etc/group)")
+
+    assert_nothing_raised do
+      EU.endXXent
+    end
+  end
+
+  def test_eu_find_pwd
+    assert_block("EU.setpwent should reset /etc/passwd") do
+      2.times do
+        assert_nothing_raised { setpwent }
+        assert_not_nil(u = find_pwd(0))
+        assert_equal(0, u.uid, "EU.find_pwd(0) should only return User with ID zero")
+        assert_nothing_raised { endpwent }
+      end
+    end
+  end
+
+  def test_to_entry
+    r = find_pwd(0).to_entry
+    assert_equal(r.chomp, r, "#to_entry should not have a trailing newline")
+  end
+  SG_MAP.keys.each do |xx|
+    define_method("test_fget#{xx}ent_cp#{SG_MAP[xx][:file].gsub('/','_')}")  {
+      begin
+        tmp_fn = "/tmp/_fget#{xx}ent_test"
+        assert_nothing_raised do
+          fh = File.open(SG_MAP[xx][:file], 'r')
+          File.open(tmp_fn, File::RDWR|File::CREAT, 0600) { |tmp_fh|
+            while ( ent = EtcUtils.send("fget#{xx}ent", fh) )
+              ent.fputs(tmp_fh)
+            end
+          }
+          fh.close
+          assert FileUtils.compare_file(SG_MAP[xx][:file], tmp_fn) == true, "DIFF FAILED: #{SG_MAP[xx][:file]} <=> #{tmp_fn}\n" << `diff #{SG_MAP[xx][:file]} #{tmp_fn}`
+        end
+      ensure
+        FileUtils.remove_file(tmp_fn);
+      end
+    }
+
+    define_method("test_get#{xx}") {
+      assert_nothing_raised do
+        EtcUtils.send("set#{xx}ent")
+        while ( ent = EtcUtils.send("get#{xx}ent")); nil; end
+      end
+    }
+
+    m = "find_#{xx}#{SG_MAP[xx][:ext]}"
+    define_method("test_#{m}_typeerr")  { assert_raise TypeError do; EtcUtils.send(m,{}); end }
+    define_method("test_#{m}_find_int") { assert_equal(EtcUtils.send(m, 0).name, "root", "EU.find_#{xx}#{SG_MAP[xx][:ent]}(0) should find root by ID")  }
+    define_method("test_#{m}_find_str") { assert_equal(EtcUtils.send(m, 'root').name, "root", "EU.find_#{xx}#{SG_MAP[xx][:ent]}('root') should find root by name") }
+  end
+end

data/tests/test_eu_locking.rb

@@ -0,0 +1,15 @@
+if EU.can_lockfile?
+  require 'etcutils_test_helper'
+  class EULockingTest < Test::Unit::TestCase
+    require "#{$eu_user}/locking"
+
+    def test_methods
+      assert EU.respond_to?(:lock), "Should respond to lock"
+      assert EU.respond_to?(:lckpwdf), "Should respond to lckpwdf"
+
+      assert EU.respond_to?(:locked?), "Should respond to locked?"
+      assert EU.respond_to?(:unlock), "Should respond to unlock"
+      assert EU.respond_to?(:ulckpwdf), "Should respond to ulckpwdf"
+    end
+  end
+end

data/tests/test_eu_next_uid_next_gid.rb

@@ -0,0 +1,32 @@
+require 'etcutils_test_helper'
+
+class Test::Unit::TestCase
+  [:uid, :gid].each do |m|
+    Class.new do
+      define_method("test_next_#{m}"){
+        assert(EU.send("next_#{m}"), "EU.next_#{m} should return next available #{m}")
+        assert_not_equal(EU.send("next_#{m}"), EU.send("next_#{m}"), "EU.next_#{m} should never return the same #{m}")
+      }
+
+      # #next_{u,g}id=x should always return x even if {U,G}ID x is assigned
+      # Weird #send bug where EU.send("next_uid=",0) != EU.next_uid=0
+      define_method("test_next_#{m}_equals"){
+        assert_equal(0, eval("EU.next_#{m}=0"), "EU.next_#{m}=x should return x")
+      }
+
+      define_method("test_next_#{m}_params"){
+        assert_not_equal(0, EU.send("next_#{m}", 0), "EU.next_#{m}(x) should return next available #{m} if x is unavailable")
+        assert_equal(9999, EU.send("next_#{m}", 9999), "EU.next_#{m}(x) should return #{m} if x is available")
+      }
+
+      define_method("test_next_#{m}_raises"){
+        assert_raise ArgumentError do
+          EU.send("next_#{m}", 65534)
+        end
+        assert_raise ArgumentError do
+          EU.send("next_#{m}=", -1)
+        end
+      }
+    end
+  end
+end

data/tests/test_eu_sgetpwent.rb

@@ -0,0 +1,91 @@
+require 'etcutils_test_helper'
+
+module EUGetPW
+  def self.uid
+    @free_uid ||= EUGetPW._free_uid
+  end
+
+  def self._free_uid
+    id = 9999
+    while EU.find_pwd(id) || EU.find_grp(id)
+      id+=1
+    end
+    return id
+  end
+end
+
+class EUsgetpwentTest < Test::Unit::TestCase
+  include EUGetPW
+
+  def setup
+    @uid = EUGetPW.uid
+    @username = "testuser#{@uid}"
+
+    @taken_uid = EU.getpwent.uid
+    @taken_gid = EU.getgrent.gid
+  end
+
+  def test_eu_known_sgetpwent
+    r = find_pwd(0).to_entry
+    assert_equal(r, sgetpwent(r).to_entry, "EU.sgetpwent(r) should equal (r = find_pwd(x).to_entry)")
+  end
+
+  def test_eu_changed_sgetpwent
+    r = find_pwd(0)
+    r.gecos = "Not #{r.gecos || r.name}"
+    r.directory = "/home/etc_utils"
+    r.passwd = "password"
+    r.shell  = "/bin/false"
+    ent = sgetpwent(r.to_entry)
+    assert_not_equal(find_pwd(0).to_entry, ent.to_entry, "EU.sgetpwent should respect most attribute changes")
+    assert_equal(r.gecos, ent.gecos, "EU.sgetpwent should respect #gecos changes")
+    assert_equal(r.directory, ent.directory, "EU.sgetpwent should respect #directory changes")
+    assert_equal(r.passwd, ent.passwd, "EU.sgetpwent should respect #directory changes")
+    assert_equal(r.shell, ent.shell, "EU.sgetpwent should respect #shell changes")
+  end
+
+  def test_eu_new_sgetpwent
+    if RUBY_PLATFORM =~ /darwin/    
+      new = "#{@username}:*:#{EUGetPW.uid}:#{EUGetPW.uid}::0:0:Test User:/home/testuser:/bin/bash"
+    else
+      new = "#{@username}:x:#{EUGetPW.uid}:#{EUGetPW.uid}:Test User:/home/testuser:/bin/bash"
+    end
+
+    ent = EU.sgetpwent(new)
+    assert_equal(@username, ent.name, "EU.sgetpwent should have the same name")
+    assert_equal(@uid, ent.uid, "EU.sgetpwent should return UID when available")
+    assert_equal(@uid, ent.gid, "EU.sgetpwent should return GID when available")
+
+    ent = EU.sgetpwent(new.gsub(/#{EUGetPW.uid}/,''))
+    e = EU.next_uid(9999) - 1
+    assert_equal(e, ent.uid, "EU.sgetpwent should return UID when available")
+    assert_equal(e, ent.gid, "EU.sgetpwent should return GID when available")
+  end
+
+  def test_eu_raise_sgetpwent
+    assert_raise ArgumentError do
+      if RUBY_PLATFORM =~ /darwin/
+        EU.sgetpwent(":*:1000:1000::0:0:Test User:/home/testuser:/bin/bash")
+      else
+        EU.sgetpwent(":x:1000:1000:Test User:/home/testuser:/bin/bash")
+      end
+    end
+
+    # Should raise rb_eSystemCallError if system calls fail (see README)
+    #
+    #assert_raise Errno::ENOENT do
+    #  EU.sgetpwent("testuser:x:1000:1000:Test User:/fake/path/testuser:/bin/bash")
+    #end
+  end
+
+  def test_eu_conflict_sgetpwent
+    if RUBY_PLATFORM =~ /darwin/
+      new = "#{@username}:*:#{@taken_uid}:#{@taken_gid}::0:0:Test User:/Users/test:/bin/bash"
+    else
+      new = "#{@username}:x:#{@taken_uid}:#{@taken_gid}:Test User:/home/testuser:/bin/bash"
+    end
+    ent = EU.sgetpwent(new)
+    assert_not_equal(@taken_uid, ent.uid, "EU.sgetpwent should return next availabile UID when conflict")
+    assert_not_equal(@taken_gid, ent.gid, "EU.sgetpwent should return next availabile GID when conflict")
+  end
+end

data/tests/test_group_class.rb

@@ -0,0 +1,128 @@
+require 'etcutils_test_helper'
+
+class GroupClassTest < Test::Unit::TestCase
+
+  ##
+  # Module Specific Methods
+  #
+
+  def test_set_end_ent
+    assert_nothing_raised do
+      EU.setgrent
+    end
+
+    assert_nothing_raised do
+      EU.endgrent
+    end
+  end
+
+  def test_find
+    assert_nil EtcUtils.find_grp("testuser"), "EU.find_grp should return nil if user does not exist"
+    assert_equal("root", EtcUtils.find_grp("root").name, "EU.find_grp(str) should return user if it exists")
+    assert_equal("root", EtcUtils.find_grp(0).name, "EU.find_grp(int) should return user if it exists")
+    assert_nothing_raised do
+      EU.setgrent
+    end
+    assert_equal(getgrnam('root').name, getgrent.name, "EU.getgrnam('root') and EU.getgrent should return the same user")
+  end
+
+  def test_sgetgrent
+    assert sgetgrent(find_grp('root').to_entry).name.eql? "root"
+  end
+
+  def test_getgrent_while
+    assert_nothing_raised do
+      EtcUtils.setgrent
+      while ( ent = EtcUtils.getgrent ); nil; end
+    end
+  end
+
+  def test_fgetgrent_and_putgrent
+    tmp_fn = "/tmp/_fgetsgent_test"
+    assert_nothing_raised do
+      fh = File.open('/etc/group', 'r')
+      File.open(tmp_fn, File::RDWR|File::CREAT, 0600) { |tmp_fh|
+        while ( ent = EtcUtils.fgetgrent(fh) )
+          EU.putgrent(ent, tmp_fh)
+        end
+      }
+      fh.close
+    end
+    assert File.exists?(tmp_fn), "EU.fgetgrent(fh) should write to fh"
+    assert FileUtils.compare_file("/etc/group", tmp_fn) == true,
+      "DIFF FAILED: /etc/group <=> #{tmp_fn}\n" << `diff /etc/group #{tmp_fn}`
+  ensure
+    FileUtils.remove_file(tmp_fn);
+  end
+
+  def test_putgrent_raises
+    FileUtils.touch "/tmp/_group"
+
+    assert_raise IOError do
+      f = File.open("/tmp/_group", 'r')
+      u = EU.find_grp('root')
+      u.fputs f
+    end
+  ensure
+    FileUtils.remove_file("/tmp/_group");
+  end
+
+  ##
+  # EU::Group class methods
+  #
+  def test_class_set_end_ent
+    assert_nothing_raised do
+      EU::Group.set
+    end
+
+    assert_nothing_raised do
+      EU::Group.end
+    end
+  end
+
+  def test_class_get
+    assert_not_nil EU::Group.get
+  end
+
+  def test_class_each
+    assert_nothing_raised do
+      EU::Group.each do |e|
+        assert e.name
+      end
+    end
+  end
+
+  def test_class_find
+    assert_equal "root", EU::Group.find('root').name
+  end
+
+  def test_class_parse
+    assert_nothing_raised do
+      EtcUtils::Group.parse("root:x:0:")
+    end
+  end
+
+  def test_class_parse_members
+    assert_nothing_raised do
+      assert_equal Array, EtcUtils::Group.parse("root:x:0:").members.class
+    end
+  end
+
+  ##
+  # EU::Group instance methods
+  #
+  def test_init
+    assert_equal EU::Group, EU::Group.new.class
+  end
+
+  def test_instance_methods
+    e = EU::Group.find('root')
+    assert_equal 'root', e.name
+    assert_not_nil e.passwd
+    assert_equal 0, e.gid
+    assert_equal 'root', EU::Group.parse(e.to_entry).name
+    assert_equal String, e.to_entry.class
+    assert_equal Array, e.members.class
+    assert e.respond_to?(:fputs)
+  end
+end

data/tests/test_passwd_class.rb

@@ -0,0 +1,125 @@
+require 'etcutils_test_helper'
+
+class PasswdClassTest < Test::Unit::TestCase
+
+
+  ##
+  # Module Specific Methods
+  #
+
+  def test_set_end_ent
+    assert_nothing_raised do
+      EU.setpwent
+    end
+
+    assert_nothing_raised do
+      EU.endpwent
+    end
+  end
+
+  def test_find
+    assert_nil EtcUtils.find_pwd("testuser"), "EU.find_pwd should return nil if user does not exist"
+    assert_equal("root", EtcUtils.find_pwd("root").name, "EU.find_pwd(str) should return user if it exists")
+    assert_equal("root", EtcUtils.find_pwd(0).name, "EU.find_pwd(int) should return user if it exists")
+    assert_nothing_raised do
+      EU.setpwent
+    end
+    assert_equal(getpwnam('root').name, getpwent.name, "EU.getpwnam('root') and EU.getpwent should return the same user")
+  end
+
+  def test_sgetpwent
+    assert sgetpwent(find_pwd('root').to_entry).name.eql? "root"
+  end
+
+  def test_getpwent_while
+    assert_nothing_raised do
+      EtcUtils.setpwent
+      while ( ent = EtcUtils.getpwent ); nil; end
+    end
+  end
+
+  def test_fgetpwent_and_putpwent
+    tmp_fn = "/tmp/_fgetsgent_test"
+    assert_nothing_raised do
+      fh = File.open('/etc/passwd', 'r')
+      File.open(tmp_fn, File::RDWR|File::CREAT, 0600) { |tmp_fh|
+        while ( ent = EtcUtils.fgetpwent(fh) )
+          EU.putpwent(ent, tmp_fh)
+        end
+      }
+      fh.close
+    end
+    assert File.exists?(tmp_fn), "EU.fgetpwent(fh) should write to fh"
+    assert FileUtils.compare_file("/etc/passwd", tmp_fn) == true,
+      "DIFF FAILED: /etc/passwd <=> #{tmp_fn}\n" << `diff /etc/passwd #{tmp_fn}`
+  ensure
+    FileUtils.remove_file(tmp_fn);
+  end
+
+  def test_putpwent_raises
+    FileUtils.touch "/tmp/_passwd"
+
+    assert_raise IOError do
+      f = File.open("/tmp/_passwd", 'r')
+      u = EU.find_pwd('root')
+      u.fputs f
+    end
+  ensure
+    FileUtils.remove_file("/tmp/_passwd");
+  end
+
+  ##
+  # EU::Passwd class methods
+  #
+  def test_class_set_end_ent
+    assert_nothing_raised do
+      EU::Passwd.set
+    end
+
+    assert_nothing_raised do
+      EU::Passwd.end
+    end
+  end
+
+  def test_class_get
+    assert_not_nil EU::Passwd.get
+  end
+
+  def test_class_each
+    assert_nothing_raised do
+      EU::Passwd.each do |e|
+        assert e.name
+      end
+    end
+  end
+
+  def test_class_find
+    assert_equal "root", EU::Passwd.find('root').name
+  end
+
+  def test_class_parse
+    assert_nothing_raised do
+      EtcUtils::Passwd.parse("root:x:0:0:root:/root:/bin/bash")
+    end
+  end
+
+  ##
+  # EU::Passwd instance methods
+  #
+  def test_init
+    assert_equal EU::Passwd, EU::Passwd.new.class
+  end
+
+  def test_instance_methods
+    e = EU::Passwd.find('root')
+    assert_equal 'root', e.name
+    assert_not_nil e.passwd
+    assert_equal 0, e.uid
+    assert_equal 0, e.gid
+    assert_equal '/root', e.directory
+    assert_not_nil e.shell
+    assert e.respond_to?(:fputs)
+    assert_equal 'root', EU::Passwd.parse(e.to_entry).name
+    assert_equal String, e.to_entry.class
+  end
+end