vagrantup 0.4.3.dev → 0.5.0

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

@@ -1,99 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class ProvisionActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Provision)
-  end
-
-  context "initialization" do
-    should "have a nil provisioner by default" do
-      assert_nil @action.provisioner
-    end
-  end
-
-  context "executing" do
-    should "do nothing if the provisioner is nil" do
-      @action.expects(:provisioner).returns(nil)
-      assert_nothing_raised { @action.execute! }
-    end
-
-    should "call `provision!` on the provisioner" do
-      provisioner = mock("provisioner")
-      provisioner.expects(:provision!).once
-      @action.expects(:provisioner).twice.returns(provisioner)
-      @action.execute!
-    end
-  end
-
-  context "preparing" do
-    context "with a nil provisioner" do
-      setup do
-        @runner.env.config.vm.provisioner = nil
-      end
-
-      should "not set a provisioner if set to nil" do
-        @action.prepare
-        assert_nil @action.provisioner
-      end
-    end
-
-    context "with a Class provisioner" do
-      setup do
-        @instance = mock("instance")
-        @instance.stubs(:is_a?).with(Vagrant::Provisioners::Base).returns(true)
-        @instance.stubs(:prepare)
-        @klass = mock("klass")
-        @klass.stubs(:is_a?).with(Class).returns(true)
-        @klass.stubs(:new).with(@runner).returns(@instance)
-
-        @runner.env.config.vm.provisioner = @klass
-      end
-
-      should "set the provisioner to an instantiation of the class" do
-        @klass.expects(:new).with(@runner).once.returns(@instance)
-        assert_nothing_raised { @action.prepare }
-        assert_equal @instance, @action.provisioner
-      end
-
-      should "call prepare on the instance" do
-        @instance.expects(:prepare).once
-        @action.prepare
-      end
-
-      should "raise an exception if the class is not a subclass of the provisioner base" do
-        @instance.expects(:is_a?).with(Vagrant::Provisioners::Base).returns(false)
-        assert_raises(Vagrant::Actions::ActionException) {
-          @action.prepare
-        }
-      end
-    end
-
-    context "with a Symbol provisioner" do
-      def provisioner_expectation(symbol, provisioner)
-        @runner.env.config.vm.provisioner = symbol
-
-        instance = mock("instance")
-        instance.expects(:prepare).once
-        provisioner.expects(:new).with(@runner).returns(instance)
-        assert_nothing_raised { @action.prepare }
-        assert_equal instance, @action.provisioner
-      end
-
-      should "raise an ActionException if its an unknown symbol" do
-        @runner.env.config.vm.provisioner = :this_will_never_exist
-
-        assert_raises(Vagrant::Actions::ActionException) {
-          @action.prepare
-        }
-      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
-end

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

@@ -1,46 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class ReloadActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Reload)
-  end
-
-  context "sub-actions" do
-    setup do
-      @default_order = [Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network, Vagrant::Actions::VM::Boot]
-      @vm.stubs(:running?).returns(false)
-    end
-
-    def setup_action_expectations
-      default_seq = sequence("default_seq")
-      @default_order.each do |action|
-        @runner.expects(:add_action).with(action).once.in_sequence(default_seq)
-      end
-    end
-
-    should "do the proper actions by default" do
-      setup_action_expectations
-      @action.prepare
-    end
-
-    should "halt if the VM is running" do
-      @vm.expects(:running?).returns(true)
-      @default_order.unshift(Vagrant::Actions::VM::Halt)
-      setup_action_expectations
-      @action.prepare
-    end
-
-    should "add in the provisioning step if enabled" do
-      env = mock_environment do |config|
-        # Dummy provisioner to test
-        config.vm.provisioner = "foo"
-      end
-
-      @runner.stubs(:env).returns(env)
-
-      @default_order.push(Vagrant::Actions::VM::Provision)
-      setup_action_expectations
-      @action.prepare
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class ResumeActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Resume)
-  end
-
-  context "executing" do
-    setup do
-      @vm.stubs(:saved?).returns(true)
-    end
-
-    should "save the state of the VM" do
-      @runner.expects(:start).once
-      @action.execute!
-    end
-
-    should "raise an ActionException if the VM is not saved" do
-      @vm.expects(:saved?).returns(false)
-      @vm.expects(:start).never
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.execute!
-      }
-    end
-  end
-end

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

