rouster 0.5 → 0.7

data/test/basic.rb

@@ -5,6 +5,9 @@ require 'rouster/puppet'
 require 'rouster/testing'
 require 'rouster/tests'
 
-p = Rouster.new(:name => 'app', :verbosity => 0)
+#a = Rouster.new(:name => 'app', :verbosity => 1, :vagrantfile => '../piab/Vagrantfile', :retries => 3)
+#p = Rouster.new(:name => 'ppm', :verbosity => 1, :vagrantfile => '../piab/Vagrantfile')
+#r = Rouster.new(:name => 'app', :verbosity => 1, :vagrantfile => 'Vagrantfile')
+l = Rouster.new(:name => 'local', :passthrough => { :type => :local }, :verbosity => 3)
 
 p 'DBGZ' if nil?

data/test/functional/deltas/test_get_crontab.rb

@@ -8,7 +8,7 @@ class TestDeltasGetCrontab < Test::Unit::TestCase
 
   def setup
     assert_nothing_raised do
-      @app = Rouster.new(:name => 'app')
+      @app = Rouster.new(:name => 'app', :cache_timeout => 20)
     end
 
     @app.up()
@@ -92,8 +92,70 @@ class TestDeltasGetCrontab < Test::Unit::TestCase
 
   end
 
+  def test_happy_path_cache_invalidated
+
+    res1, res2 = nil, nil
+
+    assert_nothing_raised do
+      res1 = @app.get_crontab('root', true)
+    end
+
+    first_cache_time = @app.cache[:crontab]
+
+    sleep (@app.cache_timeout + 1)
+
+    assert_nothing_raised do
+      res2 = @app.get_crontab('root', true)
+    end
+
+    second_cache_time = @app.cache[:crontab]
+
+    assert_equal(res1, res2)
+    assert_not_equal(first_cache_time, second_cache_time)
+
+  end
+
+  def test_unhappy_duplicate_entries
+
+    res = nil
+
+    # do this in a saner way? crontab call is overwriting existing records
+    user = 'puppet'
+    tmp  = sprintf('/tmp/rouster.tmp.crontab.%s.%s.%s', user, Time.now.to_i, $$)
+    @app.run("echo '0 0 * * * echo #{user}' > #{tmp}")
+    @app.run("echo '5 5 * * * echo #{user}' >> #{tmp}")
+    @app.run("crontab -u #{user} #{tmp}")
+
+    assert_nothing_raised do
+      res = @app.get_crontab(user)
+    end
+
+    assert_equal(Hash, res.class)
+    assert(res.has_key?('echo puppet'))
+    assert(res.has_key?('echo puppet-duplicate.55***echopuppet'))
+
+  end
+
+  def test_non_matching_lines
+    res  = nil
+    user = 'root'
+    tmp  = sprintf('/tmp/rouster.tmp.crontab.%s.%s.%s', user, Time.now.to_i, $$)
+
+    @app.run("echo 'PATH=/sbin:/usr/bin:/usr/local/bin' > #{tmp}")
+    @app.run("echo '5 5 * * * echo #{user}' >> #{tmp}")
+    @app.run("crontab -u #{user} #{tmp}")
+
+    assert_nothing_raised do
+      res = @app.get_crontab(user, false)
+    end
+
+    assert_equal(Hash, res.class)
+    assert(res.has_key?('echo root'))
+
+  end
+
   def teardown
     @app = nil
   end
 
-end
+end

data/test/functional/deltas/test_get_groups.rb

@@ -8,7 +8,7 @@ class TestDeltasGetGroups < 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()
@@ -39,7 +39,79 @@ class TestDeltasGetGroups < Test::Unit::TestCase
 
   end
 
