vagrant 0.4.0 → 0.4.1

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/lib/vagrant/actions/vm/forward_ports.rb

@@ -11,22 +11,10 @@ module Vagrant
         # report the collisions detected or will attempt to fix them
         # automatically if the port is configured to do so.
         def external_collision_check
-          # Flatten all the already-created forwarded ports into a
-          # flat list.
-          used_ports = VirtualBox::VM.all.collect do |vm|
-            if vm.running? && vm.uuid != runner.uuid
-              vm.forwarded_ports.collect do |fp|
-                fp.hostport.to_s
-              end
-            end
-          end
-
-          used_ports.flatten!
-          used_ports.uniq!
-
+          existing = used_ports
           runner.env.config.vm.forwarded_ports.each do |name, options|
-            if used_ports.include?(options[:hostport].to_s)
-              handle_collision(name, options, used_ports)
+            if existing.include?(options[:hostport].to_s)
+              handle_collision(name, options, existing)
             end
           end
         end
@@ -34,7 +22,7 @@ module Vagrant
         # Handles any collisions. This method will either attempt to
         # fix the collision automatically or will raise an error if
         # auto fixing is disabled.
-        def handle_collision(name, options, used_ports)
+        def handle_collision(name, options, existing_ports)
           if !options[:auto]
             # Auto fixing is disabled for this port forward, so we
             # must throw an error so the user can fix it.
@@ -46,7 +34,7 @@ module Vagrant
           # left with available ports.
           range = runner.env.config.vm.auto_port_range.to_a
           range -= runner.env.config.vm.forwarded_ports.collect { |n, o| o[:hostport].to_i }
-          range -= used_ports
+          range -= existing_ports
 
           if range.empty?
             raise ActionException.new(:vm_port_auto_empty, :vm_name => @runner.name, :name => name, :options => options)
@@ -55,7 +43,7 @@ module Vagrant
           # Set the port up to be the first one and add that port to
           # the used list.
           options[:hostport] = range.shift
-          used_ports << options[:hostport]
+          existing_ports << options[:hostport]
 
           # Notify the user
           logger.info "Fixed port collision: #{name} now on port #{options[:hostport]}"
@@ -67,10 +55,9 @@ module Vagrant
         end
 
         def clear
-          if runner.vm.forwarded_ports.length > 0
+          if used_ports.length > 0
             logger.info "Deleting any previously set forwarded ports..."
-            fp = runner.vm.forwarded_ports.dup
-            fp.collect { |p| p.destroy }
+            clear_ports
             runner.reload!
           end
         end
@@ -78,28 +65,90 @@ module Vagrant
         def forward_ports
           logger.info "Forwarding ports..."
 
-          @runner.env.config.vm.forwarded_ports.each do |name, options|
+          runner.env.config.vm.forwarded_ports.each do |name, options|
             adapter = options[:adapter]
 
             # Assuming the only reason to establish port forwarding is because the VM is using Virtualbox NAT networking.
             # Host-only or Bridged networking don't require port-forwarding and establishing forwarded ports on these
             # attachment types has uncertain behaviour.
             if @runner.vm.network_adapters[adapter].attachment_type == :nat
-               logger.info "Forwarding \"#{name}\": #{options[:guestport]} on adapter \##{adapter+1} => #{options[:hostport]}"
-               port = VirtualBox::ForwardedPort.new
-               port.name = name
-               port.hostport = options[:hostport]
-               port.guestport = options[:guestport]
-               port.instance = adapter
-               @runner.vm.forwarded_ports << port
+              logger.info "Forwarding \"#{name}\": #{options[:guestport]} on adapter \##{adapter+1} => #{options[:hostport]}"
+              forward_port(name, options)
             else
               logger.info "VirtualBox adapter \##{adapter+1} not configured as \"NAT\"."
               logger.info "Skipped port forwarding \"#{name}\": #{options[:guestport]} on adapter\##{adapter+1} => #{options[:hostport]}"
             end
           end
 