@@ -1,211 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class SharedFoldersActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::SharedFolders)
-    @runner.stubs(:system).returns(linux_system(@vm))
-  end
-
-  def stub_shared_folders
-    env = mock_environment do |config|
-      config.vm.shared_folders.clear
-
-      if block_given?
-        yield config
-      else
-        folders = [%w{foo fooguest foohost}, %w{bar barguest barhost}]
-        folders.each do |data|
-          config.vm.share_folder(*data)
-        end
-      end
-    end
-
-    @runner.stubs(:env).returns(env)
-    env.config.vm.shared_folders
-  end
-
-  context "before boot" do
-    should "clear folders and create metadata, in order" do
-      before_seq = sequence("before")
-      @action.expects(:clear_shared_folders).once.in_sequence(before_seq)
-      @action.expects(:create_metadata).once.in_sequence(before_seq)
-      @action.before_boot
-    end
-  end
-
-  context "after boot" do
-    should "mount folders then setup unison" do
-      seq = sequence("after")
-      @action.expects(:mount_shared_folders).once.in_sequence(seq)
-      @action.expects(:setup_unison).once.in_sequence(seq)
-      @action.after_boot
-    end
-  end
-
-  context "collecting shared folders" do
-    setup do
-      File.stubs(:expand_path).returns("baz")
-    end
-
-    should "return a hash of the shared folders" do
-      data = {
-        "foo" => %W[bar baz],
-        "bar" => %W[foo baz]
-      }
-
-      stub_shared_folders do |config|
-        data.each do |name, value|
-          config.vm.share_folder(name, *value)
-        end
-      end
-
-      result = @action.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 "append sync suffix if sync enabled to a folder" do
-      name = "foo"
-      guest = "bar"
-      host = "baz"
-
-      stub_shared_folders do |config|
-        config.vm.share_folder(name, guest, host, :sync => true)
-      end
-
-      result = @action.shared_folders
-      assert_equal "#{guest}#{@runner.env.config.unison.folder_suffix}", result[name][:guestpath]
-      assert_equal guest, result[name][:original][:guestpath]
-    end
-
-    should "not destroy original hash" do
-      @folders = stub_shared_folders do |config|
-        config.vm.share_folder("foo", "bar", "baz", :sync => true)
-      end
-
-      folder = @folders["foo"].dup
-
-      @action.shared_folders
-      assert_equal folder, @runner.env.config.vm.shared_folders["foo"]
-    end
-  end
-
-  context "unison shared folders" do
-    setup do
-      @folders = stub_shared_folders do |config|
-        config.vm.share_folder("foo", "bar", "baz", :sync => true)
-        config.vm.share_folder("bar", "foo", "baz")
-      end
-    end
-
-    should "only return the folders marked for syncing" do
-      result = @action.unison_folders
-      assert_equal 1, result.length
-      assert result.has_key?("foo")
-      assert !result.has_key?("bar")
-    end
-  end
-
-  context "clearing shared folders" do
-    setup do
-      @shared_folder = mock("shared_folder")
-      @shared_folders = [@shared_folder]
-      @vm.stubs(:shared_folders).returns(@shared_folders)
-    end
-
-    should "call destroy on each shared folder then reload" do
-      destroy_seq = sequence("destroy")
-      @shared_folders.each do |sf|
-        sf.expects(:destroy).once.in_sequence(destroy_seq)
-      end
-
-      @runner.expects(:reload!).once.in_sequence(destroy_seq)
-      @action.clear_shared_folders
-    end
-
-    should "do nothing if no shared folders existed" do
-      @shared_folders.clear
-      @runner.expects(:reload!).never
-      @action.clear_shared_folders
-    end
-  end
-
-  context "setting up shared folder metadata" do
-    setup do
-      stub_shared_folders
-    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", @runner.env.root_path)
-        assert data.include?(sf.name)
-        assert_equal hostpath, sf.host_path
-        true
-      end
-
-      @vm.stubs(:shared_folders).returns(shared_folders)
-      @vm.expects(:save).once
-
-      @action.create_metadata
-    end
-  end
-
-  context "mounting the shared folders" do
-    setup do
-      @folders = stub_shared_folders
-      @ssh = mock("ssh")
-      @runner.ssh.stubs(:execute).yields(@ssh)
-      @runner.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|
-        @runner.system.expects(:mount_shared_folder).with(@ssh, name, data[:guestpath]).in_sequence(mount_seq)
-      end
-
-      @action.mount_shared_folders
-    end
-  end
-
-  context "setting up unison" do
-    setup do
-      @ssh = mock("ssh")
-      @runner.ssh.stubs(:execute).yields(@ssh)
-
-      @folders = stub_shared_folders do |config|
-        config.vm.share_folder("foo", "bar", "baz", :sync => true)
-        config.vm.share_folder("bar", "foo", "baz")
-      end
-    end
-
-    should "do nothing if unison folders is empty" do
-      @action.stubs(:unison_folders).returns({})
-      @runner.ssh.expects(:execute).never
-      @action.setup_unison
-    end
-
-    should "prepare unison then create for each folder" do
-      seq = sequence("unison seq")
-      @runner.system.expects(:prepare_unison).with(@ssh).once.in_sequence(seq)
-      @action.unison_folders.each do |name, data|
-        if data[:sync]
-          @runner.system.expects(:create_unison).with do |ssh, opts|
-            assert_equal @ssh, ssh
-            assert_equal data, opts
-
-            true
-          end
-        end
-      end
-
-      @action.setup_unison
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class StartActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Start)
-
-    @action.options[:provision] = true
-  end
-
-  context "sub-actions" do
-    setup do
-      @runner.stubs(:created?).returns(false)
-      @vm.stubs(:saved?).returns(true)
-      File.stubs(:file?).returns(true)
-      File.stubs(:exist?).returns(true)
-      @default_order = [Vagrant::Actions::VM::Boot]
-    end
-
-    def setup_action_expectations
-      default_seq = sequence("default_seq")
-      @default_order.flatten.each do |action|
-        @runner.expects(:add_action).with(action, @action.options).once.in_sequence(default_seq)
-      end
-    end
-
-    should "do the proper actions by default" do
-      setup_action_expectations
-      @action.prepare
-    end
-
-    should "add customize to the beginning if its not saved" do
-      @vm.expects(:saved?).returns(false)
-      @default_order.unshift([Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network])
-      setup_action_expectations
-      @action.prepare
-    end
-
-    should "add do additional if VM is not created yet" do
-      @runner.stubs(:vm).returns(nil)
-      @default_order.unshift([Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network])
-      setup_action_expectations
-      @action.prepare
-    end
-
-    should "add provisioning if its enabled and not saved" do
-      @vm.env.config.vm.provisioner = :chef_solo
-
-      @runner.stubs(:vm).returns(nil)
-      @default_order.unshift([Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network])
-      @default_order << Vagrant::Actions::VM::Provision
-      setup_action_expectations
-      @action.prepare
-    end
-  end
-
-  context "provision?" do
-    should "return false if no provisioner is set" do
-      @vm.env.config.vm.provisioner = nil
-      assert !@action.provision?
-    end
-
-    should "return true if a provisioner is set" do
-      @vm.env.config.vm.provisioner = :chef_solo
-      assert @action.provision?
-    end
-
-    should "return false if provisioning is specifically disabled" do
-      @vm.env.config.vm.provisioner = :chef_solo
-      @action.options[:provision] = false
-      assert !@action.provision?
-    end
-  end
-end