-  # TODO add some non-caching tests
+  def test_without_caching
+    old_groups, new_groups = nil, nil
+
+    assert_nothing_raised do
+      old_groups = @app.get_groups(false)
+    end
+
+    assert_nil(@app.deltas[:groups])
+
+    new_group = sprintf('rouster-%s', Time.now.to_i)
+
+    ## create a group here
+    if @app.os_type.eql?(:rhel)
+      @app.run(sprintf('groupadd %s', new_group))
+    else
+      omit('only doing group creation on RHEL hosts')
+    end
+
+    assert_nothing_raised do
+      new_groups = @app.get_groups(false)
+    end
+
+    assert_nil(@app.deltas[:groups])
+    assert_not_nil(new_groups[new_group])
+    assert_not_equal(old_groups, new_groups)
+
+  end
+
+  def test_deep_inspection
+    deep, shallow = nil, nil
+
+    assert_nothing_raised do
+      deep    = @app.get_groups(false, true)
+      shallow = @app.get_groups(false, false)
+    end
+
+    assert_not_equal(deep, shallow)
+
+    ## this is not really the best test
+    deep_none, shallow_none = 0, 0
+
+    deep.each_key do |group|
+      deep_none += 1 if deep[group][:users][0].eql?('NONE')
+    end
+
+    shallow.each_key do |group|
+      shallow_none += 1 if shallow[group][:users][0].eql?('NONE')
+    end
+
+    assert(shallow_none > deep_none)
+  end
+
+  def test_happy_path_cache_invalidation
+    res1, res2 = nil, nil
+
+    assert_nothing_raised do
+      res1 = @app.get_groups(true, false)
+    end
+
+    first_cache_time = @app.cache[:groups]
+
+    sleep (@app.cache_timeout + 1)
+
+    assert_nothing_raised do
+      res2 = @app.get_groups(true, false)
+    end
+
+    second_cache_time = @app.cache[:groups]
+
+    assert_equal(res1, res2)
+    assert_not_equal(first_cache_time, second_cache_time)
+
+  end
 
   def teardown
     @app = nil

data/test/functional/deltas/test_get_os.rb

@@ -0,0 +1,68 @@
+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 teardown
+    # put the flag file back in place
+    Rouster.os_files.each_pair do |_os, ff|
+      [ ff ].flatten.each do |f|
+        bkup = sprintf('%s.bkup', f)
+        if @app.is_file?(bkup)
+          @app.run(sprintf('mv %s %s', bkup, f))
+        end
+      end
+    end
+  end
+
+  def test_happy_path
+
+    type = @app.os_type
+    assert_not_nil(type, sprintf('unable to determine vm[%s] OS', @app))
+    assert_not_equal(:invalid, type)
+
+    version = @app.os_version(type)
+    assert_not_nil(version, sprintf('unable to determine vm[%s] OS version', @app))
+    assert_not_equal(:invalid, version)
+
+    assert_nothing_raised do
+      @app.get_services
+    end
+
+  end
+
+  def test_unhappy_path
+    # move the flag file out of the way
+    Rouster.os_files.each_pair do |_os, ff|
+      [ ff ].flatten.each do |f|
+        if @app.is_file?(ff)
+          @app.run(sprintf('mv %s %s.bkup', f, f))
+        end
+      end
+    end
+
+    type = @app.os_type
+
+    assert_equal(:invalid, type, sprintf('got wrong value for unmarked OS[%s]', type))
+
+    e = assert_raise do
+      @app.get_services
+    end
+
+    assert_equal(Rouster::InternalError, e.class, sprintf('wrong exception raised[%s] [%s]', e.class, e.message))
+
+  end
+
+end

data/test/functional/deltas/test_get_packages.rb

@@ -10,7 +10,7 @@ class TestDeltasGetPackages < 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()
@@ -30,7 +30,17 @@ class TestDeltasGetPackages < Test::Unit::TestCase
 
     res.each_key do |k|
       assert_not_nil(res[k])
-      assert_match(/^\d+/, res[k]) # start with a number
+
+      if res[k].is_a?(Array)
+        res[k].each do |l|
+          assert(l.has_key?(:arch))
+          assert(l.has_key?(:version))
+        end
+      else
+        assert(res[k].has_key?(:arch))
+        assert(res[k].has_key?(:version))
+      end
+
     end
 
   end
@@ -55,11 +65,68 @@ class TestDeltasGetPackages < Test::Unit::TestCase
       res = @app.get_packages(true, false)
     end
 
-    res.each_key do |k|
-      assert_not_nil(res[k])
+    # RHEL processing doesn't do anything different in deep/not-deep calls
+    if ! (@app.os_type.eql?(:rhel) or @app.os_type.eql?(:ubuntu))
+      res.each_key do |k|
+        assert_not_nil(res[k])
+        assert_match(/\?/, res[k][:arch])
+      end
+    end
+
+  end
+
+  def test_happy_path_cache_invalidation
+    res1, res2 = nil, nil
+
+    assert_nothing_raised do
+      res1 = @app.get_packages(true, false)
+    end
+
+    first_cache_time = @app.cache[:packages]
+
+    sleep (@app.cache_timeout + 1)
+
+    assert_nothing_raised do
+      res2 = @app.get_packages(true, false)
+    end
+
+    second_cache_time = @app.cache[:packages]
+
+    assert_equal(res1, res2)
+    assert_not_equal(first_cache_time, second_cache_time)
+    assert(second_cache_time > first_cache_time)
+
+  end
 