-          @runner.vm.save
-          @runner.reload!
+          runner.vm.save
+          runner.reload!
+        end
+
+        #------------------------------------------------------------
+        # VirtualBox version-specific helpers below. VirtualBox 3.2
+        # introduced a breaking change into the way that forwarded
+        # ports are handled. For backwards compatability with 3.1, we
+        # need this trickery.
+        #------------------------------------------------------------
+        # TODO In a future version, fix this.
+
+        # Returns an array of used ports. This method is implemented
+        # differently depending on the VirtualBox version, but the
+        # behavior is the same.
+        #
+        # @return [Array<String>]
+        def used_ports
+          result = VirtualBox::VM.all.collect do |vm|
+            if vm.running? && vm.uuid != runner.uuid
+              if VirtualBox.version =~ /^3\.1\./
+                # VirtualBox 3.1.x uses forwarded ports via extra-data
+                vm.forwarded_ports.collect do |fp|
+                  fp.hostport.to_s
+                end
+              else
+                # VirtualBox 3.2.x uses forwarded ports via NAT engines
+                vm.network_adapters.collect do |na|
+                  na.nat_driver.forwarded_ports.collect do |fp|
+                    fp.hostport.to_s
+                  end
+                end
+              end
+            end
+          end
+
+          result.flatten.uniq
+        end
+
+        # Deletes existing forwarded ports.
+        def clear_ports
+          if VirtualBox.version =~ /^3\.1\./
+            fp = runner.vm.forwarded_ports.dup
+            fp.each { |p| p.destroy }
+          else
+            runner.vm.network_adapters.each do |na|
+              na.nat_driver.forwarded_ports.dup.each do |fp|
+                fp.destroy
+              end
+            end
+          end
+        end
+
+        # Forwards a port.
+        def forward_port(name, options)
+          if VirtualBox.version =~ /^3\.1\./
+            port = VirtualBox::ForwardedPort.new
+            port.name = name
+            port.hostport = options[:hostport]
+            port.guestport = options[:guestport]
+            port.instance = options[:adapter]
+            runner.vm.forwarded_ports << port
+          else
+            port = VirtualBox::NATForwardedPort.new
+            port.name = name
+            port.guestport = options[:guestport]
+            port.hostport = options[:hostport]
+            runner.vm.network_adapters[options[:adapter]].nat_driver.forwarded_ports << port
+          end
         end
       end
     end

data/lib/vagrant/actions/vm/up.rb

@@ -21,6 +21,7 @@ module Vagrant
         def after_import
           update_dotfile
           setup_mac_address
+          check_guest_additions
         end
 
         def update_dotfile
@@ -33,6 +34,19 @@ module Vagrant
           @runner.vm.network_adapters.first.mac_address = @runner.env.config.vm.base_mac
           @runner.vm.save
         end
+
+        def check_guest_additions
+          # Use the raw interface for now, while the virtualbox gem
+          # doesn't support guest properties (due to cross platform issues)
+          version = @runner.vm.interface.get_guest_property_value("/VirtualBox/GuestAdd/Version")
+          if version.empty?
+            logger.error Translator.t(:vm_additions_not_detected)
+          elsif version != VirtualBox.version
+            logger.error Translator.t(:vm_additions_version_mismatch,
+                                     :guest_additions_version => version,
+                                     :virtualbox_version => VirtualBox.version)
+          end
+        end
       end
     end
   end

data/lib/vagrant/commands/provision.rb

@@ -16,7 +16,7 @@ module Vagrant
           return # for tests
         end
 
-        if vm.vm.running?
+        if vm.created? && vm.vm.running?
           vm.provision
         else
           vm.env.logger.info "VM '#{name}' not running. Ignoring provision request."

data/lib/vagrant/commands/ssh.rb

@@ -11,7 +11,34 @@ module Vagrant
 
       def execute(args=[])
         args = parse_options(args)
-        ssh_connect(args[0])
+        if !options[:execute].empty?
+          vms = args[0] ? {args[0] => env.vms[args[0].to_sym]} : env.vms
+          vms.each do |name, vm|
+            ssh_execute(name, vm)
+          end
+        else
+          ssh_connect(args[0])
+        end
+      end
+
+      def ssh_execute(name, vm)
+        if vm.nil?
+          error_and_exit(:unknown_vm, :vm => name)
+          return # for tests
+        elsif !vm.created?
+          error_and_exit(:environment_not_created)
+          return
+        end
+
+        vm.ssh.execute do |ssh|
+          options[:execute].each do |command|
+            vm.env.logger.info("Execute: #{command}")
+            ssh.exec!(command) do |channel, type, data|
+              # TODO: Exit status checking?
+              vm.env.logger.info("#{type}: #{data}")
+            end
+          end
+        end
       end
 
       def ssh_connect(name)
@@ -37,7 +64,14 @@ module Vagrant
       end
 
       def options_spec(opts)
