vagrantup 0.5.2 → 0.5.3

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

@@ -0,0 +1,215 @@
+require "test_helper"
+
+class ShareFoldersVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ShareFolders
+    @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)
+
+    @instance = @klass.new(@app, @env)
+  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
+
+    @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.expects(:setup_unison).once.in_sequence(before_seq)
+
+      @instance.call(@env)
+    end
+
+    should "run only the metadata actions if erroneous environment" do
+      @env.error!(:foo)
+
+      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).never
+      @instance.expects(:setup_unison).never
+
+      @instance.call(@env)
+    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 = @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 do |config|
+        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")
+      end
+
+      assert_equal 2, @instance.shared_folders.length
+      assert_equal %W[v-bar v-foo], @instance.shared_folders.keys.sort
+    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 = @instance.shared_folders
+      assert_equal "#{guest}#{@env.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
+
+      @instance.shared_folders
+      assert_equal folder, @env.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 = @instance.unison_folders
+      assert_equal 1, result.length
+      assert result.has_key?("foo")
+      assert !result.has_key?("bar")
+    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", @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
+      @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|
+        @vm.system.expects(:mount_shared_folder).with(@ssh, name, data[:guestpath]).in_sequence(mount_seq)
+      end
+
+      @instance.mount_shared_folders
+    end
+  end
+
+  context "setting up unison" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.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
+      @instance.stubs(:unison_folders).returns({})
+      @vm.ssh.expects(:execute).never
+      @instance.setup_unison
+    end
+
+    should "prepare unison then create for each folder" do
+      seq = sequence("unison seq")
+      @vm.system.expects(:prepare_unison).with(@ssh).once.in_sequence(seq)
+      @instance.unison_folders.each do |name, data|
+        if data[:sync]
+          @vm.system.expects(:create_unison).with do |ssh, opts|
+            assert_equal @ssh, ssh
+            assert_equal data, opts
+
+            true
+          end
+        end
+      end
+
+      @instance.setup_unison
+    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 = 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 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_test.rb

@@ -0,0 +1,111 @@
+require "test_helper"
+
+class ActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action
+  end
+
+  context "with a class" do
+    teardown do
+      @klass.actions.clear
+    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(mock_environment)
+    end
+
+    teardown do
+      @klass.actions.clear
+    end
+
+    should "raise an exception if a nil action is given" do
+      assert_raises(Vagrant::Exceptions::UncallableAction) { @instance.run(nil) }
+      assert_raises(Vagrant::Exceptions::UncallableAction) { @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)
+    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
+
+    should "exit if environment was marked as interrupted" do
+      callable = lambda do |env|
+        env.error!(:interrupt)
+      end
+
+      @instance.stubs(:error_and_exit)
+      @instance.expects(:exit).once
+      @instance.run(callable)
+    end
+
+    should "error and exit if erroneous environment results" do
+      callable = lambda do |env|
+        env.error!(:key, :foo => :bar)
+      end
+
+      @instance.expects(:error_and_exit).with(:key, :foo => :bar)
+      @instance.run(callable)
+    end
+  end
+end

data/test/vagrant/active_list_test.rb