-      #assert_match(/\d*\..*/, res[k]) # testing the regular expression used in deltas.rb itself
-      assert_match(/\?/, res[k])
+  def test_arch_determination
+    after, install = nil, nil
+
+    if @app.os_type.eql?(:rhel)
+      packages = [ 'glibc.x86_64', 'glibc.i686' ]
+      install  = @app.run(sprintf('yum install -y %s', packages.join(' '))) # TODO these are already in the base, but just to be safe
+      after    = @app.get_packages(false, false)
+
+      assert(after.has_key?('glibc'))
+      assert(after['glibc'].is_a?(Array))
+      assert_equal(after['glibc'].length, 2)
+      assert_not_equal(after['glibc'][0][:arch], after['glibc'][1][:arch])
+    elsif @app.os_type.eql?(:ubuntu)
+      packages = @app.get_packages(false, false)
+
+      assert(packages.has_key?('xml-core'))
+      assert(packages.has_key?('whiptail'))
+      assert(packages['xml-core'].has_key?(:version))
+      assert(packages['whiptail'].has_key?(:version))
+
+      assert_equal(packages['xml-core'][:arch], 'all')
+      assert_equal(packages['whiptail'][:arch], 'amd64')
+
+    else
+      # TODO should throw a flag here..
+      assert_nothing_raised do
+        @app.get_packages(false, true)
+        @app.get_packages(false, false)
+      end
     end
 
   end

data/test/functional/deltas/test_get_ports.rb

@@ -8,7 +8,7 @@ class TestDeltasGetPorts < 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()
@@ -95,6 +95,7 @@ class TestDeltasGetPorts < Test::Unit::TestCase
     }
 
     @app.deltas[:ports] = stock
+    @app.cache[:ports]  = Time.now.to_i # since we're faking the contents, we also need to fake other artifacts that would have been generated
 
     assert_equal(true, @app.is_port_open?(1234, 'tcp', true))
     assert_equal(true, @app.is_port_active?(22, 'tcp', true))
@@ -107,11 +108,35 @@ class TestDeltasGetPorts < Test::Unit::TestCase
     assert_equal(false, @app.is_port_active?(1234, 'tcp', true))
 
     # caching/argument default validation -- can't currently do this, don't know what ports will be open on others systems
+    # TODO but can fix this by running some ncatish commands
     #assert_equal(true, @app.is_port_active?(22))
     #assert_equal(true, @app.is_port_open?(1234))
 
   end
 
+  def test_happy_path_cache_invalidation
+    res1, res2 = nil, nil
+
+    assert_nothing_raised do
+      res1 = @app.get_ports(true)
+    end
+
+    first_cache_time = @app.cache[:ports]
+
+    sleep (@app.cache_timeout + 1)
+
+    assert_nothing_raised do
+      res2 = @app.get_ports(true)
+    end
+
+    second_cache_time = @app.cache[:ports]
+
+    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
   end

data/test/functional/deltas/test_get_services.rb

@@ -8,13 +8,12 @@ class TestDeltasGetServices < 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()
 
-    # eventually this should be standardized (and symbolized?)
-    @allowed_states = %w(exists operational running stopped)
+    @allowed_states = %w(exists installed operational running stopped unsure)
   end
 
   def test_happy_path
@@ -29,12 +28,51 @@ class TestDeltasGetServices < Test::Unit::TestCase
 
     res.each_key do |k|
       assert_not_nil(res[k])
-      #assert(@allowed_states.member?(res[k]))
+      assert(@allowed_states.member?(res[k]))
     end
 
+    # this isn't the best validation, but does prove a point - no nil keys/values
+    assert_nothing_raised do
+      res.keys.sort
+      res.values.sort
+    end
+
+  end
+
+  def test_happy_path_caching
+
+    assert_nil(@app.deltas[:services])
+
+    assert_nothing_raised do
+      @app.get_services(true)
+    end
+
+    assert_equal(Hash, @app.deltas[:services].class)
+
   end
 
-  # TODO add some caching tests
+  def test_happy_path_cache_invalidation
+    res1, res2 = nil, nil
+
+    assert_nothing_raised do
+      res1 = @app.get_services(true)
+    end
+
+    first_cache_time = @app.cache[:services]
+
+    sleep (@app.cache_timeout + 1)
+
+    assert_nothing_raised do
+      res2 = @app.get_services(true)
+    end
+
+    second_cache_time = @app.cache[:services]
+
+    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