-        opts.banner = "Usage: vagrant ssh"
+        opts.banner = "Usage: vagrant ssh [--execute COMMAND]"
+
+        # Defaults
+        options[:execute] = []
+
+        opts.on("-e", "--execute COMMAND", "A command to execute. Multiple -e's may be specified.") do |value|
+          options[:execute] << value
+        end
       end
     end
   end

data/lib/vagrant/resource_logger.rb

@@ -61,19 +61,19 @@ module Vagrant
       @logger = self.class.singleton_logger(env)
     end
 
-    # TODO: The other logging methods.
+    [:debug, :info, :error, :fatal].each do |method|
+      define_method(method) do |message|
+        @@writer_lock.synchronize do
+          # We clear the line in case progress reports have been going
+          # out.
+          print(cl_reset)
+          logger.send(method, "[#{resource}] #{message}")
+        end
 
-    def info(message)
-      @@writer_lock.synchronize do
-        # We clear the line in case progress reports have been going
-        # out.
-        print(cl_reset)
-        logger.info("[#{resource}] #{message}")
+        # Once again flush the progress reporters since we probably
+        # cleared any existing ones.
+        flush_progress
       end
-
-      # Once again flush the progress reporters since we probably
-      # cleared any existing ones.
-      flush_progress
     end
 
     # Sets a progress report for the resource that this logger

data/lib/vagrant/ssh.rb

@@ -132,8 +132,20 @@ module Vagrant
       return pnum if pnum
 
       # Check if we have an SSH forwarded port
-      pnum = env.vm.vm.forwarded_ports.detect do |fp|
-        fp.name == env.config.ssh.forwarded_port_key
+      if VirtualBox.version =~ /^3\.1\./
+        pnum = env.vm.vm.forwarded_ports.detect do |fp|
+          fp.name == env.config.ssh.forwarded_port_key
+        end
+      else
+        # VirtualBox 3.2 specific
+        pnum = nil
+        env.vm.vm.network_adapters.each do |na|
+          pnum = na.nat_driver.forwarded_ports.detect do |fp|
+            fp.name == env.config.ssh.forwarded_port_key
+          end
+
+          break if pnum
+        end
       end
 
       return pnum.hostport if pnum

data/lib/vagrant/util/translator.rb

@@ -6,7 +6,7 @@ module Vagrant
     class Translator
       @@strings = nil
 
-      class <<self
+      class << self
         # Resets the internal strings hash to nil, forcing a reload on the next
         # access of {strings}.
         def reset!
@@ -32,4 +32,4 @@ module Vagrant
       end
     end
   end
-end
+end

data/templates/strings.yml

@@ -40,6 +40,26 @@
   Path:       <%= data["path"] %>
   Created at: <%= Time.at(data["created_at"]) %>
 
+#---------------------------------------------------------------------
+# CATEGORY: Warning Messages
+#---------------------------------------------------------------------
+:vm_additions_not_detected: |-
+  WARNING!
+  No guest additions were detected on the base box for this VM! Guest
+  additions are required for forwarded ports, shared folders, host only
+  networking, and more. If SSH fails on this machine, please install
+  the guest additions and repackage the box to continue.
+:vm_additions_version_mismatch: |-
+  WARNING!
+  The guest additions on this VM do not match the install version of
+  VirtualBox! This often causes things such as forwared ports, shared
+  folders, and more to not work properly. If any of those things fail on
+  this machine, please update the guest additions and repackage the
+  box.
+
+  Guest Additions Version: <%= guest_additions_version %>
+  VirtualBox Version: <%= virtualbox_version %>
+
 #---------------------------------------------------------------------
 # CATEGORY: Error Messages
 #---------------------------------------------------------------------

data/test/vagrant/actions/vm/forward_ports_test.rb

@@ -15,18 +15,6 @@ class ForwardPortsActionTest < Test::Unit::TestCase
 
   context "checking for colliding external ports" do
     setup do
-      @forwarded_port = mock("forwarded_port")
-      @forwarded_port.stubs(:hostport)
-      @forwarded_ports = [@forwarded_port]
-
-      @vm = mock("vm")
-      @vm.stubs(:forwarded_ports).returns(@forwarded_ports)
-      @vm.stubs(:running?).returns(true)
-      @vm.stubs(:uuid).returns("foo")
-      @runner.stubs(:uuid).returns("bar")
-      vms = [@vm]
-      VirtualBox::VM.stubs(:all).returns(vms)
-
       @env = mock_environment do |config|
         config.vm.forwarded_ports.clear
         config.vm.forward_port("ssh", 22, 2222)
