rouster 0.42 → 0.53

data/test/functional/puppet/test_facter.rb

@@ -8,7 +8,7 @@ class TestFacter < Test::Unit::TestCase
 
   def setup
     assert_nothing_raised do
-      @app = Rouster.new(:name => 'app')
+      @app = Rouster.new(:name => 'app', :cache_timeout => 10)
     end
 
     @app.up()
@@ -38,6 +38,46 @@ class TestFacter < Test::Unit::TestCase
     assert_equal(nil, @app.facts)
   end
 
+  def test_caching
+    # NOTE: this only works if (time_to_run_facter < cache_timeout)
+
+    assert_nothing_raised do
+      @app.facter(true)
+    end
+
+    first_cached_time = @app.cache[:facter]
+
+    assert_nothing_raised do
+      @app.facter(true)
+    end
+
+    second_cached_time = @app.cache[:facter]
+
+    assert_equal(first_cached_time, second_cached_time)
+
+  end
+
+  def test_cache_invalidation
+
+    assert_nothing_raised do
+      @app.facter(true)
+    end
+
+    first_cached_time = @app.cache[:facter]
+
+    sleep (@app.cache_timeout + 1)
+
+    assert_nothing_raised do
+      @app.facter(true)
+    end
+
+    second_cached_time = @app.cache[:facter]
+
+    assert_not_equal(first_cached_time, second_cached_time)
+    assert(second_cached_time > first_cached_time)
+
+  end
+
   def test_custom_facts
 
     facts = nil

data/test/functional/test_caching.rb

@@ -74,8 +74,12 @@ class TestCaching < Test::Unit::TestCase
   end
 
   def test_ssh_caching
+
+    skip('see comments in rouster.rb line ~84')
+
     timeout = 100
-    app     = Rouster.new(:name => 'app', :cache_timeout => timeout)
+    app     = Rouster.new(:name => 'app', :sshtunnel => true, :cache_timeout => timeout)
+    app.up()
 
     assert_equal(app.cache_timeout, timeout)
 

data/test/functional/test_dirs.rb

@@ -56,6 +56,31 @@ class TestDirs < Test::Unit::TestCase
 
   end
 
