bmabey-vagrant 0.2.0

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

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class StartActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Start)
+    mock_config
+  end
+
+  context "sub-actions" do
+    setup do
+      @vm.stubs(:saved?).returns(true)
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      @default_order = [Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+    end
+
+    def setup_action_expectations
+      default_seq = sequence("default_seq")
+      @default_order.each do |action|
+        @mock_vm.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 "add customize to the beginning if its not saved" do
+      @vm.expects(:saved?).returns(false)
+      @default_order.unshift(Vagrant::Actions::VM::Customize)
+      setup_action_expectations
+      @action.prepare
+    end
+  end
+end

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

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

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

@@ -0,0 +1,107 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class UpActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Up)
+    mock_config
+  end
+
+  context "sub-actions" do
+    setup do
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      @default_order = [Vagrant::Actions::VM::Import, Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+
+      @dotfile_path = "foo"
+      @runner.env.stubs(:dotfile_path).returns(@dotfile_path)
+    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 "raise an ActionException if a dotfile exists but is not a file" do
+      File.expects(:file?).with(@runner.env.dotfile_path).returns(false)
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "not raise an ActionException if dotfile doesn't exist" do
+      setup_action_expectations
+      File.stubs(:exist?).returns(false)
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "not raise an ActionException if dotfile exists but is a file" do
+      File.stubs(:file?).returns(true)
+      File.stubs(:exist?).returns(true)
+      setup_action_expectations
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "do the proper actions by default" do
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "add in the provisioning step if enabled" do
+      env = mock_environment do |config|
+        config.vm.provisioner = "foo"
+      end
+
+      @runner.stubs(:env).returns(env)
+      env.stubs(:dotfile_path).returns(@dotfile_path)
+
+      @default_order.push(Vagrant::Actions::VM::Provision)
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "add in the action to move hard drive if config is set" do
+      env = mock_environment do |config|
+        File.expects(:directory?).with("foo").returns(true)
+        config.vm.hd_location = "foo"
+      end
+
+      @runner.stubs(:env).returns(env)
+      env.stubs(:dotfile_path).returns(@dotfile_path)
+
+      @default_order.insert(0, Vagrant::Actions::VM::MoveHardDrive)
+      setup_action_expectations
+      @action.prepare
+    end
+  end
+
+  context "callbacks" do
+    should "call persist and mac address setup after import" do
+      boot_seq = sequence("boot")
+      @action.expects(:persist).once.in_sequence(boot_seq)
+      @action.expects(:setup_mac_address).once.in_sequence(boot_seq)
+      @action.after_import
+    end
+  end
+
+  context "persisting" do
+    should "persist the VM with Env" do
+      @runner.stubs(:uuid)
+      @runner.env.expects(:persist_vm).once
+      @action.persist
+    end
+  end
+
+  context "setting up MAC address" do
+    should "match the mac address with the base" do
+      nic = mock("nic")
+      nic.expects(:macaddress=).once
+
+      @vm.expects(:nics).returns([nic]).once
+      @vm.expects(:save).with(true).once
+
+      @action.setup_mac_address
+    end
+  end
+end

data/test/vagrant/active_list_test.rb

@@ -0,0 +1,190 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ActiveListTest < Test::Unit::TestCase
+  setup do
+    mock_config
+
+    @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 [], @list.list(true)
+    end
+
+    should "parse the JSON by reading the file" do
+      file = mock("file")
+      data = mock("data")
+      result = mock("result")
+      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
+  end
+
+  context "vms" do
+    setup do
+      @the_list = ["foo", "bar"]
+      @list.stubs(:list).returns(@the_list)
+    end
+
+    should "return the list, but with each value as a VM" do
+      new_seq = sequence("new")
+      results = []
+      @the_list.each do |item|
+        result = mock("result-#{item}")
+        Vagrant::VM.expects(:find).with(item).returns(result).in_sequence(new_seq)
+        results << result
+      end
+
+      assert_equal results, @list.vms
+    end
+
+    should "compact out the nil values" do
+      Vagrant::VM.stubs(:find).returns(nil)
+      results = @list.vms
+      assert results.empty?
+    end
+  end
+
+  context "filtered list" do
+    should "return a list of UUIDs from the VMs" do
+      vms = []
+      result = []
+      5.times do |i|
+        vm = mock("vm#{i}")
+        vm.expects(:uuid).returns(i)
+        result << i
+        vms << vm
+      end
+
+      @list.stubs(:vms).returns(vms)
+      assert_equal result, @list.filtered_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_equal [@uuid], @the_list
+    end
+
+    should "uniq the array so multiples never exist" do
+      @the_list << @uuid
+      assert_equal 1, @the_list.length
+      @list.add(@vm)
+      assert_equal 1, @the_list.length
+    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(:filtered_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,151 @@
+require File.join(File.dirname(__FILE__), '..', '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
+    end
+
+    should "execute the Add action when add is called" do
+      @box.expects(:execute!).with(Vagrant::Actions::Box::Add).once
+      @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.expects(:execute!).with(Vagrant::Actions::Box::Destroy).once
+        @box.destroy
+      end
+    end
+
+    context "ovf file" do
+      setup do
+        @box.stubs(:directory).returns("foo")
+      end
+
+      should "be the directory joined with the config ovf file" do
+        assert_equal File.join(@box.directory, Vagrant.config.vm.box_ovf), @box.ovf_file
+      end
+    end
+  end
+end