vagrantup 0.5.2 → 0.5.3

data/test/vagrant/provisioners/chef_test.rb

@@ -0,0 +1,178 @@
+require "test_helper"
+
+class ChefProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action_env = Vagrant::Action::Environment.new(mock_environment)
+    @action_env.env.vm = mock_vm
+
+    @action = Vagrant::Provisioners::Chef.new(@action_env)
+    @env = @action.env
+    @vm = @action.vm
+  end
+
+  context "preparing" do
+    should "error the environment" do
+      @action.prepare
+      assert @action_env.error?
+      assert_equal :chef_base_invalid_provisioner, @action_env.error.first
+    end
+  end
+
+  context "config" do
+    setup do
+      @config = Vagrant::Provisioners::Chef::ChefConfig.new
+      @config.run_list.clear
+    end
+
+    should "not include the 'json' key in the config dump" do
+      result = JSON.parse(@config.to_json)
+      assert !result.has_key?("json")
+    end
+
+    should "provide accessors to the run list" do
+      @config.run_list << "foo"
+      assert !@config.run_list.empty?
+      assert_equal ["foo"], @config.run_list
+    end
+
+    should "provide a writer for the run list" do
+      data = mock("data")
+
+      assert_nothing_raised {
+        @config.run_list = data
+        assert_equal data, @config.run_list
+      }
+    end
+
+    should "add a recipe to the run list" do
+      @config.add_recipe("foo")
+      assert_equal "recipe[foo]", @config.run_list[0]
+    end
+
+    should "not wrap the recipe in 'recipe[]' if it was in the name" do
+      @config.add_recipe("recipe[foo]")
+      assert_equal "recipe[foo]", @config.run_list[0]
+    end
+
+    should "add a role to the run list" do
+      @config.add_role("user")
+      assert_equal "role[user]", @config.run_list[0]
+    end
+
+    should "not wrap the role in 'role[]' if it was in the name" do
+      @config.add_role("role[user]")
+      assert_equal "role[user]", @config.run_list[0]
+    end
+  end
+
+  context "verifying binary" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "verify binary exists" do
+      binary = "foo"
+      @ssh.expects(:exec!).with("which #{binary}", :error_key => :chef_not_detected, :error_data => { :binary => binary }).once
+      @action.verify_binary(binary)
+    end
+  end
+  context "permissions on provisioning folder" do
+    should "create and chown the folder to the ssh user" do
+      ssh_seq = sequence("ssh_seq")
+      ssh = mock("ssh")
+      ssh.expects(:exec!).with("sudo mkdir -p #{@env.config.chef.provisioning_path}").once.in_sequence(ssh_seq)
+      ssh.expects(:exec!).with("sudo chown #{@env.config.ssh.username} #{@env.config.chef.provisioning_path}").once.in_sequence(ssh_seq)
+      @vm.ssh.expects(:execute).yields(ssh)
+      @action.chown_provisioning_folder
+    end
+  end
+
+  context "generating and uploading chef configuration file" do
+    setup do
+      @vm.ssh.stubs(:upload!)
+
+      @template = "template"
+      @filename = "foo.rb"
+
+      Vagrant::Util::TemplateRenderer.stubs(:render).returns("foo")
+    end
+
+    should "render and upload file" do
+      template_data = mock("data")
+      string_io = mock("string_io")
+      Vagrant::Util::TemplateRenderer.expects(:render).with(@template, anything).returns(template_data)
+      StringIO.expects(:new).with(template_data).returns(string_io)
+      File.expects(:join).with(@env.config.chef.provisioning_path, @filename).once.returns("bar")
+      @vm.ssh.expects(:upload!).with(string_io, "bar")
+
+      @action.setup_config(@template, @filename, {})
+    end
+
+    should "provide log level by default" do
+      Vagrant::Util::TemplateRenderer.expects(:render).returns("foo").with() do |template, vars|
+        assert vars.has_key?(:log_level)
+        assert_equal @env.config.chef.log_level.to_sym, vars[:log_level]
+        true
+      end
+
+      @action.setup_config(@template, @filename, {})
+    end
+
+    should "allow custom template variables" do
+      custom = {
+        :foo => "bar",
+        :int => 7
+      }
+
+      Vagrant::Util::TemplateRenderer.expects(:render).returns("foo").with() do |template, vars|
+        custom.each do |key, value|
+          assert vars.has_key?(key)
+          assert_equal value, vars[key]
+        end
+
+        true
+      end
+
+      @action.setup_config(@template, @filename, custom)
+    end
+  end
+
+  context "generating and uploading json" do
+    def assert_json
+      @vm.ssh.expects(:upload!).with do |json, path|
+        data = JSON.parse(json.read)
+        yield data
+        true
+      end
+
+      @action.setup_json
+    end
+
+    should "merge in the extra json specified in the config" do
+      @env.config.chef.json = { :foo => "BAR" }
+      assert_json do |data|
+        assert_equal "BAR", data["foo"]
+      end
+    end
+
+    should "add the directory as a special case to the JSON" do
+      assert_json do |data|
+        assert_equal @env.config.vm.shared_folders["v-root"][:guestpath], data["vagrant"]["directory"]
+      end
+    end
+
+    should "add the config to the JSON" do
+      assert_json do |data|
+        assert_equal @env.config.ssh.username, data["vagrant"]["config"]["ssh"]["username"]
+      end
+    end
+
+    should "upload a StringIO to dna.json" do
+      StringIO.expects(:new).with(anything).returns("bar")
+      File.expects(:join).with(@env.config.chef.provisioning_path, "dna.json").once.returns("baz")
+      @vm.ssh.expects(:upload!).with("bar", "baz").once
+      @action.setup_json
+    end
+  end
+end

