rouster 0.5 → 0.7

data/test/functional/deltas/test_get_users.rb

@@ -8,7 +8,7 @@ class TestDeltasGetUsers < 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()
@@ -36,7 +36,40 @@ class TestDeltasGetUsers < Test::Unit::TestCase
 
   end
 
-  # TODO add some caching tests
+  def test_happy_path_caching
+
+    assert_nil(@app.deltas[:users])
+
+    assert_nothing_raised do
+      @app.get_users(true)
+    end
+
+    assert_equal(Hash, @app.deltas[:users].class)
+
+  end
+
+  def test_happy_path_cache_invalidation
+    res1, res2 = nil, nil
+
+    assert_nothing_raised do
+      res1 = @app.get_users(true)
+    end
+
+    first_cache_time = @app.cache[:users]
+
+    sleep (@app.cache_timeout + 1)
+
+    assert_nothing_raised do
+      res2 = @app.get_users(true)
+    end
+
+    second_cache_time = @app.cache[:users]
+
+    assert_equal(res1, res2)
+    assert_not_equal(first_cache_time, second_cache_time)
+    assert(second_cache_time > first_cache_time)
+
+  end
 
   def teardown
     @app = nil

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

@@ -75,10 +75,10 @@ class TestCaching < Test::Unit::TestCase
 
   def test_ssh_caching
 
-    skip('see comments in rouster.rb line ~84')
-
     timeout = 100
     app     = Rouster.new(:name => 'app', :sshtunnel => true, :cache_timeout => timeout)
+    app.destroy() # should be a no-op if running under rake, doing this to be safe
+
     app.up()
 
     assert_equal(app.cache_timeout, timeout)

data/test/functional/test_inspect.rb

@@ -21,7 +21,7 @@ class TestInspect < Test::Unit::TestCase
     assert_match(/status/, res)
     assert_match(/sudo\[true\]/, res)
     assert_match(/vagrantfile/, res)