+  def test_case_sensitvity
+    dirs_to_create = ['Fizz', 'foo', 'baz']
+    dirs_expected_sensitive = ['foo']
+    dirs_expected_insensitive = ['Fizz', 'foo']
+
+    dirs_to_create.each do |dir|
+      @app.run(sprintf('mkdir -p %s/%s', @dir, dir))
+    end
+
+    dirs_actual_sensitive = @app.dirs(@dir, 'f*', false)
+
+    dirs_actual_sensitive.each do |dir|
+      dir = dir.gsub(/#{@dir}/, '')
+      assert(dirs_expected_sensitive.member?(dir))
+    end
+
+    dirs_actual_insensitive = @app.dirs(@dir, 'f*', true)
+
+    dirs_actual_insensitive.each do |dir|
+      dir = dir.gsub(/#{@dir}/, '')
+      assert(dirs_expected_insensitive.member?(dir))
+    end
+
+  end
+
   def teardown
     @app.run(sprintf('rm -rf %s', @dir))
   end

data/test/functional/test_get.rb

@@ -45,7 +45,8 @@ class TestGet < Test::Unit::TestCase
   def test_remote_path_dne
 
     assert_raise Rouster::FileTransferError do
-      @app.get(@kb_dne_location, @kg_local_location)
+      res = @app.get(@kb_dne_location, @kg_local_location)
+      assert_equal(false, res)
     end
 
     assert_equal(false, File.file?(@kg_local_location), 'known bad remote file path DNE')
@@ -54,7 +55,7 @@ class TestGet < Test::Unit::TestCase
   def test_with_suspended_machine
     @app.suspend()
 
-    #assert_raise Rouster::SSHConnectionError do <-- why was this ever used?
+    #assert_raise Rouster::SSHConnectionError do <-- this is what we want when the connection is bad, as opposed to permission/disk space issues
     assert_raise Rouster::FileTransferError do
       @app.get(@kg_remote_location, @kg_local_location)
     end
@@ -63,10 +64,13 @@ class TestGet < Test::Unit::TestCase
   end
 
   def teardown
-    # TODO we should suspend instead if any test failed for triage
-    #@app.destroy()
-    #@ppm.destroy()
-
     File.delete(@kg_local_location) if File.file?(@kg_local_location).true?
   end
+
+  def self.shutdown
+    # TODO we should suspend instead if any test failed for triage
+    #@app.suspend()
+    #@ppm.suspend()
+  end
+
 end

data/test/functional/test_new.rb

@@ -23,7 +23,7 @@ class TestNew < Test::Unit::TestCase
 
   def test_2_good_openssh_tunnel
     @app = Rouster.new(:name => 'app', :sshtunnel => true)
-
+                                           7
     # TODO how do we properly test this? we really need the rspec should_call mechanism...
 
     assert_equal(true, @app.is_available_via_ssh?)
@@ -33,23 +33,24 @@ class TestNew < Test::Unit::TestCase
 
     assert_nothing_raised do
       @app = Rouster.new(
-        :name        => 'app',
-        :passthrough => true,
-        :sudo        => false,
-        :verbosity   => 4,
-        #:vagrantfile => traverse_up(Dir.pwd, 'Vagrantfile'), # this is what happens anyway..
-        :sshkey      =>  ENV['VAGRANT_HOME'].nil? ? sprintf('%s/.vagrant.d/insecure_private_key', ENV['HOME']) : sprintf('%s/insecure_private_key', ENV['VAGRANT_HOME']),
+        :name          => 'app',
+        :passthrough   => false,
+        :sudo          => false,
+        :verbosity     => 4,
+        #:vagrantfile  => traverse_up(Dir.pwd, 'Vagrantfile'), # this is what happens anyway..
+        :sshkey        =>  ENV['VAGRANT_HOME'].nil? ? sprintf('%s/.vagrant.d/insecure_private_key', ENV['HOME']) : sprintf('%s/insecure_private_key', ENV['VAGRANT_HOME']),
+        :cache_timeout => 10,
       )
 
-
     end
 
     assert_equal('app', @app.name)
-    assert_equal(true, @app.is_passthrough?())
+    assert_equal(false, @app.is_passthrough?())
     assert_equal(false, @app.uses_sudo?())
     assert_equal(4, @app.verbosity) # is this going to be strinigified?
     assert_equal(true, File.file?(@app.vagrantfile))
     assert_equal(true, File.file?(@app.sshkey))
+    assert_equal(10, @app.cache_timeout)
   end
 
   def test_4_bad_name_instantiation

data/test/functional/test_put.rb

@@ -49,35 +49,33 @@ class TestPut < Test::Unit::TestCase
 
   end
 
-=begin
-TODO fix tests failing for unknown/incorrect reasons
   def test_with_suspended_machine
     @app.is_available_via_ssh?() # make sure we have a tunnel
     @app.suspend()
 
-    assert_raise Net::SSH::Disconnect do
+    #assert_raise Rouster::SSHConnectionError
+    assert_raise Rouster::FileTransferError do
       @app.put(__FILE__, @kg_local_location)
     end
 
-    assert_equal(false, @app.is_file?(@kg_local_location), 'when machine is suspended, unable to get from it')
+    #assert_equal(false, @app.is_file?(@kg_local_location), 'when machine is suspended, unable to get from it')
   end
 
   def test_with_suspended_machine_after_destroying_ssh_tunnel
-    @app._vm.channel.destroy_ssh_connection() # make sure we don't have a tunnel
+    @app.disconnect_ssh_tunnel()
     @app.suspend()
 
-    assert_raise Rouster::SSHConnectionError do
+    #assert_raise Rouster::SSHConnectionError do
+    assert_raise Rouster::FileTransferError do
       @app.put(__FILE__, @kg_local_location)
     end
 
-    assert_equal(false, @app.is_file?(@kg_local_location), 'when machine is suspended, and connection is manually destroyed, unable to get from it')
+    #assert_equal(false, @app.is_file?(@kg_local_location), 'when machine is suspended, and connection is manually destroyed, unable to get from it')
   end
-=end
 
   def teardown
-    # TODO we should suspend instead if any test failed for triage
     #@app.destroy()
-    #@ppm.destroy()
+    @app.suspend()
     File.delete(@kg_location) if File.file?(@kg_location).true?
   end
 end

data/test/functional/test_restart.rb

@@ -10,7 +10,6 @@
       assert_nothing_raised do
         @app = Rouster.new(:name => 'app', :verbosity => 4)
       end
-
     end
 
     def test_happy_path
@@ -31,7 +30,7 @@
         sleep 10
       end
 
-      new_uptime = @app.facter()['uptime_seconds'].to_i
+      new_uptime = @app.facter(false)['uptime_seconds'].to_i
 
       assert_not_equal(original_uptime, new_uptime)
       assert(original_uptime > new_uptime)

data/test/functional/test_run.rb

@@ -71,8 +71,7 @@ class TestRun < Test::Unit::TestCase
   end
 
   def teardown
-    # TODO we should suspend instead if any test failed for triage
-    #@app.destroy()
-    #@ppm.destroy()
+    @app.suspend()
+    @app_no_sudo.suspend()
   end
 end

data/test/functional/test_validate_file.rb

@@ -0,0 +1,30 @@
+require sprintf('%s/../../path_helper', File.dirname(File.expand_path(__FILE__)))
+
+require 'rouster'
+require 'rouster/puppet'
+require 'rouster/testing'
+require 'test/unit'
+
+class TestValidateFileFunctional < Test::Unit::TestCase
+
+  def setup
+    # expose private methods
+    Rouster.send(:public, *Rouster.private_instance_methods)
+    Rouster.send(:public, *Rouster.protected_instance_methods)
+
+    @app = Rouster.new(:name => 'app')
+  end
+
+  def test_negative_functional_fallthrough
+
+    assert_equal(false, @app.validate_file('/foo', {}, false, true))
+    assert_equal(false, @app.validate_file('/fizzy', { :ensure => 'directory' }, false, true))
+    assert_equal(false, @app.validate_file('/bang', { :ensure => 'file' }, false, true))
+
+  end
+
+  def teardown
+    # noop
+  end
+
+end

data/test/puppet/test_apply.rb

@@ -121,23 +121,23 @@ class TestPuppetApply < Test::Unit::TestCase
 
     # manually specified testing
     app_expected_files.each_pair do |f,e|
-      assert_equal(true, @app.validate_file(f,e))
+      assert_equal(true, @app.validate_file(f,e), "file[#{f}] expectation[#{e}]")
     end
 
     app_expected_groups.each_pair do |g,e|
-      assert_equal(true, @app.validate_group(g,e))
+      assert_equal(true, @app.validate_group(g,e), "group[#{g}] expectation[#{e}]")
     end
 
     app_expected_packages.each_pair do |p,e|
-      assert_equal(true, @app.validate_package(p, e))
+      assert_equal(true, @app.validate_package(p, e), "package[#{p}] expectation[#{e}]")
     end
 
     app_expected_services.each_pair do |s,e|
-      assert_equal(true, @app.validate_service(s,e))
+      assert_equal(true, @app.validate_service(s,e), "service[#{s}] expectation[#{e}]")
     end
 
     app_expected_users.each_pair do |u,e|
-      assert_equal(true, @app.validate_user(u,e))
+      assert_equal(true, @app.validate_user(u,e), "user[#{u}] expectation[#{e}]")
     end
 
   end

data/test/puppet/test_roles.rb

@@ -9,10 +9,23 @@ require 'test/unit'
 class TestPuppetRoles < Test::Unit::TestCase
 
   def setup
-    @ppm = Rouster.new(:name => 'ppm', :vagrantfile => '../piab/Vagrantfile')
-    @ppm.rebuild() unless @ppm.status.eql?('running') # destroy / rebuild
 
-    @app = Rouster.new(:name => 'app', :vagrantfile => '../piab/Vagrantfile')
+    piab_vagrantfile = sprintf('%s/../../../piab/Vagrantfile', File.dirname(File.expand_path(__FILE__)))
+
+    unless File.file?(piab_vagrantfile)
+      skip(sprintf('missing SFDC specific Vagrantfile[%s], skipping', piab_vagrantfile))
+    end
+
+    assert_nothing_raised do
+      @ppm = Rouster.new(:name => 'ppm', :vagrantfile => piab_vagrantfile)
+      @ppm.up()
+      @ppm.remove_existing_certs('ppm')
+      #@ppm.rebuild() unless @ppm.status.eql?('running') # destroy / rebuild
+    end
+
+    assert_nothing_raised do
+      @app = Rouster.new(:name => 'app', :vagrantfile => piab_vagrantfile)
+    end
 
     assert_nothing_raised do
 		  @ppm.run_puppet('master', { :expected_exitcode => [0,2] })

data/test/unit/test_parse_ls_string.rb

@@ -327,6 +327,30 @@ class TestParseLsString < Test::Unit::TestCase
 
   end
 
+  def test_suid
+    str = "drwxr-sr-x 2 root root 4096 Oct  7 17:09 /etc/nagios/objects\n"
+
+    skip('need to improve (read: implement) actual suid support')
+
+    expectation = {
+      :directory?  => true,
+      :file?       => false,
+      :mode        => '4755', # right now, we return '0755', if we detect an 's', do we just +4000?
+      :name        => '/etc/nagios/objects',
+      :owner       => 'root',
+      :group       => 'root',
+      :size        => '4096',
+      :executable? => [true, true, true], # right now, we return [true,false,true]
+      :readable?   => [true, true, true],
+      :writeable?  => [true, false, false],
+    }
+
+    res = @app.exposed_parse_ls_string(str)
+
+    assert_equal(expectation, res)
+
+  end
+
   def teardown
     # noop
   end

data/test/unit/testing/test_validate_file.rb

@@ -48,67 +48,60 @@ class TestValidateFile < Test::Unit::TestCase
 
   def test_positive_basic
 
-    assert(@app.validate_file('/etc/hosts', { :ensure => 'file', :mode => '0644', :file => true, :directory => false,  :owner => 'root', :group => 'root' }, true))
-    assert(@app.validate_file('/etc/hosts', { :exists => 'present' }, true ))
-    assert(@app.validate_file('/etc/hosts', { }, true ))
-    assert(@app.validate_file('/etc/hosts', { :mode => '0644' }, true))
-    assert(@app.validate_file('/etc/hosts', { :permissions => '0644' }, true))
-    assert(@app.validate_file('/etc/hosts', { :size => 166 }, true ))
-    assert(@app.validate_file('/etc/hosts', { :size => '166' }, true ))
-    assert(@app.validate_file('/etc/hosts', { :file => 'true' }, true))
-    assert(@app.validate_file('/etc/hosts', { :file => true }, true))
-    assert(@app.validate_file('/etc/hosts', { :directory => 'false' }, true))
-    assert(@app.validate_file('/etc/hosts', { :directory => false }, true))
-    assert(@app.validate_file('/etc/hosts', { :owner => 'root' }, true))
-    assert(@app.validate_file('/etc/hosts', { :group => 'root' }, true))
-
-    assert(@app.validate_file('/etc/fizzbang', { :ensure => 'absent' }, true))
-    assert(@app.validate_file('/etc/fizzbang', { :ensure => false }, true ))
-
-    assert(@app.validate_file('/etc', { :ensure => 'directory' }, true))
-    assert(@app.validate_file('/etc', { :ensure => 'dir' }, true))
-    assert(@app.validate_file('/etc', { :ensure => 'dir', :file => 'false' }, true))
-    assert(@app.validate_file('/etc', { :ensure => 'dir', :directory => 'true' }, true))
-    assert(@app.validate_file('/etc', { :ensure => 'dir', :file => 'false', :directory => 'true' }, true))
-
-    assert(@app.validate_file('/fizzy', { :ensure => 'absent' }, true))
-    assert(@app.validate_file('/fizzy', { :ensure => false }, true))
-    assert(@app.validate_file('/fizzy', { :exists => 'false' }, true))
-    assert(@app.validate_file('/fizzy', { :exists => false }, true))
-
-    # TODO need to do :contains testing in a non-unit context
+    assert(@app.validate_file('/etc/hosts', { :ensure => 'file', :mode => '0644', :file => true, :directory => false,  :owner => 'root', :group => 'root' }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :exists => 'present' }, false, true ))
+    assert(@app.validate_file('/etc/hosts', { }, false, true ))
+    assert(@app.validate_file('/etc/hosts', { :mode => '0644' }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :permissions => '0644' }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :size => 166 }, false, true ))
+    assert(@app.validate_file('/etc/hosts', { :size => '166' }, false, true ))
+    assert(@app.validate_file('/etc/hosts', { :file => 'true' }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :file => true }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :directory => 'false' }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :directory => false }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :owner => 'root' }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :group => 'root' }, false, true))
+
+    assert(@app.validate_file('/etc/fizzbang', { :ensure => 'absent' }, false, true))
+    assert(@app.validate_file('/etc/fizzbang', { :ensure => false }, false, true ))
+
+    assert(@app.validate_file('/etc', { :ensure => 'directory' }, false, true))
+    assert(@app.validate_file('/etc', { :ensure => 'dir' }, false, true))
+    assert(@app.validate_file('/etc', { :ensure => 'dir', :file => 'false' }, false, true))
+    assert(@app.validate_file('/etc', { :ensure => 'dir', :directory => 'true' }, false, true))
+    assert(@app.validate_file('/etc', { :ensure => 'dir', :file => 'false', :directory => 'true' }, false, true))
+
+    assert(@app.validate_file('/fizzy', { :ensure => 'absent' }, false, true))
+    assert(@app.validate_file('/fizzy', { :ensure => false }, false, true))
+    assert(@app.validate_file('/fizzy', { :exists => 'false' }, false, true))
+    assert(@app.validate_file('/fizzy', { :exists => false }, false, true))
 
   end
 
   def test_positive_constrained
 
