fixed-vagrant 0.7.4.dev

data/test/vagrant/action/vm/package_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class PackageVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Package
+    @app, @env = action_env
+    @env["export.temp_dir"] = "foo"
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  should "be a subclass of general packaging middleware" do
+    assert @instance.is_a?(Vagrant::Action::General::Package)
+  end
+
+  should "set the package directory then call parent" do
+    @instance.expects(:general_call).once.with() do |env|
+      assert env["package.directory"]
+      assert_equal env["package.directory"], env["export.temp_dir"]
+      true
+    end
+
+    @instance.call(@env)
+  end
+end

data/test/vagrant/action/vm/package_vagrantfile_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class PackageVagrantfileVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::PackageVagrantfile
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+    @env["export.temp_dir"] = "foo"
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "create the vagrantfile then continue chain" do
+      seq = sequence("sequence")
+      @instance.expects(:create_vagrantfile).in_sequence(seq)
+      @app.expects(:call).with(@env).in_sequence(seq)
+
+      @instance.call(@env)
+    end
+  end
+
+  context "creating vagrantfile" do
+    setup do
+      @network_adapter = mock("nic")
+      @network_adapter.stubs(:mac_address).returns("mac_address")
+      @internal_vm.stubs(:network_adapters).returns([@network_adapter])
+    end
+
+    should "write the rendered vagrantfile to temp_path Vagrantfile" do
+      f = mock("file")
+      rendered = mock("rendered")
+      File.expects(:open).with(File.join(@env["export.temp_dir"], "Vagrantfile"), "w").yields(f)
+      Vagrant::Util::TemplateRenderer.expects(:render).returns(rendered).with("package_Vagrantfile", {
+                                                                                :base_mac => @internal_vm.network_adapters.first.mac_address
+                                                                              })
+      f.expects(:write).with(rendered)
+
+      @instance.create_vagrantfile
+    end
+  end
+end

data/test/vagrant/action/vm/provision_test.rb

@@ -0,0 +1,90 @@
+require "test_helper"
+
+class ProvisionVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Provision
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:name).returns("foo")
+    @vm.stubs(:ssh).returns(mock("ssh"))
+    @vm.stubs(:system).returns(mock("system"))
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+  end
+
+  context "initializing" do
+    setup do
+      @klass.any_instance.stubs(:load_provisioners)
+    end
+
+    should "load provisioner if provisioning enabled" do
+      @env["config"].vm.provision :chef_solo
+      @klass.any_instance.expects(:load_provisioners).once
+      @klass.new(@app, @env)
+    end
+
+    should "not load provisioner if disabled" do
+      @klass.any_instance.expects(:load_provisioners).never
+      @klass.new(@app, @env)
+    end
+
+    should "not load provisioner if disabled through env hash" do
+      @env["provision.enabled"] = false
+      @klass.any_instance.expects(:load_provisioners).never
+      @klass.new(@app, @env)
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      # Set provisioner to nil so the provisioner isn't loaded on init
+      @env["config"].vm.provisioners.clear
+      @instance = @klass.new(@app, @env)
+    end
+
+    context "loading a provisioner" do
+      setup do
+        Vagrant::Provisioners::ChefSolo.any_instance.expects(:prepare).at_least(0)
+      end
+
+      should "instantiate and prepare each provisioner" do
+        @env["config"].vm.provision :chef_solo
+        @env["config"].vm.provision :chef_solo
+        @instance.load_provisioners
+
+        assert_equal 2, @instance.provisioners.length
+      end
+
+      should "set the config for each provisioner" do
+        @env["config"].vm.provision :chef_solo do |chef|
+          chef.cookbooks_path = "foo"
+        end
+
+        @instance.load_provisioners
+
+        assert_equal "foo", @instance.provisioners.first.config.cookbooks_path
+      end
+    end
+
+    context "calling" do
+      setup do
+        Vagrant::Provisioners::ChefSolo.any_instance.stubs(:prepare)
+        @env["config"].vm.provision :chef_solo
+        @instance.load_provisioners
+      end
+
+      should "provision and continue chain" do
+        seq = sequence("seq")
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.provisioners.each do |prov|
+          prov.expects(:provision!).in_sequence(seq)
+        end
+
+        @instance.call(@env)
+      end
+    end
+  end
+end

data/test/vagrant/action/vm/resume_test.rb

