boxcar 0.10005.1

data/test/unit_legacy/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/unit_legacy/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/unit_legacy/vagrant/action/vm/provision_test.rb

@@ -0,0 +1,65 @@
+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 "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
+      should "instantiate and prepare each provisioner" do
+        @env["config"].vm.provision :chef_solo
+        @env["config"].vm.provision :chef_solo
+        provisioners = @instance.enabled_provisioners
+
+        assert_equal 2, provisioners.length
+      end
+
+      should "set the config for each provisioner" do
+        @env["config"].vm.provision :chef_solo do |chef|
+          chef.cookbooks_path = "foo"
+        end
+
+        provisioners = @instance.enabled_provisioners
+
+        assert_equal "foo", provisioners.first.config.cookbooks_path
+      end
+    end
+
+    context "calling" do
+      should "provision and continue chain" do
+        provisioners = [mock("one"), mock("two")]
+        seq = sequence("seq")
+        @instance.stubs(:enabled_provisioners).returns(provisioners)
+
+        provisioners.each do |prov|
+          prov.expects(:prepare).in_sequence(seq)
+        end
+
+        @app.expects(:call).with(@env).in_sequence(seq)
+
+        provisioners.each do |prov|
+          prov.expects(:provision!).in_sequence(seq)
+        end
+
+        @instance.call(@env)
+      end
+    end
+  end
+end

data/test/unit_legacy/vagrant/action/vm/provisioner_cleanup_test.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+class ProvisionerCleanupVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ProvisionerCleanup
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+  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
+      should "instantiate and prepare each provisioner" do
+        @env["config"].vm.provision :chef_solo
+        @env["config"].vm.provision :chef_solo
+        provisioners = @instance.enabled_provisioners
+
+        assert_equal 2, provisioners.length
+      end
+
+      should "set the config for each provisioner" do
+        @env["config"].vm.provision :chef_solo do |chef|
+          chef.cookbooks_path = "foo"
+        end
+
+        provisioners = @instance.enabled_provisioners
+
+        assert_equal "foo", provisioners.first.config.cookbooks_path
+      end
+    end
+
+    context "calling" do
+      should "provision and continue chain" do
+        provisioners = [mock("one"), mock("two")]
+        seq = sequence("seq")
+        @instance.stubs(:enabled_provisioners).returns(provisioners)
+        provisioners.each do |prov|
+          prov.expects(:cleanup).in_sequence(seq)
+        end
+        @app.expects(:call).with(@env).in_sequence(seq)
+
+        @instance.call(@env)
+      end
+    end
+  end
+end

data/test/unit_legacy/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/unit_legacy/vagrant/action/vm/share_folders_test.rb

@@ -0,0 +1,144 @@
+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
+    @env["vm.modify"] = mock("proc")
+
+    @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)
+
+      @env["vm.modify"].expects(:call).with() do |proc|
+        proc.call(@internal_vm)
+        true
+      end
+
+      @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", :owner => "yo", :group => "fo")
+        config.vm.share_folder("bar", "fooguest/foo", "barhost", :owner => "foo", :group => "bar")
+        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], data[:owner], data[:group]).in_sequence(mount_seq)
+        else
+          @vm.system.expects(:mount_shared_folder).with(@ssh, name, anything, anything, anything).never
+        end
+      end
+
+      @instance.mount_shared_folders
+    end
+  end
+end

data/test/unit_legacy/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/unit_legacy/vagrant/action_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class ActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action
+  end
+
+  context "with a class" do
+    teardown do
+      @klass.actions.delete(:foo)
+    end
+
+    should "be able to register an action" do
+      @klass.register(:foo, :bar)
+      assert @klass.actions.has_key?(:foo)
+      assert_equal :bar, @klass.actions[:foo]
+    end
+
+    should "be able to retrieve an action using []" do
+      @klass.register(:foo, :bar)
+      assert_equal :bar, @klass[:foo]
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new(vagrant_env)
+    end
+
+    should "raise an exception if a nil action is given" do
+      assert_raises(ArgumentError) { @instance.run(nil) }
+      assert_raises(ArgumentError) { @instance.run(:dontexist) }
+    end
+
+    should "run the callable item with the proper context" do
+      callable = mock("callable")
+      callable.expects(:call).with() do |env|
+        assert env.kind_of?(Vagrant::Action::Environment)
+        assert_equal @instance.env, env.env
+        true
+      end
+
+      @instance.run(callable)
+    end
+
+    should "run the callable with the passed in options if given" do
+      options = {
+        :key => :value,
+        :another => %W[1 2 3]
+      }
+
+      callable = mock("callable")
+      callable.expects(:call).with() do |env|
+        assert env.kind_of?(Vagrant::Action::Environment)
+        assert_equal @instance.env, env.env
+
+        options.each do |k,v|
+          assert_equal v, env[k]
+        end
+
+        true
+      end
+
+      @instance.run(callable, options)
+    end
+
+    should "run the registered callable if a symbol is given" do
+      callable = mock("callable")
+      callable.expects(:call).once
+
+      @klass.register(:call, callable)
+      @instance.run(:call)
+      @klass.actions.delete(:call)
+    end
+
+    should "run the given class if a class is given" do
+      callable = Class.new do
+        def initialize(app, env); end
+      end
+
+      callable.any_instance.expects(:call).with() do |env|
+        assert_equal :foo, env[:bar]
+        true
+      end
+
+      @instance.run(callable, :bar => :foo)
+    end
+  end
+end