@@ -0,0 +1,173 @@
+require "test_helper"
+
+class ActiveListTest < Test::Unit::TestCase
+  setup do
+    @env = mock_environment
+    @list = Vagrant::ActiveList.new(@env)
+  end
+
+  context "initializing" do
+    should "set the environment to nil if not specified" do
+      assert_nothing_raised {
+        list = Vagrant::ActiveList.new
+        assert list.env.nil?
+      }
+    end
+
+    should "set the environment to the given parameter if specified" do
+      env = mock("env")
+      list = Vagrant::ActiveList.new(env)
+      assert_equal env, list.env
+    end
+  end
+
+  context "listing" do
+    setup do
+      @path = "foo"
+      @list.stubs(:path).returns(@path)
+    end
+
+    should "load if reload is given" do
+      File.stubs(:file?).returns(true)
+      File.expects(:open).once
+      @list.list(true)
+    end
+
+    should "not load if the active json file doesn't exist" do
+      File.expects(:file?).with(@list.path).returns(false)
+      File.expects(:open).never
+      assert_equal Hash.new, @list.list(true)
+    end
+
+    should "parse the JSON by reading the file" do
+      file = mock("file")
+      data = mock("data")
+      result = { :hey => :yep }
+      File.expects(:file?).returns(true)
+      File.expects(:open).with(@list.path, 'r').once.yields(file)
+      file.expects(:read).returns(data)
+      JSON.expects(:parse).with(data).returns(result)
+      assert_equal result, @list.list(true)
+    end
+
+    should "not load if reload flag is false and already loaded" do
+      File.expects(:file?).once.returns(false)
+      result = @list.list(true)
+      assert result.equal?(@list.list)
+      assert result.equal?(@list.list)
+      assert result.equal?(@list.list)
+    end
+
+    should "be an empty hash if JSON parsing raises an exception" do
+      file = mock("file")
+      file.stubs(:read)
+      File.expects(:file?).returns(true)
+      File.expects(:open).with(@list.path, 'r').once.yields(file)
+      JSON.expects(:parse).raises(Exception)
+
+      assert_nothing_raised do
+        assert_equal Hash.new, @list.list(true)
+      end
+    end
+  end
+
+  context "filter list" do
+    should "remove nonexistent VMs" do
+      list = {}
+      result = {}
+      5.times do |i|
+        vm = mock("vm#{i}")
+        vm.stubs(:uuid).returns(i)
+
+        list[vm.uuid] = {}
+
+        found_vm = i % 2 ? nil : vm
+        Vagrant::VM.stubs(:find).with(vm.uuid, @env).returns(found_vm)
+        results[vm.uuid] = {} if found_vm
+      end
+
+      @list.stubs(:list).returns(list)
+      assert_equal result, @list.filter_list
+    end
+  end
+
+  context "adding a VM to the list" do
+    setup do
+      @the_list = {}
+      @list.stubs(:list).returns(@the_list)
+      @list.stubs(:save)
+
+      @uuid = "foo"
+      @vm = mock("vm")
+      @vm.stubs(:uuid).returns(@uuid)
+    end
+
+    should "add the VMs UUID to the list" do
+      @list.add(@vm)
+      assert @the_list[@uuid]
+      assert @the_list[@uuid].is_a?(Hash)
+    end
+
+    should "save after adding" do
+      save_seq = sequence('save')
+      @the_list.expects(:[]=).in_sequence(save_seq)
+      @list.expects(:save).in_sequence(save_seq)
+      @list.add(@vm)
+    end
+  end
+
+  context "deleting a VM from the list" do
+    setup do
+      @the_list = ["bar"]
+      @list.stubs(:list).returns(@the_list)
+      @list.stubs(:save)
+
+      @uuid = "bar"
+      @vm = mock("vm")
+      @vm.stubs(:uuid).returns(@uuid)
+      @vm.stubs(:is_a?).with(Vagrant::VM).returns(true)
+    end
+
+    should "delete the uuid from the list of a VM" do
+      @list.remove(@vm)
+      assert @the_list.empty?
+    end
+
+    should "delete just the string if a string is given" do
+      @the_list << "zoo"
+      @list.remove("zoo")
+      assert !@the_list.include?("zoo")
+    end
+
+    should "save after removing" do
+      save_seq = sequence('save')
+      @the_list.expects(:delete).in_sequence(save_seq)
+      @list.expects(:save).in_sequence(save_seq)
+      @list.remove(@vm)
+    end
+  end
+
+  context "saving" do
+    setup do
+      @filtered = ["zoo"]
+      @list.stubs(:filter_list).returns(@filtered)
+    end
+
+    should "open the JSON path and save to it" do
+      file = mock("file")
+      File.expects(:open).with(@list.path, "w+").yields(file)
+      file.expects(:write).with(@filtered.to_json)
+      @list.save
+    end
+  end
+
+  context "path" do
+    setup do
+      @env.stubs(:home_path).returns("foo")
+    end
+
+    should "return the active file within the home path" do
+      assert_equal File.join(@env.home_path, Vagrant::ActiveList::FILENAME), @list.path
+    end
+  end
+end

data/test/vagrant/box_test.rb