@@ -34,29 +22,20 @@ class ForwardPortsActionTest < Test::Unit::TestCase
 
       @runner.stubs(:env).returns(@env)
 
+      @used_ports = []
+      @action.stubs(:used_ports).returns(@used_ports)
+
       # So no exceptions are raised
       @action.stubs(:handle_collision)
     end
 
-    should "ignore vms which aren't running" do
-      @vm.expects(:running?).returns(false)
-      @vm.expects(:forwarded_ports).never
-      @action.external_collision_check
-    end
-
-    should "ignore vms which are equivalent to ours" do
-      @runner.expects(:uuid).returns(@vm.uuid)
-      @vm.expects(:forwarded_ports).never
-      @action.external_collision_check
-    end
-
     should "not raise any errors if no forwarded ports collide" do
-      @forwarded_port.expects(:hostport).returns(80)
+      @used_ports << "80"
       assert_nothing_raised { @action.external_collision_check }
     end
 
     should "handle the collision if it happens" do
-      @forwarded_port.expects(:hostport).returns(2222)
+      @used_ports << "2222"
       @action.expects(:handle_collision).with("ssh", anything, anything).once
       @action.external_collision_check
     end
@@ -127,24 +106,11 @@ class ForwardPortsActionTest < Test::Unit::TestCase
       @vm.expects(:network_adapters).returns([network_adapter])
       network_adapter.expects(:attachment_type).returns(:nat)
 
-      @runner.env.config.vm.forwarded_ports.each do |name, opts|
-        forwarded_ports.expects(:<<).with do |port|
-          assert_equal name, port.name
-          assert_equal opts[:hostport], port.hostport
-          assert_equal opts[:guestport], port.guestport
-          assert_equal opts[:adapter], port.instance
-          true
-        end
-      end
-
-      @vm.expects(:forwarded_ports).returns(forwarded_ports)
       @vm.expects(:save).once
       @runner.expects(:reload!).once
       @action.forward_ports
     end
-  end
 
-  context "Not forwarding ports" do
     should "No port forwarding for non NAT interfaces" do
       forwarded_ports = mock("forwarded_ports")
       network_adapter = mock("network_adapter")
@@ -158,23 +124,176 @@ class ForwardPortsActionTest < Test::Unit::TestCase
   end
 
   context "clearing forwarded ports" do
-    should "call destroy on all forwarded ports" do
-      forwarded_ports = []
-      5.times do |i|
-        port = mock("port#{i}")
-        port.expects(:destroy).once
-        forwarded_ports << port
-      end
+    setup do
+      @action.stubs(:used_ports).returns([:a])
+      @action.stubs(:clear_ports)
+    end
 
-      @vm.stubs(:forwarded_ports).returns(forwarded_ports)
+    should "call destroy on all forwarded ports" do
+      @action.expects(:clear_ports).once
       @runner.expects(:reload!)
       @action.clear
     end
 
     should "do nothing if there are no forwarded ports" do
-      @vm.stubs(:forwarded_ports).returns([])
+      @action.stubs(:used_ports).returns([])
       @runner.expects(:reload!).never
       @action.clear
     end
   end
