rouster 0.7 → 0.41

data/test/functional/test_new.rb

@@ -7,25 +7,13 @@ require 'test/unit'
 
 class TestNew < Test::Unit::TestCase
 
-  # 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?
+  def setup
+    @app = Rouster.new(:name => 'app')
+    @app.destroy() if @app.status().eql?('running')
     @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
+  def test_1_able_to_instantiate
 
     assert_nothing_raised do
       @app = Rouster.new(:name => 'app')
@@ -33,93 +21,62 @@ class TestNew < Test::Unit::TestCase
 
   end
 
-  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
+  def test_2_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_good_advanced_instantiation
+  def test_3_good_advanced_instantiation
 
     assert_nothing_raised do
       @app = Rouster.new(
-        :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,
+        :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']),
       )
 
+
     end
 
     assert_equal('app', @app.name)
-    assert_equal(false, @app.is_passthrough?())
+    assert_equal(true, @app.is_passthrough?())
     assert_equal(false, @app.uses_sudo?())
-    assert_equal(4, @app.instance_variable_get(:@verbosity_console))
-    assert_equal(0, @app.instance_variable_get(:@verbosity_logfile))
+    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)
-
-    ## 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_bad_name_instantiation
+  def test_4_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::ArgumentError do
+    assert_raise Rouster::InternalError do
       @app = Rouster.new(:not_a_name => 'test')
     end
 
   end
 
-  def test_bad_vagrantfile_instantiation
+  def test_5_bad_vagrantfile_instantiation
 
     assert_raise Rouster::InternalError do
       @app = Rouster.new(:name => 'FIZZY') # auto find Vagrantfile
     end
 
-    assert_raise Rouster::ArgumentError do
+    assert_raise Rouster::InternalError do
       @app = Rouster.new(:name => 'testing', :vagrantfile => '/this/file/dne')
     end
 
   end
 
-  def test_bad_sshkey_instantiation
+  def test_6_bad_sshkey_instantiation
 
     assert_raise Rouster::InternalError do
       @app = Rouster.new(:name => 'app', :sshkey => '/this/file/dne')
@@ -127,177 +84,9 @@ 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
-    # 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?('')
+    # noop
   end
 
 end

data/test/functional/test_put.rb

@@ -49,33 +49,35 @@ 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 Rouster::SSHConnectionError
-    assert_raise Rouster::FileTransferError do
+    assert_raise Net::SSH::Disconnect 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.disconnect_ssh_tunnel()
+    @app._vm.channel.destroy_ssh_connection() # make sure we don't have a tunnel
     @app.suspend()
 
-    #assert_raise Rouster::SSHConnectionError do
-    assert_raise Rouster::FileTransferError do
+    assert_raise Rouster::SSHConnectionError 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()
-    #@app.suspend()
+    #@ppm.destroy()
     File.delete(@kg_location) if File.file?(@kg_location).true?
   end
-end
+end

data/test/functional/test_restart.rb

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

data/test/functional/test_run.rb

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

data/test/puppet/test_apply.rb

@@ -21,13 +21,11 @@ class TestPuppetApply < Test::Unit::TestCase
       'test/puppet/modules/role/manifests/ui.pp'     => 'modules/role/manifests/ui.pp',
     }
 
-    ['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
+    ## 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
 
     required_files.each_pair do |source,dest|
       @app.put(source, dest)
@@ -88,7 +86,7 @@ class TestPuppetApply < Test::Unit::TestCase
 
     app_expected_files = {
       '/etc/hosts' => {
-        :contains => [ 'localhost', '127.0.0.1' ],
+        :contains => [ 'localhost', 'app' ],
         :ensure   => 'present',
         :group    => 'root',
         :owner    => 'root',
@@ -123,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), "file[#{f}] expectation[#{e}]")
+      assert_equal(true, @app.validate_file(f,e))
     end
 
     app_expected_groups.each_pair do |g,e|
-      assert_equal(true, @app.validate_group(g,e), "group[#{g}] expectation[#{e}]")
+      assert_equal(true, @app.validate_group(g,e))
     end
 
     app_expected_packages.each_pair do |p,e|
-      assert_equal(true, @app.validate_package(p, e), "package[#{p}] expectation[#{e}]")
+      assert_equal(true, @app.validate_package(p, e))
     end
 
     app_expected_services.each_pair do |s,e|
-      assert_equal(true, @app.validate_service(s,e), "service[#{s}] expectation[#{e}]")
+      assert_equal(true, @app.validate_service(s,e))
     end
 
     app_expected_users.each_pair do |u,e|
-      assert_equal(true, @app.validate_user(u,e), "user[#{u}] expectation[#{e}]")
+      assert_equal(true, @app.validate_user(u,e))
     end
 
   end