data/test/vagrant/ssh_session_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class SshSessionTest < Test::Unit::TestCase
+  setup do
+    @session = mock("session")
+
+    @klass = Vagrant::SSH::Session
+    @instance = @klass.new(@session)
+  end
+
+  context "exec!" do
+    should "retry 5 times" do
+      @session.expects(:open_channel).times(5).raises(IOError)
+      assert_raises(IOError) {
+        @instance.exec!("foo")
+      }
+    end
+  end
+
+  context "checking exit status" do
+    should "raise an ActionException if its non-zero" do
+      assert_raises(Vagrant::Action::ActionException) {
+        @instance.check_exit_status(1, "foo")
+      }
+    end
+
+    should "raise the given exception if specified" do
+      options = {
+        :error_key => :foo,
+        :error_data => {}
+      }
+      result = Exception.new
+      Vagrant::Action::ActionException.expects(:new).with(options[:error_key], options[:error_data]).once.returns(result)
+
+      assert_raises(Exception) {
+        @instance.check_exit_status(1, "foo", options)
+      }
+    end
+
+    should "raise nothing if its zero" do
+      assert_nothing_raised {
+        @instance.check_exit_status(0, "foo")
+      }
+    end
+  end
+end

data/test/vagrant/ssh_test.rb

@@ -0,0 +1,317 @@
+require "test_helper"
+
+class SshTest < Test::Unit::TestCase
+  def mock_ssh
+    @env = mock_environment do |config|
+      yield config if block_given?
+    end
+
+    @forwarded_ports = []
+    @network_adapters = []
+    @vm = mock("vm")
+    @vm.stubs(:network_adapters).returns(@network_adapters)
+
+    @env.stubs(:vm).returns(mock_vm(@env))
+    @env.vm.stubs(:vm).returns(@vm)
+
+    @ssh = Vagrant::SSH.new(@env)
+  end
+
+  setup do
+    VirtualBox.stubs(:version).returns("3.1.4")
+  end
+
+  context "connecting to external SSH" do
+    setup do
+      mock_ssh
+      @ssh.stubs(:check_key_permissions)
+      @ssh.stubs(:error_and_exit)
+      Kernel.stubs(:exec)
+
+      Vagrant::Util::Platform.stubs(:leopard?).returns(false)
+    end
+
+    should "check key permissions prior to exec" do
+      exec_seq = sequence("exec_seq")
+      @ssh.expects(:check_key_permissions).with(@env.config.ssh.private_key_path).once.in_sequence(exec_seq)
+      Kernel.expects(:exec).in_sequence(exec_seq)
+      @ssh.connect
+    end
+
+    should "call exec with defaults when no options are supplied" do
+      ssh_exec_expect(@ssh.port,
+                      @env.config.ssh.private_key_path,
+                      @env.config.ssh.username,
+                      @env.config.ssh.host)
+      @ssh.connect
+    end
+
+    should "call exec with supplied params" do
+      args = {:username => 'bar', :private_key_path => 'baz', :host => 'bak', :port => 'bag'}
+      ssh_exec_expect(args[:port], args[:private_key_path], args[:username], args[:host])
+      @ssh.connect(args)
+    end
+
+    should "add forward agent option if enabled" do
+      @env.config.ssh.forward_agent = true
+      ssh_exec_expect(@ssh.port,
+                      @env.config.ssh.private_key_path,
+                      @env.config.ssh.username,
+                      @env.config.ssh.host) do |args|
+        assert args =~ /-o ForwardAgent=yes/
+      end
+      @ssh.connect
+    end
+
+    context "on leopard" do
+      setup do
+        Vagrant::Util::Platform.stubs(:leopard?).returns(true)
+      end
+
+      should "fork, exec, and wait" do
+        pid = mock("pid")
+        @ssh.expects(:fork).once.returns(pid)
+        Process.expects(:wait).with(pid)
+
+        @ssh.connect
+      end
+    end
+
+    context "checking windows" do
+      should "error and exit if the platform is windows" do
+        Mario::Platform.expects(:windows?).returns(true)
+        @ssh.expects(:error_and_exit).with do |error_name, opts|
+          opts[:key_path] && opts[:ssh_port]
+        end
+        @ssh.connect
+      end
+
+      should "not error and exit if the platform is anything other that windows" do
+        Mario::Platform.expects(:windows?).returns(false)
+        @ssh.expects(:error_and_exit).never
+        @ssh.connect
+      end
+    end
+
+    def ssh_exec_expect(port, key_path, uname, host)
+      Kernel.expects(:exec).with() do |arg|
+        assert arg =~ /^ssh/
+        assert arg =~ /-p #{port}/
+        assert arg =~ /-i #{key_path}/
+        assert arg =~ /#{uname}@#{host}/
+        yield arg if block_given?
+        true
+      end
+    end
+  end
+
+  context "executing ssh commands" do
+    setup do
+      mock_ssh
+      @ssh.stubs(:check_key_permissions)
+      @ssh.stubs(:port).returns(80)
+    end
+
+    should "check key permissions then attempt to start connection" do
+      seq = sequence("seq")
+      @ssh.expects(:check_key_permissions).with(@env.config.ssh.private_key_path).once.in_sequence(seq)
+      Net::SSH.expects(:start).once.in_sequence(seq)
+      @ssh.execute
+    end
+
+    should "call net::ssh.start with the proper names" do
+      Net::SSH.expects(:start).once.with() do |host, username, opts|
+        assert_equal @env.config.ssh.host, host
+        assert_equal @env.config.ssh.username, username
+        assert_equal @ssh.port, opts[:port]
+        assert_equal [@env.config.ssh.private_key_path], opts[:keys]
+        true
+      end
+      @ssh.execute
+    end
+
+    should "forward agent if configured" do
+      @env.config.ssh.forward_agent = true
+      Net::SSH.expects(:start).once.with() do |host, username, opts|
+        assert opts[:forward_agent]
+        true
+      end
+
+      @ssh.execute
+    end
+
+    should "use custom host if set" do
+      @env.config.ssh.host = "foo"
+      Net::SSH.expects(:start).with(@env.config.ssh.host, @env.config.ssh.username, anything).once
+      @ssh.execute
+    end
+
+    should "yield an SSH session object" do
+      raw = mock("raw")
+      Net::SSH.expects(:start).yields(raw)
+      @ssh.execute do |ssh|
+        assert ssh.is_a?(Vagrant::SSH::Session)
+        assert_equal raw, ssh.session
+      end
+    end
+  end
+
+  context "SCPing files to the remote host" do
+    setup do
+      mock_ssh
+    end
+
+    should "use Vagrant::SSH execute to setup an SCP connection and upload" do
+      scp = mock("scp")
+      ssh = mock("ssh")
+      sess = mock("session")
+      ssh.stubs(:session).returns(sess)
+      scp.expects(:upload!).with("foo", "bar").once
+      Net::SCP.expects(:new).with(ssh.session).returns(scp).once
+      @ssh.expects(:execute).yields(ssh).once
+      @ssh.upload!("foo", "bar")
+    end
+
+    should "retry 5 times" do
+      @ssh.expects(:execute).times(5).raises(IOError)
+      assert_raises(IOError) {
+        @ssh.upload!("foo", "bar")
+      }
+    end
+  end
+
+  context "checking if host is up" do
+    setup do
+      mock_ssh
+      @ssh.stubs(:check_key_permissions)
+    end
+
+    should "return true if SSH connection works" do
+      Net::SSH.expects(:start).yields("success")
+      assert @ssh.up?
+    end
+
+    should "return false if SSH connection times out" do
+      Net::SSH.expects(:start)
+      assert !@ssh.up?
+    end
+
+    should "allow the thread the configured timeout time" do
+      @thread = mock("thread")
+      @thread.stubs(:[])
+      Thread.expects(:new).returns(@thread)
+      @thread.expects(:join).with(@env.config.ssh.timeout).once
+      @ssh.up?
+    end
+
+    should "return false if the connection is refused" do
+      Net::SSH.expects(:start).raises(Errno::ECONNREFUSED)
+      assert_nothing_raised {
+        assert !@ssh.up?
+      }
+    end
+
+    should "return false if the connection is dropped" do
+      Net::SSH.expects(:start).raises(Net::SSH::Disconnect)
+      assert_nothing_raised {
+        assert !@ssh.up?
+      }
+    end
+
+    should "specifity the timeout as an option to execute" do
+      @ssh.expects(:execute).with(:timeout => @env.config.ssh.timeout).yields(true)
+      assert @ssh.up?
+    end
+
+    should "error and exit if a Net::SSH::AuthenticationFailed is raised" do
+      @ssh.expects(:execute).raises(Net::SSH::AuthenticationFailed)
+      @ssh.expects(:error_and_exit).with(:vm_ssh_auth_failed).once
+      @ssh.up?
+    end
+  end
+
+  context "getting the ssh port" do
+    setup do
+      mock_ssh
+    end
+
+    should "return the port given in options if it exists" do
+      assert_equal "47", @ssh.port({ :port => "47" })
+    end
+  end
+
+  context "checking key permissions" do
+    setup do
+      mock_ssh
+      @ssh.stubs(:file_perms)
+
+      @key_path = "foo"
+
+
+      @stat = mock("stat")
+      @stat.stubs(:owned?).returns(true)
+      File.stubs(:stat).returns(@stat)
+
+      Mario::Platform.stubs(:windows?).returns(false)
+    end
+
+    should "do nothing if on windows" do
+      Mario::Platform.stubs(:windows?).returns(true)
+      File.expects(:stat).never
+      @ssh.check_key_permissions(@key_path)
+    end
+
+    should "do nothing if the user is not the owner" do
+      @stat.expects(:owned?).returns(false)
+      File.expects(:chmod).never
+      @ssh.check_key_permissions(@key_path)
+    end
+
+    should "do nothing if the file perms equal 600" do
+      @ssh.expects(:file_perms).with(@key_path).returns("600")
+      File.expects(:chmod).never
+      @ssh.check_key_permissions(@key_path)
+    end
+
+    should "chmod the file if the file perms aren't 600" do
+      perm_sequence = sequence("perm_seq")
+      @ssh.expects(:file_perms).returns("900").in_sequence(perm_sequence)
+      File.expects(:chmod).with(0600, @key_path).once.in_sequence(perm_sequence)
+      @ssh.expects(:file_perms).returns("600").in_sequence(perm_sequence)
+      @ssh.expects(:error_and_exit).never
+      @ssh.check_key_permissions(@key_path)
+    end
+
+    should "error and exit if the resulting chmod doesn't work" do
+      perm_sequence = sequence("perm_seq")
+      @ssh.expects(:file_perms).returns("900").in_sequence(perm_sequence)
+      File.expects(:chmod).with(0600, @key_path).once.in_sequence(perm_sequence)
+      @ssh.expects(:file_perms).returns("900").in_sequence(perm_sequence)
+      @ssh.expects(:error_and_exit).once.with(:ssh_bad_permissions, :key_path => @key_path).in_sequence(perm_sequence)
+      @ssh.check_key_permissions(@key_path)
+    end
+
+    should "error and exit if a bad file perm is raised" do
+      @ssh.expects(:file_perms).with(@key_path).returns("900")
+      File.expects(:chmod).raises(Errno::EPERM)
+      @ssh.expects(:error_and_exit).once.with(:ssh_bad_permissions, :key_path => @key_path)
+      @ssh.check_key_permissions(@key_path)
+    end
+  end
+
+  context "getting file permissions" do
+    setup do
+      mock_ssh
+    end
+
+    should "return the last 3 characters of the file mode" do
+      path = "foo"
+      mode = "10000foo"
+      stat = mock("stat")
+      File.expects(:stat).with(path).returns(stat)
+      stat.expects(:mode).returns(mode)
+      @ssh.expects(:sprintf).with("%o", mode).returns(mode)
+      assert_equal path, @ssh.file_perms(path)
+    end
+  end
+end