@@ -0,0 +1,35 @@
+require "test_helper"
+
+class ResumeVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Resume
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "run the proper methods when saved" do
+      @internal_vm.expects(:saved?).returns(true)
+
+      seq = sequence("seq")
+      @env.env.actions.expects(:run).with(Vagrant::Action::VM::Boot).once.in_sequence(seq)
+      @app.expects(:call).with(@env).once.in_sequence(seq)
+      @instance.call(@env)
+    end
+
+    should "do nothing if VM is not saved" do
+      @internal_vm.expects(:saved?).returns(false)
+
+      @vm.expects(:start).never
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
+    end
+  end
+end

data/test/vagrant/action/vm/share_folders_test.rb

@@ -0,0 +1,139 @@
+require "test_helper"
+
+class ShareFoldersVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ShareFolders
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:name).returns("foo")
+    @vm.stubs(:ssh).returns(mock("ssh"))
+    @vm.stubs(:system).returns(mock("system"))
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    # No validation for this test since its a nightmare due to all the
+    # nonexistent shared folders.
+    Vagrant::Config::Top.any_instance.stubs(:validate!)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  def stub_shared_folders(contents)
+    env = vagrant_env(vagrantfile(<<-vf))
+      config.vm.shared_folders.clear
+      #{contents}
+    vf
+
+    @env.stubs(:env).returns(env)
+    env.config.vm.shared_folders
+  end
+
+  context "calling" do
+    should "run the methods in the proper order" do
+      before_seq = sequence("before")
+      @instance.expects(:create_metadata).once.in_sequence(before_seq)
+      @app.expects(:call).with(@env).in_sequence(before_seq)
+      @instance.expects(:mount_shared_folders).once.in_sequence(before_seq)
+
+      @instance.call(@env)
+    end
+  end
+
+  context "collecting shared folders" do
+    should "return a hash of the shared folders" do
+      data = {
+        "foo" => %W[bar baz],
+        "bar" => %W[foo baz]
+      }
+
+      stub_shared_folders(<<-sf)
+        config.vm.share_folder("foo", "bar", "baz")
+        config.vm.share_folder("bar", "foo", "baz")
+      sf
+
+      result = @instance.shared_folders
+      assert_equal data.length, result.length
+      data.each do |name, value|
+        guest, host = value
+        assert_equal guest, result[name][:guestpath]
+        assert_equal host, result[name][:hostpath]
+      end
+    end
+
+    should "ignore disabled shared folders" do
+      stub_shared_folders(<<-sf)
+        config.vm.share_folder("v-foo", "/foo", "/foo")
+        config.vm.share_folder("v-root", "/vagrant", ".", :disabled => true)
+        config.vm.share_folder("v-bar", "/bar", "/bar")
+      sf
+
+      assert_equal 2, @instance.shared_folders.length
+      assert_equal %W[v-bar v-foo], @instance.shared_folders.keys.sort
+    end
+
+    should "not destroy original hash" do
+      @folders = stub_shared_folders(<<-sf)
+        config.vm.share_folder("foo", "bar", "baz", :sync => true)
+      sf
+
+      folder = @folders["foo"].dup
+
+      @instance.shared_folders
+      assert_equal folder, @env.env.config.vm.shared_folders["foo"]
+    end
+  end
+
+  context "setting up shared folder metadata" do
+    setup do
+      stub_shared_folders(<<-sf)
+        config.vm.share_folder("foo", "fooguest", "foohost")
+        config.vm.share_folder("bar", "barguest", "barhost")
+      sf
+    end
+
+    should "add all shared folders to the VM" do
+      shared_folders = []
+      data = %W[foo bar]
+      shared_folders.expects(:<<).times(data.length).with() do |sf|
+        hostpath = File.expand_path("#{sf.name}host", @env.env.root_path)
+        assert data.include?(sf.name)
+        assert_equal hostpath, sf.host_path
+        true
+      end
+
+      @internal_vm.stubs(:shared_folders).returns(shared_folders)
+      @internal_vm.expects(:save).once
+
+      @instance.create_metadata
+    end
+  end
+
+  context "mounting the shared folders" do
+    setup do
+      @folders = stub_shared_folders(<<-sf)
+        config.vm.share_folder("foo", "fooguest", "foohost")
+        config.vm.share_folder("bar", "barguest", "barhost")
+        config.vm.share_folder("foo_no_mount", nil, "foohost2")
+      sf
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+      @vm.system.stubs(:mount_shared_folder)
+    end
+
+    should "mount all shared folders to the VM" do
+      mount_seq = sequence("mount_seq")
+      @folders.each do |name, data|
+        if data[:guestpath]
+          @vm.system.expects(:mount_shared_folder).with(@ssh, name, data[:guestpath]).in_sequence(mount_seq)
+        else
+          @vm.system.expects(:mount_shared_folder).with(@ssh, name, anything).never
+        end
+      end
+
+      @instance.mount_shared_folders
+    end
+  end
+end