-    assert(@app.validate_file('/etc/hosts', { :mode => '0644', :constrain => 'is_virtual true' }, true))
+    assert(@app.validate_file('/etc/hosts', { :mode => '0644', :constrain => 'is_virtual true' }, false, true))
 
   end
 
   def test_negative_basic
 
-    assert_equal(false, @app.validate_file('/etc/hosts', { :mode => '0777' }, true))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :permissions => '0777' }, true))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :file => 'false' }, true ))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :file => false }, true))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :directory => 'true' }, true))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :directory => true }, true))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :size => 'foo' }, true))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :size => 100 }, true))
-    assert_equal(false, @app.validate_file('/etc/hosts', { :size => '100'}, true))
-
-    # TODO figure out how to run these in a truly unit-y way, since the data is not present in faked hash, we will fall through to functional testing
-    assert_equal(false, @app.validate_file('/foo', {}, true))
-    assert_equal(false, @app.validate_file('/fizzy', { :ensure => 'directory' }, true))
-    assert_equal(false, @app.validate_file('/bang', { :ensure => 'file' }, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :mode => '0777' }, false, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :permissions => '0777' }, false, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :file => 'false' }, false, true ))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :file => false }, false, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :directory => 'true' }, false, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :directory => true }, false, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :size => 'foo' }, false, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :size => 100 }, false, true))
+    assert_equal(false, @app.validate_file('/etc/hosts', { :size => '100'}, false, true))
 
   end
 
   def test_negative_constrained
 
-    assert(@app.validate_file('/etc/hosts', { :mode => '0644', :constrain => 'is_virtual false' }, true))
-    assert(@app.validate_file('/etc/hosts', { :mode => '0999', :constrain => 'is_virtual false' }, true))
+    assert(@app.validate_file('/etc/hosts', { :mode => '0644', :constrain => 'is_virtual false' }, false, true))
+    assert(@app.validate_file('/etc/hosts', { :mode => '0999', :constrain => 'is_virtual false' }, false, true))
 
   end