rouster 0.53 → 0.57

data/test/functional/test_new.rb

@@ -7,39 +7,70 @@ 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_able_to_instantiate
+
+    assert_nothing_raised do
+      @app = Rouster.new(:name => 'app')
+    end
+
   end
 
-  def test_1_able_to_instantiate
+  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_2_good_openssh_tunnel
+  def test_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...
 
+    # 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   => false,
         :sudo          => false,
-        :verbosity     => 4,
+        :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
@@ -47,37 +78,48 @@ class TestNew < Test::Unit::TestCase
     assert_equal('app', @app.name)
     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')
@@ -85,9 +127,136 @@ 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(true, @app.is_available_via_ssh?())
+
+  end
+
+  def test_good_remote_passthrough
+
+    skip('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} #{host}`
+    skip("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,
+        },
+        :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
+    # TODO should we be catching this ourselves?
+    assert_raise SocketError do
+      @app = Rouster.new(
+        :name => 'fizzy',
+        :passthrough => {
+          :type => :remote,
+          :key  => @@user_sshkey,
+          :user => 'foo',
+          :host => 'this.host.does.not.exist',
+        },
+        :verbosity => 4,
+      )
+    end
+
+    # IP that doesn't resolve
+    # TODO should we be catching this ourselves?
+    assert_raise SocketError do
+      @app = Rouster.new(
+        :name => 'fizzy',
+        :passthrough => {
+          :type => :remote,
+          :key  => @@user_sshkey,
+          :user => 'foo',
+          :host => '255.256.257.258',
+        },
+        :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

data/test/functional/test_passthroughs.rb

@@ -0,0 +1,94 @@
+require sprintf('%s/../../path_helper', File.dirname(File.expand_path(__FILE__)))
+
+require 'rouster'
+require 'test/unit'
+
+# most of the real passthrough testing is done in test_new.rb, since the only effective difference should be the target of the SSH connection
+
+class TestPassthroughs < Test::Unit::TestCase
+
+  def setup
+    @@user_sshkey = sprintf('%s/.ssh/id_rsa', ENV['HOME'])
+
+    unless File.file?(@@user_sshkey)
+      File.write(@@user_sshkey, '') # either this or `touch`
+      File.chmod(0600, @@user_sshkey)
+    end
+
+  end
+
+  def test_functional_local_passthrough
+
+    assert_nothing_raised do
+      @local = Rouster.new(
+        :name => 'local',
+        :passthrough => {
+          :type => :local,
+        },
+        :verbose => 4,
+      )
+    end
+
+    assert(@local.is_passthrough?(), 'worker is a passthrough')
+    assert(@local.is_available_via_ssh?(), 'worker is available via SSH')
+
+    # put a file in /tmp/fizz and read it back
+    tmpfile = sprintf('/tmp/fizzy.%s.%s', Time.now.to_i, $$)
+    content = 'this is some sample text'
+
+    assert_nothing_raised do
+      @local.run("echo #{content} >> #{tmpfile}")
+    end
+
+    read = @local.run("cat #{tmpfile}").chomp! # using >> automatically includes \n
+
+    assert_equal(content, read, 'worker is able to read and write files on system')
+
+    # TODO better here
+    assert_nothing_raised do
+      @local.file('/etc/hosts')
+      @local.dir('/tmp')
+    end
+
+  end
+
+  def test_functional_remote_passthrough
+
+    skip('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} #{host}`
+    skip("found an ssh key, but it doesn't appear to be valid for this host") unless $?.success?
+
+    assert_nothing_raised do
+      @remote = Rouster.new(
+        :name => 'remote',
+        :passthrough => {
+          :type => :remote,
+          :host => host,
+          :user => ENV['USER'],
+          :key  => @@user_sshkey,
+        },
+        :verbosity => 4,
+      )
+    end
+
+    assert_equal('remote', @remote.name)
+    assert_equal(true, @remote.is_passthrough?())
+    assert_equal(false, @remote.uses_sudo?())
+    assert_equal(true, @remote.is_available_via_ssh?())
+
+    # TODO better here
+    assert_nothing_raised do
+      @remote.file('/etc/hosts')
+      @remote.dir('/tmp')
+    end
+
+  end
+
+  def teardown
+    # 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

data/test/functional/test_put.rb

@@ -75,7 +75,7 @@ class TestPut < Test::Unit::TestCase
 
   def teardown
     #@app.destroy()
-    @app.suspend()
+    #@app.suspend()
     File.delete(@kg_location) if File.file?(@kg_location).true?
   end
-end
+end

data/test/functional/test_validate_file.rb

@@ -17,9 +17,61 @@ class TestValidateFileFunctional < Test::Unit::TestCase
 
   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))
+    assert_equal(false, @app.validate_file('/foo', {}, false, true), 'when no expectation is specified, :ensure => present is assumed')
+    assert_equal(false, @app.validate_file('/fizzy', { :ensure => 'directory' }, false, true), 'standard DNE directory test')
+    assert_equal(false, @app.validate_file('/bang', { :ensure => 'file' }, false, true), '~standard DNE directory test')
+
+  end
+
+  # TODO tests
+  # :contains string
+  # :contains array
+  # :exists vs. :ensure -> what options are supported?
+  # :mode vs. :permissions
+  # :size
+  # :owner
+  # :group
+  # :constrain
+
+
+  def test_happy_basic
+    file        = '/tmp/chiddy'
+    expectation = { :ensure => 'file' }
+
+    @app.run("touch #{file}")
+
+    assert_equal(true, @app.validate_file(file, expectation, false, true))
+
+  end
+
+  def test_happy_doesnt_contain
+    file         = '/etc/hosts'
+    expectations = {
+      :ensure        => 'file',
+      :doesntcontain => 'fizzybang.12345',
+      :notcontains   => 'this.isnt.there.either'
+    }
+
+    assert_equal(true, @app.validate_file(file, expectations, false, true))
+
+  end
+
+  def test_happy_symlink
+    file = '/tmp/bang'
+
+    @app.run("ln -sf /etc/hosts #{file}")
+
+    expectations = [
+      { :ensure => 'symlink' },
+      { :ensure => 'link' },
+      { :ensure => 'link', :target => '/etc/hosts' }
+    ]
+
+    expectations.each do |e|
+      # this is a weird convention, maybe reconsider the calling signature for validate_file
+      #    thinking something like validate_file(expectations) instead of validate_file(file, expectations)
+      assert_equal(true, @app.validate_file(file, e, false, true))
+    end
 
   end
 

data/test/puppet/test_apply.rb

@@ -21,11 +21,13 @@ class TestPuppetApply < Test::Unit::TestCase
       'test/puppet/modules/role/manifests/ui.pp'     => 'modules/role/manifests/ui.pp',
     }
 
-    ## TODO figure out a better pattern here -- scp tunnel is under 'vagrant' context, but dirs created with 'root'
-    @app.sudo = false
-    @app.run('mkdir -p manifests/hieradata')
-    @app.run('mkdir -p modules/role/manifests')
-    @app.sudo = true
+    ['manifests/hieradata', 'modules/role/manifests'].each do |dir|
+      top = dir.split('/')[0]
+
+      @app.run("mkdir -p #{dir}")
+      @app.run("chown -R vagrant:vagrant #{top}") # because sudo=true, directories will be created with root:root
+
+    end
 
     required_files.each_pair do |source,dest|
       @app.put(source, dest)