-    assert_match(/verbosity\[4\]/, res)
+    assert_match(/verbosity console\[3\] \/ log\[2/, res)
   end
 
   def teardown

data/test/functional/test_is_file.rb

@@ -22,8 +22,9 @@ class TestIsFile < Test::Unit::TestCase
     @file_other_rwx = sprintf('%s/other', @dir_tmp)
     @file_644       = sprintf('%s/sixfourfour', @dir_tmp)
     @file_755       = sprintf('%s/sevenfivefive', @dir_tmp)
+    @symlink        = sprintf('%s/symlinking', @dir_tmp)
 
-    @files = [@file_user_rwx, @file_group_rwx, @file_other_rwx, @file_644, @file_755]
+    @files = [@file_user_rwx, @file_group_rwx, @file_other_rwx, @file_644, @file_755, @symlink]
   end
 
   def test_user
@@ -41,6 +42,8 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(false, @app.is_readable?(@file_user_rwx,   'o'))
     assert_equal(false, @app.is_writeable?(@file_user_rwx,  'o'))
     assert_equal(false, @app.is_executable?(@file_user_rwx, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_group
@@ -58,6 +61,8 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(false, @app.is_readable?(@file_group_rwx,   'o'))
     assert_equal(false, @app.is_writeable?(@file_group_rwx,  'o'))
     assert_equal(false, @app.is_executable?(@file_group_rwx, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_other
@@ -76,6 +81,7 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(true, @app.is_writeable?(@file_other_rwx,  'o'))
     assert_equal(true, @app.is_executable?(@file_other_rwx, 'o'))
 
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_644
@@ -93,6 +99,8 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(true, @app.is_readable?(@file_644,    'o'))
     assert_equal(false, @app.is_writeable?(@file_644,  'o'))
     assert_equal(false, @app.is_executable?(@file_644, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
   end
 
   def test_755
@@ -110,6 +118,14 @@ class TestIsFile < Test::Unit::TestCase
     assert_equal(true, @app.is_readable?(@file_755,   'o'))
     assert_equal(false, @app.is_writeable?(@file_755, 'o'))
     assert_equal(true, @app.is_executable?(@file_755, 'o'))
+
+    assert_equal(false, @app.is_symlink?(@file_755))
+  end
+
+  def test_symlink
+    @app.run("ln -s /etc/hosts #{@symlink}")
+
+    assert_equal(true, @app.is_symlink?(@symlink))
   end
 
   def teardown

data/test/functional/test_is_in_file.rb

@@ -0,0 +1,40 @@
+require sprintf('%s/../../path_helper', File.dirname(File.expand_path(__FILE__)))
+
+require 'rouster'
+require 'rouster/tests'
+require 'test/unit'
+
+class TestIsInFile < Test::Unit::TestCase
+
+  SHIBBOLETH = 'foobar'
+
+  def setup
+    assert_nothing_raised do
+      # no reason not to do this as a passthrough once we can
+      @app = Rouster.new(:name => 'app', :sudo => false)
+      @app.up()
+    end
+
+    # create some temporary files
+    @dir_tmp = sprintf('/tmp/rouster-%s.%s', $$, Time.now.to_i)
+    @app.run(sprintf('mkdir %s', @dir_tmp))
+
+    @file = sprintf('%s/file', @dir_tmp)
+    @app.run(sprintf('echo "%s" >> %s', SHIBBOLETH, @file))
+  end
+
+  def teardown; end
+
+  def test_positive
+
+    assert_equal(true, @app.is_in_file?(@file, SHIBBOLETH))
+
+  end
+
+  def test_negative
+
+    assert_equal(false, @app.is_in_file?(@file, 'fizzbuzz'))
+
+  end
+
+end

data/test/functional/test_new.rb

@@ -7,13 +7,25 @@ require 'test/unit'
 
 class TestNew < Test::Unit::TestCase
 
-  def setup
-    @app = Rouster.new(:name => 'app')
-    @app.destroy() if @app.status().eql?('running')
+  # when run under Rake, if named 'setup', @@user_sshkey is not initialized in the
+  # TestNew namespace (does not matter if running directly). since setup() really
+  # only needed to be run once anyway, this isn't a huge problem
+  def test_0_setup
+    @app = Rouster.new(:name => 'app', :sshtunnel => false)
+    @app.destroy() if @app.status().eql?('running') # TODO do we really need to do this?
     @app = nil
+
+    @@user_sshkey = sprintf('%s/.ssh/id_rsa', ENV['HOME'])
+
+    unless File.file?(@@user_sshkey)
+      #`ssh-keygen -t rsa -q -f #{@@user_sshkey} -N ''` # this will create the file, and we can track with another class variable.. but how do we safely install/uninstall this to localhost ~/.ssh/authorized_keys ?
+      File.write(@@user_sshkey, '') # either this or `touch`
+      File.chmod(0600, @@user_sshkey)
+    end
+
   end
 
-  def test_1_able_to_instantiate
+  def test_able_to_instantiate
 
     assert_nothing_raised do
       @app = Rouster.new(:name => 'app')
@@ -21,62 +33,93 @@ class TestNew < Test::Unit::TestCase
 
   end
 
-  def test_2_good_openssh_tunnel
+  def test_defaults
+
+    assert_nothing_raised do
+      @app = Rouster.new(:name => 'app')
+    end
+
+    assert_equal('app', @app.name)
+    assert_equal(false, @app.cache_timeout)
+    assert_equal(false, @app.instance_variable_get(:@logfile))
+    assert_equal(false, @app.is_passthrough?())
+    assert_equal(0, @app.retries)
+    assert_equal(true, @app.instance_variable_get(:@sshtunnel))
+    assert_equal(false, @app.instance_variable_get(:@unittest))
+    assert_equal(false, @app.instance_variable_get(:@vagrant_concurrency))
+    assert_equal(3, @app.instance_variable_get(:@verbosity_console))
+    assert_equal(2, @app.instance_variable_get(:@verbosity_logfile))
+
+  end
+
+  def test_good_openssh_tunnel
     @app = Rouster.new(:name => 'app', :sshtunnel => true)
 
     # TODO how do we properly test this? we really need the rspec should_call mechanism...
-
     assert_equal(true, @app.is_available_via_ssh?)
   end
 
-  def test_3_good_advanced_instantiation
+  def test_good_advanced_instantiation
 
     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,0],
+        #: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,
+        :logfile       => true,
       )
 
-
     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(4, @app.instance_variable_get(:@verbosity_console))
+    assert_equal(0, @app.instance_variable_get(:@verbosity_logfile))
     assert_equal(true, File.file?(@app.vagrantfile))
     assert_equal(true, File.file?(@app.sshkey))
+    assert_equal(10, @app.cache_timeout)
+
+    ## logfile validation -- do we need to do more here?
+    logfile = @app.instance_variable_get(:@logfile)
+
+    assert_not_equal(true, logfile)
+    assert(File.file?(logfile))
+
+    contents = File.read(logfile)
+    assert_not_nil(contents)
   end
 
-  def test_4_bad_name_instantiation
+  def test_bad_name_instantiation
 
+    # TODO this is probably wrong, should really be an ArgumentError
     assert_raise Rouster::InternalError do
       @app = Rouster.new(:name => 'foo')
     end
 
-    assert_raise Rouster::InternalError do
+    assert_raise Rouster::ArgumentError do
       @app = Rouster.new(:not_a_name => 'test')
     end
 
   end
 
-  def test_5_bad_vagrantfile_instantiation
+  def test_bad_vagrantfile_instantiation
 
     assert_raise Rouster::InternalError do
       @app = Rouster.new(:name => 'FIZZY') # auto find Vagrantfile
     end
 
-    assert_raise Rouster::InternalError do
+    assert_raise Rouster::ArgumentError do
       @app = Rouster.new(:name => 'testing', :vagrantfile => '/this/file/dne')
     end
 
   end
 
-  def test_6_bad_sshkey_instantiation
+  def test_bad_sshkey_instantiation
 
     assert_raise Rouster::InternalError do
       @app = Rouster.new(:name => 'app', :sshkey => '/this/file/dne')
@@ -84,9 +127,177 @@ class TestNew < Test::Unit::TestCase
 
   end
 
+  def test_good_local_passthrough
+
+    assert_nothing_raised do
+      @app = Rouster.new(:name => 'local', :passthrough => { :type => :local }, :verbosity => 4)
+    end
+
+    assert_equal('local', @app.name)
+    assert_equal(true, @app.is_passthrough?())
+    assert_equal(false, @app.uses_sudo?())
+    assert_equal(false, @app.is_available_via_ssh?())
+
+  end
+
+  def test_good_remote_passthrough
+
+    omit('not running test_good_remote_passthrough, autogenerated a fake ssh key') if File.file?(@@user_sshkey) and File.read(@@user_sshkey).eql?("")
+
+    host = '127.0.0.1'
+    `ssh -i #{@@user_sshkey} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null #{host} exit` # if this succeeds, we want to exit immediately so we don't get hung
+    omit("found an ssh key, but it doesn't appear to be valid for this host") unless $?.success?
+
+    assert_nothing_raised do
+      @app = Rouster.new(
+        :name => 'remote',
+        :sudo => false,
+        :passthrough => {
+          :type => :remote,
+          :host => host,
+          :user => ENV['USER'],
+          :key  => @@user_sshkey,
+          :paranoid => false,
+        },
+        :verbosity => 4,
+      )
+    end
+
+    assert_equal('remote', @app.name)
+    assert_equal(true, @app.is_passthrough?())
+    assert_equal(false, @app.uses_sudo?())
+    assert_equal(true, @app.is_available_via_ssh?())
+
+  end
+
+  def test_paranoia_remote_passthrough
+
+    omit('not running test_good_remote_passthrough, autogenerated a fake ssh key') if File.file?(@@user_sshkey) and File.read(@@user_sshkey).eql?("")
+
+    host = '127.0.0.1'
+    `ssh -i #{@@user_sshkey} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null #{host} exit` # if this succeeds, we want to exit immediately so we don't get hung
+    omit("found an ssh key, but it doesn't appear to be valid for this host") unless $?.success?
+
+    assert_nothing_raised do
+      @app = Rouster.new(
+          :name => 'remote',
+          :sudo => false,
+          :passthrough => {
+              :type => :remote,
+              :host => host,
+              :user => ENV['USER'],
+              :key  => @@user_sshkey,
+              :paranoid => :very,
+          },
+          :verbosity => 4,
+      )
+    end
+
+    assert_equal('remote', @app.name)
+    assert_equal(true, @app.is_passthrough?())
+    assert_equal(false, @app.uses_sudo?())
+    assert_equal(true, @app.is_available_via_ssh?())
+
+  end
+
+
+  def test_invalid_passthrough
+
+    # invalid type
+    # missing required parameters
+
+    assert_raise Rouster::ArgumentError do
+      @app = Rouster.new(:name => 'fizzy', :passthrough => {}, :verbosity => 4)
+    end
+
+    assert_raise Rouster::ArgumentError do
+      @app = Rouster.new(:name => 'fizzy', :passthrough => { :type => 'invalid' }, :verbosity => 4)
+    end
+
+    assert_raise Rouster::ArgumentError do
+      @app = Rouster.new(:name => 'fizzy', :passthrough => { :type => :remote }, :verbosity => 4)
+    end
+
+    assert_raise Rouster::ArgumentError do
+      @app = Rouster.new(:name => 'fizzy', :passthrough => { :type => :remote, :user => 'foo' }, :verbosity => 4)
+    end
+
+  end
+
+  def test_bad_passthrough
+
+    # invalid key
+    assert_raise Rouster::InternalError do
+      @app = Rouster.new(
+        :name => 'fizzy',
+        :passthrough => {
+          :type => :remote,
+          :key  => '/etc/hosts',
+          :user => 'foo',
+          :host => 'bar',
+        },
+        :verbosity => 4,
+      )
+    end
+
+    # key that DNE
+    assert_raise Rouster::ArgumentError do
+      @app = Rouster.new(
+        :name => 'fizzy',
+        :passthrough => {
+            :type => :remote,
+            :key  => '/etc/this-file-dne',
+            :user => 'foo',
+            :host => 'bar',
+        },
+        :verbosity => 4,
+      )
+    end
+
+    # host that DNE
+    assert_raise SocketError do
+      @app = Rouster.new(
+        :name => 'fizzy',
+        :passthrough => {
+          :type => :remote,
+          :key  => @@user_sshkey,
+          :user => 'foo',
+          :host => 'this.host.does.not.exist',
+
+          # don't retry.. too much
+          :ssh_sleep_ceiling => 1,
+          :ssh_sleep_time    => 1,
+        },
+
+        :sshtunnel => true,
+        :verbosity => 4,
+      )
+    end
+
+    # IP that doesn't resolve
+    assert_raise SocketError do
+      @app = Rouster.new(
+        :name => 'fizzy',
+        :passthrough => {
+          :type => :remote,
+          :key  => @@user_sshkey,
+          :user => 'foo',
+          :host => '255.256.257.258',
+
+          :ssh_sleep_ceiling => 1,
+          :ssh_sleep_time    => 1,
+        },
+
+        :sshtunnel => true,
+        :verbosity => 4,
+      )
+    end
+
+  end
 
   def teardown
-    # noop
+    # if the file is empty, we know we created it (or it doesn't matter)..
+    File.delete(@@user_sshkey) if File.file?(@@user_sshkey) and File.read(@@user_sshkey).eql?('')
   end
 
 end