@@ -0,0 +1,166 @@
+require "test_helper"
+
+class BoxTest < Test::Unit::TestCase
+  context "class methods" do
+    setup do
+      @env = mock_environment
+    end
+
+    context "listing all boxes" do
+      setup do
+        Dir.stubs(:open)
+        File.stubs(:directory?).returns(true)
+
+        @boxes_path = "foo"
+        @env.stubs(:boxes_path).returns(@boxes_path)
+      end
+
+      should "open the boxes directory" do
+        Dir.expects(:open).with(@env.boxes_path)
+        Vagrant::Box.all(@env)
+      end
+
+      should "return an array" do
+        result = Vagrant::Box.all(@env)
+        assert result.is_a?(Array)
+      end
+
+      should "not return the '.' and '..' directories" do
+        dir = [".", "..", "..", ".", ".."]
+        Dir.expects(:open).yields(dir)
+        result = Vagrant::Box.all(@env)
+        assert result.empty?
+      end
+
+      should "return the other directories" do
+        dir = [".", "foo", "bar", "baz"]
+        Dir.expects(:open).yields(dir)
+        result = Vagrant::Box.all(@env)
+        assert_equal ["foo", "bar", "baz"], result
+      end
+
+      should "ignore the files" do
+        dir = ["foo", "bar"]
+        files = [true, false]
+        Dir.expects(:open).yields(dir)
+        dir_sequence = sequence("directory")
+        dir.each_with_index do |dir, index|
+          File.expects(:directory?).with(File.join(@boxes_path, dir)).returns(files[index]).in_sequence(dir_sequence)
+        end
+
+        result = Vagrant::Box.all(@env)
+        assert_equal ["foo"], result
+      end
+    end
+
+    context "finding" do
+      setup do
+        @dir = "foo"
+        @name = "bar"
+        Vagrant::Box.stubs(:directory).with(@env, @name).returns(@dir)
+      end
+
+      should "return nil if the box doesn't exist" do
+        File.expects(:directory?).with(@dir).once.returns(false)
+        assert_nil Vagrant::Box.find(@env, @name)
+      end
+
+      should "return a box object with the proper name set" do
+        File.expects(:directory?).with(@dir).once.returns(true)
+        result = Vagrant::Box.find(@env, @name)
+        assert result
+        assert_equal @name, result.name
+      end
+
+      should "return a box object with the proper env set" do
+        File.expects(:directory?).with(@dir).once.returns(true)
+        result = Vagrant::Box.find(@env, @name)
+        assert result
+        assert_equal @env, result.env
+      end
+    end
+
+    context "adding" do
+      setup do
+        @name = "foo"
+        @uri = "bar"
+      end
+
+      should "create a new instance, set the variables, and add it" do
+        box = mock("box")
+        box.expects(:name=).with(@name)
+        box.expects(:uri=).with(@uri)
+        box.expects(:env=).with(@env)
+        box.expects(:add).once
+        Vagrant::Box.expects(:new).returns(box)
+        Vagrant::Box.add(@env, @name, @uri)
+      end
+    end
+
+    context "box directory" do
+      setup do
+        @name = "foo"
+        @box_dir = File.join(@env.boxes_path, @name)
+      end
+
+      should "return the boxes_path joined with the name" do
+        assert_equal @box_dir, Vagrant::Box.directory(@env, @name)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @box = Vagrant::Box.new
+      @box.env = mock_environment
+    end
+
+    should "execute the Add action when add is called" do
+      @box.env.actions.expects(:run).with(:box_add, { "box" => @box })
+      @box.add
+    end
+
+    context "box directory" do
+      setup do
+        @box.name = "foo"
+      end
+
+      should "return the boxes_path joined with the name" do
+        result = mock("object")
+        Vagrant::Box.expects(:directory).with(@box.env, @box.name).returns(result)
+        assert result.equal?(@box.directory)
+      end
+    end
+
+    context "destroying" do
+      should "execute the destroy action" do
+        @box.env.actions.expects(:run).with(:box_remove, { "box" => @box })
+        @box.destroy
+      end
+    end
+
+    context "repackaging" do
+      should "execute the repackage action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box })
+        @box.repackage
+      end
+
+      should "forward given options into the action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "foo" => "bar" })
+        @box.repackage("foo" => "bar")
+      end
+    end
+
+    context "ovf file" do
+      setup do
+        @box.stubs(:directory).returns("foo")
+
+        @box.env.config.vm.box_ovf = "foo.ovf"
+      end
+
+      should "be the directory joined with the config ovf file" do
+        assert_equal File.join(@box.directory, @box.env.config.vm.box_ovf), @box.ovf_file
+      end
+    end
+  end
+end