vagrantup 0.5.2 → 0.5.3

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

@@ -0,0 +1,269 @@
+require "test_helper"
+
+class NFSVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::NFS
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @vm.stubs(:system).returns(mock("system"))
+    @env.env.stubs(:host).returns(Vagrant::Hosts::Base.new(@env))
+    @env.env.config.vm.network("192.168.55.1")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+  end
+
+  context "initializing" do
+    should "not call verify settings if NFS is not enabled" do
+      @klass.any_instance.expects(:verify_settings).never
+      @klass.new(@app, @env)
+    end
+
+    should "call verify settings if NFS is enabled" do
+      @env.env.config.vm.share_folder("v-root", "/vagrant", ".", :nfs => true)
+      @klass.any_instance.expects(:verify_settings).once
+      @klass.new(@app, @env)
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new(@app, @env)
+    end
+
+    context "calling" do
+      setup do
+        @instance.stubs(:folders).returns([:a])
+
+        [:clear_nfs_exports, :extract_folders, :prepare_folders, :export_folders, :mount_folders].each do |meth|
+          @instance.stubs(meth)
+        end
+      end
+
+      should "call the proper sequence and succeed" do
+        seq = sequence('seq')
+        @instance.expects(:extract_folders).in_sequence(seq)
+        @instance.expects(:prepare_folders).in_sequence(seq)
+        @instance.expects(:clear_nfs_exports).with(@env).in_sequence(seq)
+        @instance.expects(:export_folders).in_sequence(seq)
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.expects(:mount_folders).in_sequence(seq)
+        @instance.call(@env)
+      end
+
+      should "not export folders if folders is empty" do
+        @instance.stubs(:folders).returns([])
+
+        seq = sequence('seq')
+        @instance.expects(:extract_folders).in_sequence(seq)
+        @instance.expects(:prepare_folders).never
+        @instance.expects(:export_folders).never
+        @instance.expects(:clear_nfs_exports).never
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.expects(:mount_folders).never
+        @instance.call(@env)
+      end
+
+      should "halt chain if environment error occured" do
+        @env.error!(:foo)
+
+        seq = sequence('seq')
+        @instance.expects(:extract_folders).in_sequence(seq)
+        @instance.expects(:prepare_folders).in_sequence(seq)
+        @instance.expects(:clear_nfs_exports).in_sequence(seq)
+        @instance.expects(:export_folders).in_sequence(seq)
+        @app.expects(:call).never
+        @instance.call(@env)
+      end
+
+      should "not mount folders if an error occured" do
+        seq = sequence("seq")
+        @app.expects(:call).in_sequence(seq).with() do
+          # Use this mark the env as error
+          @env.error!(:foo)
+
+          true
+        end
+
+        @instance.expects(:clear_nfs_exports).with(@env).in_sequence(seq)
+
+        @instance.expects(:mount_folders).never
+        @instance.call(@env)
+      end
+    end
+
+    context "extracting folders" do
+      setup do
+        @env.env.config.vm.shared_folders.clear
+        @env.env.config.vm.share_folder("v-foo", "/foo", ".", :nfs => true)
+        @env.env.config.vm.share_folder("v-bar", "/bar", ".", :nfs => true)
+      end
+
+      should "extract the NFS enabled folders" do
+        @instance.extract_folders
+        assert_equal 2, @instance.folders.length
+      end
+
+      should "mark the folders disabled from the original config" do
+        @instance.extract_folders
+        %W[v-foo v-bar].each do |key|
+          assert @env["config"].vm.shared_folders[key][:disabled]
+        end
+      end
+
+      should "expand the hostpath relative to the env root" do
+        @instance.extract_folders
+        %W[v-foo v-bar].each do |key|
+          opts = @env["config"].vm.shared_folders[key]
+          assert_equal File.expand_path(opts[:hostpath], @env.env.root_path), @instance.folders[key][:hostpath]
+        end
+      end
+    end
+
+    context "preparing UID/GID" do
+      setup do
+        @stat = mock("stat")
+        File.stubs(:stat).returns(@stat)
+      end
+
+      should "return nil if the perm is not set" do
+        assert_nil @instance.prepare_permission(:uid, {:gid => 7})
+      end
+
+      should "return nil if the perm explicitly says nil" do
+        assert_nil @instance.prepare_permission(:uid, {:uid => nil})
+      end
+
+      should "return the set value if it is set" do
+        assert_equal 7, @instance.prepare_permission(:gid, {:map_gid => 7})
+      end
+
+      should "return the global config value if set and not explicitly set on folder" do
+        @env.env.config.nfs.map_gid = 12
+        assert_equal 12, @instance.prepare_permission(:gid, {})
+      end
+
+      should "return the stat result of the hostpath if :auto" do
+        opts = { :hostpath => "foo", :map_uid => :auto }
+        File.expects(:stat).with(opts[:hostpath]).returns(@stat)
+        @stat.stubs(:uid).returns(24)
+
+        assert_equal 24, @instance.prepare_permission(:uid, opts)
+      end
+    end
+
+    context "exporting folders" do
+      setup do
+        @instance.stubs(:folders).returns({})
+        @instance.stubs(:guest_ip).returns("192.168.33.10")
+      end
+
+      should "call nfs_export on the host" do
+        @env["host"].expects(:nfs_export).with(@instance.guest_ip, @instance.folders)
+        @instance.export_folders
+      end
+
+      should "error the environment if exception is raised" do
+        @env["host"].expects(:nfs_export).raises(Vagrant::Action::ActionException.new(:foo))
+        @instance.export_folders
+        assert @env.error?
+        assert_equal :foo, @env.error.first
+      end
+    end
+
+    context "mounting folders" do
+      setup do
+        @instance.stubs(:host_ip).returns("foo")
+        @instance.stubs(:folders).returns(["bar"])
+      end
+
+      should "mount the folders on the system" do
+        @vm.system.expects(:mount_nfs).with(@instance.host_ip, @instance.folders)
+        @instance.mount_folders
+      end
+    end
+
+    context "getting the host IP" do
+      setup do
+        @network_adapters = []
+        @internal_vm.stubs(:network_adapters).returns(@network_adapters)
+      end
+
+      def stub_interface(ip)
+        interface = mock("interface")
+        adapter = mock("adapter")
+        adapter.stubs(:host_interface_object).returns(interface)
+        interface.stubs(:ip_address).returns(ip)
+
+        @network_adapters << adapter
+        interface
+      end
+
+      should "return the IP of the first interface" do
+        ip = "192.168.1.1"
+        stub_interface(ip)
+
+        assert_equal ip, @instance.host_ip
+      end
+
+      should "return nil if no IP is found" do
+        assert_nil @instance.host_ip
+      end
+    end
+
+    context "getting the guest IP" do
+      should "return the first networked IP" do
+        ip = "192.168.33.10"
+        @env.env.config.vm.network(ip, :adapter => 1)
+        @env.env.config.vm.network("192.168.66.10", :adapter => 2)
+        assert_equal ip, @instance.guest_ip
+      end
+    end
+
+    context "nfs enabled" do
+      should "return false if no folders are marked for NFS" do
+        assert !@instance.nfs_enabled?
+      end
+
+      should "return true if a shared folder is marked for NFS" do
+        @env.env.config.vm.share_folder("v-foo", "/foo", "/bar", :nfs => true)
+        assert @instance.nfs_enabled?
+      end
+    end
+
+    context "verifying settings" do
+      setup do
+        @env.env.host.stubs(:nfs?).returns(true)
+      end
+
+      should "error environment if host is nil" do
+        @env.env.stubs(:host).returns(nil)
+        @instance.verify_settings
+        assert @env.error?
+        assert_equal :nfs_host_required, @env.error.first
+      end
+
+      should "error environment if host does not support NFS" do
+        @env.env.host.stubs(:nfs?).returns(false)
+        @instance.verify_settings
+        assert @env.error?
+        assert_equal :nfs_not_supported, @env.error.first
+      end
+
+      should "error environment if host only networking is not enabled" do
+        @env.env.config.vm.network_options.clear
+        @instance.verify_settings
+        assert @env.error?
+        assert_equal :nfs_no_host_network, @env.error.first
+      end
+
+      should "be fine if everything passes" do
+        @env.env.host.stubs(:nfs?).returns(true)
+        @instance.verify_settings
+        assert !@env.error?
+      end
+    end
+  end
+end

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 = mock_action_data
+    @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 = mock_action_data
+
+    @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/persist_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+
+class PersistVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Persist
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @vm.stubs(:uuid).returns("123")
+    @env["vm"] = @vm
+  end
+
+  context "initializing" do
+    setup do
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      @dotfile_path = "foo"
+      @env.env.stubs(:dotfile_path).returns(@dotfile_path)
+    end
+
+    should "error environment if dotfile exists but is not a file" do
+      File.expects(:file?).with(@env.env.dotfile_path).returns(false)
+      @klass.new(@app, @env)
+      assert @env.error?
+      assert_equal :dotfile_error, @env.error.first
+    end
+
+    should "initialize properly if dotfiles doesn't exist" do
+      File.expects(:exist?).with(@env.env.dotfile_path).returns(false)
+      @klass.new(@app, @env)
+      assert !@env.error?
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      @instance = @klass.new(@app, @env)
+    end
+
+    should "persist the dotfile then continue chain" do
+      update_seq = sequence("update_seq")
+      @env.env.expects(:update_dotfile).in_sequence(update_seq)
+      @app.expects(:call).with(@env).in_sequence(update_seq)
+
+      @instance.call(@env)
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+require "test_helper"
+
+class ProvisionVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Provision
+    @app, @env = mock_action_data
+
+    @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_provisioner)
+    end
+
+    should "load provisioner if provisioning enabled" do
+      @env["config"].vm.provisioner = :chef_solo
+      @klass.any_instance.expects(:load_provisioner).once
+      @klass.new(@app, @env)
+    end
+
+    should "not load provisioner if disabled" do
+      @env["config"].vm.provisioner = nil
+      @klass.any_instance.expects(:load_provisioner).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.provisioner = nil
+      @instance = @klass.new(@app, @env)
+    end
+
+    context "loading a provisioner" do
+      context "with a Class provisioner" do
+        setup do
+          @prov = mock("instance")
+          @prov.stubs(:is_a?).with(Vagrant::Provisioners::Base).returns(true)
+          @prov.stubs(:prepare)
+          @klass = mock("klass")
+          @klass.stubs(:is_a?).with(Class).returns(true)
+          @klass.stubs(:new).with(@env).returns(@prov)
+
+          @env["config"].vm.provisioner = @klass
+        end
+
+        should "set the provisioner to an instantiation of the class" do
+          @klass.expects(:new).with(@env).once.returns(@prov)
+          assert_equal @prov, @instance.load_provisioner
+        end
+
+        should "call prepare on the instance" do
+          @prov.expects(:prepare).once
+          @instance.load_provisioner
+        end
+
+        should "error environment if the class is not a subclass of the provisioner base" do
+          @prov.expects(:is_a?).with(Vagrant::Provisioners::Base).returns(false)
+          @instance.load_provisioner
+          assert @env.error?
+          assert_equal :provisioner_invalid_class, @env.error.first
+        end
+      end
+
+      context "with a Symbol provisioner" do
+        def provisioner_expectation(symbol, provisioner)
+          @env[:config].vm.provisioner = symbol
+
+          instance = mock("instance")
+          instance.expects(:prepare).once
+          provisioner.expects(:new).with(@env).returns(instance)
+          assert_equal instance, @instance.load_provisioner
+        end
+
+        should "raise an ActionException if its an unknown symbol" do
+          @env["config"].vm.provisioner = :this_will_never_exist
+          @instance.load_provisioner
+          assert @env.error?
+          assert_equal :provisioner_unknown_type, @env.error.first
+        end
+
+        should "set :chef_solo to the ChefSolo provisioner" do
+          provisioner_expectation(:chef_solo, Vagrant::Provisioners::ChefSolo)
+        end
+
+        should "set :chef_server to the ChefServer provisioner" do
+          provisioner_expectation(:chef_server, Vagrant::Provisioners::ChefServer)
+        end
+      end
+    end
+
+    context "calling" do
+      setup do
+        Vagrant::Provisioners::ChefSolo.any_instance.stubs(:prepare)
+        @env["config"].vm.provisioner = :chef_solo
+        @prov = @instance.load_provisioner
+      end
+
+      should "provision and continue chain" do
+        seq = sequence("seq")
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @prov.expects(:provision!).in_sequence(seq)
+
+        @instance.call(@env)
+      end
+
+      should "continue chain and not provision if not enabled" do
+        @env["config"].vm.provisioner = nil
+        @prov.expects(:provision!).never
+        @app.expects(:call).with(@env).once
+
+        @instance.call(@env)
+      end
+
+      should "not provision if erroneous environment" do
+        @env.error!(:foo)
+
+        @prov.expects(:provision!).never
+        @app.expects(:call).with(@env).once
+
+        @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 = mock_action_data
+
+    @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