+
+  context "getting list of used ports" do
+    setup do
+      @vms = []
+      VirtualBox::VM.stubs(:all).returns(@vms)
+      VirtualBox.stubs(:version).returns("3.1.0")
+      @runner.stubs(:uuid).returns(:bar)
+    end
+
+    def mock_vm(options={})
+      options = {
+        :running? => true,
+        :uuid => :foo
+      }.merge(options)
+
+      vm = mock("vm")
+      options.each do |k,v|
+        vm.stubs(k).returns(v)
+      end
+
+      vm
+    end
+
+    def mock_fp(hostport)
+      fp = mock("fp")
+      fp.stubs(:hostport).returns(hostport.to_s)
+      fp
+    end
+
+    should "ignore VMs which aren't running" do
+      @vms << mock_vm(:running? => false)
+      @vms[0].expects(:forwarded_ports).never
+      @action.used_ports
+    end
+
+    should "ignore VMs of the same uuid" do
+      @vms << mock_vm(:uuid => @runner.uuid)
+      @vms[0].expects(:forwarded_ports).never
+      @action.used_ports
+    end
+
+    should "return the forwarded ports for VB 3.1.x" do
+      VirtualBox.stubs(:version).returns("3.1.4")
+      fps = [mock_fp(2222), mock_fp(80)]
+      @vms << mock_vm(:forwarded_ports => fps)
+      assert_equal %W[2222 80], @action.used_ports
+    end
+
+    should "return the forwarded ports for VB 3.2.x" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      fps = [mock_fp(2222), mock_fp(80)]
+      na = mock("na")
+      ne = mock("ne")
+      na.stubs(:nat_driver).returns(ne)
+      ne.stubs(:forwarded_ports).returns(fps)
+      @vms << mock_vm(:network_adapters => [na])
+      assert_equal %W[2222 80], @action.used_ports
+    end
+  end
+
+  context "clearing ports" do
+    def mock_fp
+      fp = mock("fp")
+      fp.expects(:destroy).once
+      fp
+    end
+
+    context "in VB 3.1.x" do
+      setup do
+        VirtualBox.stubs(:version).returns("3.1.4")
+        @fps = []
+        @vm.stubs(:forwarded_ports).returns(@fps)
+      end
+
+      should "destroy each forwarded port" do
+        @fps << mock_fp
+        @fps << mock_fp
+        @action.clear_ports
+      end
+    end
+
+    context "in VB 3.2.x" do
+      setup do
+        VirtualBox.stubs(:version).returns("3.2.8")
+        @adapters = []
+        @vm.stubs(:network_adapters).returns(@adapters)
+      end
+
+      def mock_adapter
+        na = mock("adapter")
+        engine = mock("engine")
+        engine.stubs(:forwarded_ports).returns([mock_fp])
+        na.stubs(:nat_driver).returns(engine)
+        na
+      end
+
+      should "destroy each forwarded port" do
+        @adapters << mock_adapter
+        @adapters << mock_adapter
+        @action.clear_ports
+      end
+    end
+  end
+
+  context "forwarding ports" do
+    context "in VB 3.1.x" do
+      setup do
+        VirtualBox.stubs(:version).returns("3.1.4")
+      end
+
+      should "forward ports" do
+        forwarded_ports = mock("forwarded_ports")
+        @vm.expects(:forwarded_ports).returns(forwarded_ports)
+        @runner.env.config.vm.forwarded_ports.each do |name, opts|
+          forwarded_ports.expects(:<<).with do |port|
+            assert_equal name, port.name
+            assert_equal opts[:hostport], port.hostport
+            assert_equal opts[:guestport], port.guestport
+            assert_equal opts[:adapter], port.instance
+            true
+          end
+
+          @action.forward_port(name, opts)
+        end
+      end
+    end
+
+    context "in VB 3.2.x" do
+      setup do
+        VirtualBox.stubs(:version).returns("3.2.8")
+      end
+
+      should "forward ports" do
+        name, opts = @runner.env.config.vm.forwarded_ports.first
+
+        adapters = []
+        adapter = mock("adapter")
+        engine = mock("engine")
+        fps = mock("forwarded ports")
+        adapter.stubs(:nat_driver).returns(engine)
+        engine.stubs(:forwarded_ports).returns(fps)
+        fps.expects(:<<).with do |port|
+          assert_equal name, port.name
+          assert_equal opts[:hostport], port.hostport
+          assert_equal opts[:guestport], port.guestport
+          true
+        end
+
+        adapters[opts[:adapter]] = adapter
+        @vm.stubs(:network_adapters).returns(adapters)
+
+        @action.forward_port(name, opts)
+      end
+    end
+  end
 end

data/test/vagrant/actions/vm/up_test.rb

@@ -69,6 +69,7 @@ class UpActionTest < Test::Unit::TestCase
       boot_seq = sequence("boot")
       @action.expects(:update_dotfile).once.in_sequence(boot_seq)
       @action.expects(:setup_mac_address).once.in_sequence(boot_seq)
+      @action.expects(:check_guest_additions).once.in_sequence(boot_seq)
       @action.after_import
     end
   end

data/test/vagrant/commands/provision_test.rb

@@ -18,6 +18,7 @@ class CommandsProvisionTest < Test::Unit::TestCase
     setup do
       @foo_vm = mock("vm")
       @foo_vm.stubs(:env).returns(@env)
+      @foo_vm.stubs(:created?).returns(true)
 
       @vm_for_real = mock("vm for real")
       @foo_vm.stubs(:vm).returns(@vm_for_real)
@@ -45,6 +46,15 @@ class CommandsProvisionTest < Test::Unit::TestCase
       @foo_vm.expects(:provision).never
       @instance.execute(["foo"])
     end
