vagrant 1.0.7 → 1.5.0

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

@@ -1,25 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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