vagrant 0.3.4 → 0.4.0

data/test/vagrant/provisioners/base_test.rb

@@ -7,13 +7,13 @@ class BaseProvisionerTest < Test::Unit::TestCase
 
   context "base instance" do
     setup do
-      @env = mock_environment
-      @base = Vagrant::Provisioners::Base.new(@env)
+      @vm = mock("vm")
+      @base = Vagrant::Provisioners::Base.new(@vm)
     end
 
     should "set the environment" do
-      base = Vagrant::Provisioners::Base.new(@env)
-      assert_equal @env, base.env
+      base = Vagrant::Provisioners::Base.new(@vm)
+      assert_equal @vm, base.vm
     end
 
     should "implement provision! which does nothing" do

data/test/vagrant/provisioners/chef_server_test.rb

@@ -2,13 +2,15 @@ require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
 
 class ChefServerProvisionerTest < Test::Unit::TestCase
   setup do
-    @env = mock_environment
-    @action = Vagrant::Provisioners::ChefServer.new(@env)
+    @vm = mock_vm
+    @env = @vm.env
+    @action = Vagrant::Provisioners::ChefServer.new(@vm)
   end
 
   context "provisioning" do
     should "run the proper sequence of methods in order" do
       prov_seq = sequence("prov_seq")
+      @action.expects(:verify_binary).with("chef-client").once.in_sequence(prov_seq)
       @action.expects(:chown_provisioning_folder).once.in_sequence(prov_seq)
       @action.expects(:create_client_key_folder).once.in_sequence(prov_seq)
       @action.expects(:upload_validation_key).once.in_sequence(prov_seq)
@@ -106,7 +108,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
     should "create the folder using the dirname of the path" do
       ssh = mock("ssh")
       ssh.expects(:exec!).with("sudo mkdir -p #{@path.dirname}").once
-      @env.ssh.expects(:execute).yields(ssh)
+      @vm.ssh.expects(:execute).yields(ssh)
       @action.create_client_key_folder
     end
   end
@@ -115,7 +117,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
     should "upload the validation key to the provisioning path" do
       @action.expects(:validation_key_path).once.returns("foo")
       @action.expects(:guest_validation_key_path).once.returns("bar")
-      @env.ssh.expects(:upload!).with("foo", "bar").once
+      @vm.ssh.expects(:upload!).with("foo", "bar").once
       @action.upload_validation_key
     end
   end
@@ -155,10 +157,19 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
   end
 
   context "running chef client" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
     should "cd into the provisioning directory and run chef client" do