data/test/vagrant/action/vm/suspend_test.rb

@@ -0,0 +1,35 @@
+require "test_helper"
+
+class SuspendVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Suspend
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "calling" do
+    should "run the proper methods when running" do
+      @internal_vm.expects(:running?).returns(true)
+
+      seq = sequence("seq")
+      @internal_vm.expects(:save_state).once.in_sequence(seq)
+      @app.expects(:call).with(@env).once.in_sequence(seq)
+      @instance.call(@env)
+    end
+
+    should "do nothing if VM is not running" do
+      @internal_vm.expects(:running?).returns(false)
+
+      @internal_vm.expects(:save_state).never
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
+    end
+  end
+end

data/test/vagrant/action/warden_test.rb

@@ -0,0 +1,119 @@
+require "test_helper"
+
+class ActionWardenTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Warden
+    @instance = @klass.new([], {})
+  end
+
+  context "initializing" do
+    should "finalize the middleware" do
+      middleware = [1,2,3]
+      middleware.each do |m|
+        @klass.any_instance.expects(:finalize_action).with(m, {}).returns(m)
+      end
+      @warden = @klass.new(middleware, new_env)
+      assert_equal @warden.actions, [1,2,3]
+    end
+  end
+
+  context "setting up middleware" do
+    should "make non-classes lambdas" do
+      env = new_env
+      env.expects(:foo).once
+
+      func = lambda { |x| x.foo }
+      @instance.finalize_action(func, env).call(env)
+    end
+
+    should "raise exception if given invalid middleware" do
+      assert_raises(RuntimeError) {
+        @instance.finalize_action(7, nil)
+      }
+    end
+  end
+
+  context "calling" do
+    should "return if there are no actions to execute" do
+      @instance.actions.expects(:pop).never
+      assert !@instance.call(new_env)
+    end
+
+    should "move the last action to the front of the stack" do
+      @instance.actions << lambda { |env| }
+      assert @instance.stack.empty?
+      @instance.call(new_env)
+      assert !@instance.stack.empty?
+      assert @instance.actions.empty?
+    end
+
+    should "call the next action" do
+      action = mock('action')
+      action.expects(:call).with({})
+      @instance.actions << action
+      @instance.call(new_env)
+    end
+
+    should "begin recovery sequence when the called action raises an exception" do
+      class Foo
+        def initialize(*args); end
+        def call(env)
+          raise "An exception"
+        end
+      end
+
+      @instance.actions << Foo.new
+      @instance.expects(:begin_rescue).with() do |env|
+        assert env["vagrant.error"].is_a?(RuntimeError)
+        true
+      end
+      assert_raises(RuntimeError) { @instance.call(new_env) }
+    end
+
+    should "not begin recovery sequence if a SystemExit is raised" do
+      class Foo
+        def initialize(*args); end
+        def call(env)
+          # Raises a system exit
+          abort
+        end
+      end
+
+      @instance.actions << Foo.new
+      @instance.expects(:begin_rescue).never
+      assert_raises(SystemExit) { @instance.call(new_env) }
+    end
+
+    should "raise interrupt if the environment is interupted" do
+      env = new_env
+      env.expects(:interrupted?).returns(true)
+      @instance.actions << lambda { |env| }
+
+      assert_raises(Vagrant::Errors::VagrantInterrupt) {
+        @instance.call(env)
+      }
+    end
+  end
+
+  context "recover" do
+    should "call recover on all items in the stack" do
+      seq = sequence("sequence")
+      @instance.stack = [rescueable_mock("action"), rescueable_mock("another")]
+      @instance.stack.each do |action|
+        action.expects(:recover).with(new_env).in_sequence(seq)
+      end
+
+      @instance.begin_rescue(new_env)
+    end
+  end
+
+  def new_env
+    Vagrant::Action::Environment.new(nil)
+  end
+
+  def rescueable_mock(name)
+    mock_action = mock(name)
+    mock_action.stubs(:respond_to?).with(:recover).returns(true)
+    mock_action
+  end
+end