+
+    should "do log to info if it's not created" do
+      logger = mock("logger")
+      logger.expects(:info)
+      @env.stubs(:logger).returns(logger)
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:provision).never
+      @instance.execute(["foo"])
+    end
   end
 
 end

data/test/vagrant/commands/ssh_test.rb

@@ -18,6 +18,64 @@ class CommandsSSHTest < Test::Unit::TestCase
       @instance.expects(:ssh_connect).with(nil).once
       @instance.execute
     end
+
+    should "execute if commands are given" do
+      @env.stubs(:vms).returns(:foo => mock("foo"))
+      @instance.expects(:ssh_execute).with("foo", @env.vms[:foo]).once
+      @instance.execute(["foo","-e","bar"])
+    end
+
+    should "execute over every VM if none is specified with a command" do
+      vms = {
+        :foo => mock("foo"),
+        :bar => mock("bar")
+      }
+
+      @env.stubs(:vms).returns(vms)
+      vms.each do |key, vm|
+        @instance.expects(:ssh_execute).with(key, vm).once
+      end
+
+      @instance.execute(["--execute", "bar"])
+    end
+  end
+
+  context "ssh executing" do
+    setup do
+      @name = :foo
+
+      @ssh_conn = mock("connection")
+      @ssh_conn.stubs(:exec!)
+
+      @ssh = mock("ssh")
+      @ssh.stubs(:execute).yields(@ssh_conn)
+
+      @vm = mock("vm")
+      @vm.stubs(:created?).returns(true)
+      @vm.stubs(:ssh).returns(@ssh)
+      @vm.stubs(:env).returns(@env)
+    end
+
+    should "error and exit if invalid VM given" do
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => @name).once
+      @instance.ssh_execute(@name, nil)
+    end
+
+    should "error and exit if VM isn't created" do
+      @vm.stubs(:created?).returns(false)
+      @instance.expects(:error_and_exit).with(:environment_not_created).once
+      @instance.ssh_execute(@name, @vm)
+    end
+
+    should "execute each command" do
+      commands = [:a,:b,:c]
+      @instance.stubs(:options).returns(:execute => commands)
+      commands.each do |cmd|
+        @ssh_conn.expects(:exec!).with(cmd).once
+      end
+
+      @instance.ssh_execute(@name, @vm)
+    end
   end
 
   context "ssh connecting" do

data/test/vagrant/resource_logger_test.rb

@@ -76,11 +76,12 @@ class ResourceLoggerTest < Test::Unit::TestCase
         @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)
+      [:debug, :info, :error, :fatal].each do |method|
+        should "log with the proper format on #{method}" do
+          message = "bar"
+          @logger.expects(method).with("[#{@resource}] #{message}").once
+          @instance.send(method, message)
+        end
       end
     end
 

data/test/vagrant/ssh_session_test.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
-class SshTest < Test::Unit::TestCase
+class SshSessionTest < Test::Unit::TestCase
   setup do
     @session = mock("session")
 

data/test/vagrant/ssh_test.rb

@@ -16,6 +16,10 @@ class SshTest < Test::Unit::TestCase
     @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
@@ -93,6 +97,7 @@ class SshTest < Test::Unit::TestCase
     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
@@ -206,10 +211,11 @@ class SshTest < Test::Unit::TestCase
   context "getting the ssh port" do
     setup do
       mock_ssh
-
     end
 
-    should "return the configured port by default" do
+    should "return the configured port by default in VB 3.1.x" do
+      VirtualBox.stubs(:version).returns("3.1.4")
+
       port = 2222
       fp = mock("fp")
       fp.stubs(:name).returns(@env.config.ssh.forwarded_port_key)

data/vagrant.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{vagrant}
-  s.version = "0.4.0"
+  s.version = "0.4.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mitchell Hashimoto", "John Bender"]
-  s.date = %q{2010-06-10}
+  s.date = %q{2010-06-17}
   s.default_executable = %q{vagrant}
   s.description = %q{Vagrant is a tool for building and distributing virtualized development environments.}
   s.email = ["mitchell.hashimoto@gmail.com", "john.m.bender@gmail.com"]

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 4
-  - 0
-  version: 0.4.0
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Mitchell Hashimoto
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-10 00:00:00 -07:00
+date: 2010-06-17 00:00:00 -07:00
 default_executable: vagrant
 dependencies: 
 - !ruby/object:Gem::Dependency