-      ssh = mock("ssh")
-      ssh.expects(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json").once
-      @env.ssh.expects(:execute).yields(ssh)
+      @ssh.expects(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json").once
+      @action.run_chef_client
+    end
+
+    should "check the exit status if that is given" do
+      @ssh.stubs(:exec!).yields(nil, :exit_status, :foo)
+      @ssh.expects(:check_exit_status).with(:foo, anything).once
       @action.run_chef_client
     end
   end

data/test/vagrant/provisioners/chef_solo_test.rb

@@ -2,8 +2,9 @@ require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
 
 class ChefSoloProvisionerTest < Test::Unit::TestCase
   setup do
-    @env = mock_environment
-    @action = Vagrant::Provisioners::ChefSolo.new(@env)
+    @vm = mock_vm
+    @env = @vm.env
+    @action = Vagrant::Provisioners::ChefSolo.new(@vm)
   end
 
   context "preparing" do
@@ -21,6 +22,7 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
   context "provisioning" do
     should "run the proper sequence of methods in order" do
       prov_seq = sequence("prov_seq")
+      @action.expects(:verify_binary).with("chef-solo").once.in_sequence(prov_seq)
       @action.expects(:chown_provisioning_folder).once.in_sequence(prov_seq)
       @action.expects(:setup_json).once.in_sequence(prov_seq)
       @action.expects(:setup_solo_config).once.in_sequence(prov_seq)
@@ -28,7 +30,6 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
       @action.provision!
     end
   end
-
   context "sharing cookbook folders" do
     setup do
       @host_cookbook_paths = ["foo", "bar"]
@@ -148,7 +149,7 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
 
   context "generating and uploading chef solo configuration file" do
     setup do
-      @env.ssh.stubs(:upload!)
+      @vm.ssh.stubs(:upload!)
     end
 
     should "call setup_config with proper variables" do
@@ -163,10 +164,19 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
   end
 
   context "running chef solo" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
     should "cd into the provisioning directory and run chef solo" do
-      ssh = mock("ssh")
-      ssh.expects(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json").once
-      @env.ssh.expects(:execute).yields(ssh)
+      @ssh.expects(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json").once
+      @action.run_chef_solo
+    end
+
+    should "check the exit status if that is given" do
+      @ssh.stubs(:exec!).yields(nil, :exit_status, :foo)
+      @ssh.expects(:check_exit_status).with(:foo, anything).once
       @action.run_chef_solo
     end
   end

data/test/vagrant/provisioners/chef_test.rb

@@ -2,8 +2,9 @@ require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
 
 class ChefProvisionerTest < Test::Unit::TestCase
   setup do
-    @env = mock_environment
-    @action = Vagrant::Provisioners::Chef.new(@env)
+    @vm = mock_vm
+    @env = @vm.env
+    @action = Vagrant::Provisioners::Chef.new(@vm)
   end
 
   context "preparing" do
@@ -61,20 +62,32 @@ class ChefProvisionerTest < Test::Unit::TestCase
     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)
-      @env.ssh.expects(:execute).yields(ssh)
+      @vm.ssh.expects(:execute).yields(ssh)
       @action.chown_provisioning_folder
     end
   end
 
   context "generating and uploading chef configuration file" do
     setup do
-      @env.ssh.stubs(:upload!)
+      @vm.ssh.stubs(:upload!)
 
       @template = "template"
       @filename = "foo.rb"
@@ -88,7 +101,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
       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")
-      @env.ssh.expects(:upload!).with(string_io, "bar")
+      @vm.ssh.expects(:upload!).with(string_io, "bar")
 
       @action.setup_config(@template, @filename, {})
     end
@@ -124,7 +137,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
 
   context "generating and uploading json" do
     def assert_json
-      @env.ssh.expects(:upload!).with do |json, path|
+      @vm.ssh.expects(:upload!).with do |json, path|
         data = JSON.parse(json.read)
         yield data
         true
@@ -142,20 +155,20 @@ class ChefProvisionerTest < Test::Unit::TestCase
 
     should "add the directory as a special case to the JSON" do
       assert_json do |data|
-        assert_equal @env.config.vm.project_directory, data["vagrant"]["directory"]
+        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.vm.project_directory, data["vagrant"]["config"]["vm"]["project_directory"]
+        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")
-      @env.ssh.expects(:upload!).with("bar", "baz").once
+      @vm.ssh.expects(:upload!).with("bar", "baz").once
       @action.setup_json
     end
   end

data/test/vagrant/resource_logger_test.rb

@@ -0,0 +1,144 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ResourceLoggerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::ResourceLogger
+  end
+
+  context "singleton logger" do
+    setup do
+      @klass.reset_singleton_logger!
+
+      @result = mock("result")
+    end
+
+    should "return a nil plain logger if no environment is given" do
+      Vagrant::Util::PlainLogger.expects(:new).with(nil).returns(@result)
+      assert_equal @result, @klass.singleton_logger
+    end
+
+    should "return a nil plain logger if the config is not loaded" do
+      env = mock_environment
+      env.config.stubs(:loaded?).returns(false)
+
+      Vagrant::Util::PlainLogger.expects(:new).with(nil).returns(@result)
+      assert_equal @result, @klass.singleton_logger(env)
+    end
+
+    should "return a logger with the specified output if environment is ready" do
+      output = mock("output")
+      env = mock_environment
+      env.config.vagrant.log_output = output
+
+      Vagrant::Util::PlainLogger.expects(:new).with(output).returns(@result)
+      assert_equal @result, @klass.singleton_logger(env)
+    end
+
+    should "only load the logger once" do
+      output = mock("output")
+      env = mock_environment
+      env.config.vagrant.log_output = output
+
+      Vagrant::Util::PlainLogger.expects(:new).with(output).returns(@result)
+      assert_equal @result, @klass.singleton_logger(env)
+      assert_equal @result, @klass.singleton_logger(env)
+      assert_equal @result, @klass.singleton_logger(env)
+    end
+  end
+
+  context "initialization" do
+    should "setup the logger and attributes" do
+      env = mock_environment
+      resource = mock("resource")
+      result = mock("result")
+
+      @klass.expects(:singleton_logger).with(env).returns(result)
+      instance = @klass.new(resource, env)
+      assert_equal resource, instance.resource
+      assert_equal env, instance.env
+      assert_equal result, instance.logger
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @resource = "foo"
+      @env = mock_environment
+      @logger = mock("logger")
+
+      @klass.stubs(:singleton_logger).returns(@logger)
+      @instance = @klass.new(@resource, @env)
+    end
+
+    context "logging methods" do
+      setup do
+        @instance.stubs(:flush_progress)
+        @instance.stubs(:cl_reset).returns("")
+      end
+
+      should "log with the proper format" do
+        message = "bar"
+        @logger.expects(:info).with("[#{@resource}] #{message}").once
+
+        @instance.info(message)
+      end
+    end
+
+    context "reporting progress" do
+      setup do
+        @instance.stubs(:flush_progress)
+      end
+
+      should "flush progress" do
+        @instance.expects(:flush_progress).once
+        @instance.report_progress(72, 100)
+      end
+
+      should "add the reporter to the progress reporters" do
+        @instance.report_progress(72, 100)
+        assert @klass.progress_reporters.has_key?(@instance.resource)
+      end
+    end
+
+    context "clearing progress" do
+      setup do
+        @instance.stubs(:flush_progress)
+
+        @klass.progress_reporters.clear
+        @instance.report_progress(72, 100)
+      end
+
+      should "remove the key from the reporters" do
+        assert @klass.progress_reporters.has_key?(@instance.resource)
+        @instance.clear_progress
+        assert !@klass.progress_reporters.has_key?(@instance.resource)
+      end
+    end
+
+    context "command line reset" do
+      setup do
+        Mario::Platform.logger(nil)
+      end
+
+      context "on windows" do
+        setup do
+          Mario::Platform.forced = Mario::Platform::Windows7
+        end
+
+        should "just return \\r for the clear screen" do
+          assert_equal  "\r", @instance.cl_reset
+        end
+      end
+
+      context "on other platforms" do
+        setup do
+          Mario::Platform.forced = Mario::Platform::Linux
+        end
+
+        should "return the full clear screen" do
+          assert_equal "\r\e[0K", @instance.cl_reset
+        end
+      end
+    end
+  end
+end

data/test/vagrant/ssh_session_test.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class SshTest < 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::Actions::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::Actions::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

@@ -6,6 +6,13 @@ class SshTest < Test::Unit::TestCase
       yield config if block_given?
     end
 
+    @forwarded_ports = []
+    @vm = mock("vm")
+    @vm.stubs(:forwarded_ports).returns(@forwarded_ports)
+
+    @env.stubs(:vm).returns(mock_vm(@env))
+    @env.vm.stubs(:vm).returns(@vm)
+
     @ssh = Vagrant::SSH.new(@env)
   end
 
@@ -111,6 +118,15 @@ class SshTest < Test::Unit::TestCase
       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
@@ -121,11 +137,20 @@ class SshTest < Test::Unit::TestCase
     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).returns(scp).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
@@ -181,10 +206,17 @@ class SshTest < Test::Unit::TestCase
   context "getting the ssh port" do
     setup do
       mock_ssh
+
     end
 
     should "return the configured port by default" do
-      assert_equal @env.config.vm.forwarded_ports[@env.config.ssh.forwarded_port_key][:hostport], @ssh.port
+      port = 2222
+      fp = mock("fp")
+      fp.stubs(:name).returns(@env.config.ssh.forwarded_port_key)
+      fp.stubs(:hostport).returns(port)
+      @forwarded_ports << fp
+
+      assert_equal port, @ssh.port
     end
 
     should "return the port given in options if it exists" do
@@ -203,6 +235,14 @@ class SshTest < Test::Unit::TestCase
       @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