vagrant 0.1.0

data/test/vagrant/box_test.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BoxTest < Test::Unit::TestCase
+  context "class methods" do
+    context "finding" do
+      setup do
+        @dir = "foo"
+        @name = "bar"
+        Vagrant::Box.stubs(:directory).with(@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(@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(@name)
+        assert result
+        assert_equal @name, result.name
+      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(:add).once
+        Vagrant::Box.expects(:new).returns(box)
+        Vagrant::Box.add(@name, @uri)
+      end
+    end
+
+    context "box directory" do
+      setup do
+        @name = "foo"
+        @box_dir = File.join(Vagrant::Env.boxes_path, @name)
+      end
+
+      should "return the boxes_path joined with the name" do
+        assert_equal @box_dir, Vagrant::Box.directory(@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.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

data/test/vagrant/busy_test.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BusyTest < Test::Unit::TestCase
+  context "waiting for not busy" do
+    setup do
+      Vagrant::Busy.reset_trap_thread!
+    end
+
+    should "run in a thread" do
+      Thread.expects(:new).once.returns(nil)
+      Vagrant::Busy.wait_for_not_busy
+    end
+
+    should "not start a thread multiple times" do
+      Thread.expects(:new).once.returns("foo")
+      Vagrant::Busy.wait_for_not_busy
+    end
+  end
+
+  context "during an action in a busy block" do
+    should "report as busy" do
+      Vagrant.busy do
+        # Inside the block Vagrant.busy? should be true
+        assert Vagrant.busy?
+      end
+
+      #After the block finishes Vagrant.busy? should be false
+      assert !Vagrant.busy?
+    end
+
+    should "set busy to false upon exception and reraise the error" do
+      assert_raise Exception do
+        Vagrant.busy do
+          assert Vagrant.busy?
+          raise Exception
+        end
+      end
+
+      assert !Vagrant.busy?
+    end
+
+    should "complete the trap thread even if an exception occurs" do
+      trap_thread = mock("trap_thread")
+      trap_thread.expects(:join).once
+      Vagrant::Busy.stubs(:trap_thread).returns(trap_thread)
+
+      assert_raise Exception do
+        Vagrant.busy do
+          raise Exception
+        end
+      end
+    end
+
+    should "report busy to the outside world regardless of thread" do
+      Thread.new do
+        Vagrant.busy do
+          sleep(1)
+        end
+      end
+
+      # While the above thread is executing vagrant should be busy
+      assert Vagrant.busy?
+    end
+
+    should "run the action in a new thread" do
+      runner_thread = nil
+      Vagrant.busy do
+        runner_thread = Thread.current
+      end
+
+      assert_not_equal Thread.current, runner_thread
+    end
+
+    should "trap INT" do
+      trap_seq = sequence("trap_seq")
+      Signal.expects(:trap).with("INT", anything).once.in_sequence(trap_seq)
+      Signal.expects(:trap).with("INT", "DEFAULT").once.in_sequence(trap_seq)
+      Vagrant.busy do; end
+    end
+  end
+end

data/test/vagrant/commands_test.rb

@@ -0,0 +1,252 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class CommandsTest < Test::Unit::TestCase
+  setup do
+    Vagrant::Env.stubs(:load!)
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+    Vagrant::Env.stubs(:persisted_vm).returns(@persisted_vm)
+  end
+
+  context "init" do
+    setup do
+      File.stubs(:copy)
+      @rootfile_path = File.join(Dir.pwd, Vagrant::Env::ROOTFILE_NAME)
+      @template_path = File.join(PROJECT_ROOT, "templates", Vagrant::Env::ROOTFILE_NAME)
+    end
+
+    should "error and exit if a rootfile already exists" do
+      File.expects(:exist?).with(@rootfile_path).returns(true)
+      Vagrant::Commands.expects(:error_and_exit).once
+      Vagrant::Commands.init
+    end
+
+    should "copy the templated rootfile to the current path" do
+      File.expects(:exist?).with(@rootfile_path).returns(false)
+      File.expects(:copy).with(@template_path, @rootfile_path).once
+      Vagrant::Commands.init
+    end
+  end
+
+  context "up" do
+    setup do
+      Vagrant::Env.stubs(:persisted_vm).returns(nil)
+      Vagrant::VM.stubs(:execute!)
+      Vagrant::Env.stubs(:require_box)
+    end
+
+    should "require load the environment" do
+      Vagrant::Env.expects(:load!).once
+      Vagrant::Commands.up
+    end
+
+    should "require a box" do
+      Vagrant::Env.expects(:require_box).once
+      Vagrant::Commands.up
+    end
+
+    should "call the up action on VM if it doesn't exist" do
+      Vagrant::VM.expects(:execute!).with(Vagrant::Actions::VM::Up).once
+      Vagrant::Commands.up
+    end
+
+    should "call start on the persisted vm if it exists" do
+      Vagrant::Env.stubs(:persisted_vm).returns(@persisted_vm)
+      @persisted_vm.expects(:start).once
+      Vagrant::VM.expects(:execute!).never
+      Vagrant::Commands.up
+    end
+  end
+
+  context "down" do
+    setup do
+      @persisted_vm.stubs(:destroy)
+    end
+
+    should "require a persisted VM" do
+      Vagrant::Env.expects(:require_persisted_vm).once
+      Vagrant::Commands.down
+    end
+
+    should "destroy the persisted VM and the VM image" do
+      @persisted_vm.expects(:destroy).once
+      Vagrant::Commands.down
+    end
+  end
+
+  context "reload" do
+    should "require a persisted VM" do
+      Vagrant::Env.expects(:require_persisted_vm).once
+      Vagrant::Commands.reload
+    end
+
+    should "call the `reload` action on the VM" do
+      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Reload).once
+      Vagrant::Commands.reload
+    end
+  end
+
+  context "ssh" do
+    setup do
+      Vagrant::SSH.stubs(:connect)
+    end
+
+    should "require a persisted VM" do
+      Vagrant::Env.expects(:require_persisted_vm).once
+      Vagrant::Commands.ssh
+    end
+
+    should "connect to SSH" do
+      Vagrant::SSH.expects(:connect).once
+      Vagrant::Commands.ssh
+    end
+  end
+
+  context "halt" do
+    should "require a persisted VM" do
+      Vagrant::Env.expects(:require_persisted_vm).once
+      Vagrant::Commands.halt
+    end
+
+    should "call the `halt` action on the VM" do
+      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Halt).once
+      Vagrant::Commands.halt
+    end
+  end
+
+  context "suspend" do
+    setup do
+      @persisted_vm.stubs(:suspend)
+      @persisted_vm.stubs(:saved?).returns(false)
+    end
+
+    should "require a persisted VM" do
+      Vagrant::Env.expects(:require_persisted_vm).once
+      Vagrant::Commands.suspend
+    end
+
+    should "suspend the VM" do
+      @persisted_vm.expects(:suspend).once
+      Vagrant::Commands.suspend
+    end
+  end
+
+  context "resume" do
+    setup do
+      @persisted_vm.stubs(:resume)
+      @persisted_vm.stubs(:saved?).returns(true)
+    end
+
+    should "require a persisted VM" do
+      Vagrant::Env.expects(:require_persisted_vm).once
+      Vagrant::Commands.resume
+    end
+
+    should "save the state of the VM" do
+      @persisted_vm.expects(:resume).once
+      Vagrant::Commands.resume
+    end
+  end
+
+  context "package" do
+    setup do
+      @persisted_vm.stubs(:package)
+      @persisted_vm.stubs(:powered_off?).returns(true)
+    end
+
+    should "require a persisted vm" do
+      Vagrant::Env.expects(:require_persisted_vm).once
+      Vagrant::Commands.package
+    end
+
+    should "error and exit if the VM is not powered off" do
+      @persisted_vm.stubs(:powered_off?).returns(false)
+      Vagrant::Commands.expects(:error_and_exit).once
+      @persisted_vm.expects(:package).never
+      Vagrant::Commands.package
+    end
+
+    should "call package on the persisted VM" do
+      @persisted_vm.expects(:package).once
+      Vagrant::Commands.package
+    end
+
+    should "pass the out path and include_files to the package method" do
+      out_path = mock("out_path")
+      include_files = mock("include_files")
+      @persisted_vm.expects(:package).with(out_path, include_files).once
+      Vagrant::Commands.package(out_path, include_files)
+    end
+
+    should "default to an empty array when not include_files are specified" do
+      out_path = mock("out_path")
+      @persisted_vm.expects(:package).with(out_path, []).once
+      Vagrant::Commands.package(out_path)
+    end
+  end
+
+  context "box" do
+    setup do
+      Vagrant::Commands.stubs(:box_foo)
+      Vagrant::Commands.stubs(:box_add)
+      Vagrant::Commands.stubs(:box_remove)
+    end
+
+    should "load the environment" do
+      Vagrant::Env.expects(:load!).with(:suppress_errors => true).once
+      Vagrant::Commands.box(["add"])
+    end
+
+    should "error and exit if the first argument is not 'add' or 'remove'" do
+      Vagrant::Commands.expects(:error_and_exit).once
+      Vagrant::Commands.box(["foo"])
+    end
+
+    should "not error and exit if the first argument is 'add' or 'remove'" do
+      commands = ["add", "remove"]
+
+      commands.each do |command|
+        Vagrant::Commands.expects(:error_and_exit).never
+        Vagrant::Commands.expects("box_#{command}".to_sym).once
+        Vagrant::Commands.box([command])
+      end
+    end
+
+    should "forward any additional arguments" do
+      Vagrant::Commands.expects(:box_add).with(1,2,3).once
+      Vagrant::Commands.box(["add",1,2,3])
+    end
+  end
+
+  context "box add" do
+    setup do
+      @name = "foo"
+      @path = "bar"
+    end
+
+    should "execute the add action with the name and path" do
+      Vagrant::Box.expects(:add).with(@name, @path).once
+      Vagrant::Commands.box_add(@name, @path)
+    end
+  end
+
+  context "box remove" do
+    setup do
+      @name = "foo"
+    end
+
+    should "error and exit if the box doesn't exist" do
+      Vagrant::Box.expects(:find).returns(nil)
+      Vagrant::Commands.expects(:error_and_exit).once
+      Vagrant::Commands.box_remove(@name)
+    end
+
+    should "call destroy on the box if it exists" do
+      @box = mock("box")
+      Vagrant::Box.expects(:find).with(@name).returns(@box)
+      @box.expects(:destroy).once
+      Vagrant::Commands.box_remove(@name)
+    end
+  end
+end

data/test/vagrant/config_test.rb

@@ -0,0 +1,123 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ConfigTest < Test::Unit::TestCase
+  context "resetting" do
+    setup do
+      Vagrant::Config.run { |config| }
+      Vagrant::Config.execute!
+    end
+
+    should "return the same config object typically" do
+      config = Vagrant::Config.config
+      assert config.equal?(Vagrant::Config.config)
+    end
+
+    should "create a new object if cleared" do
+      config = Vagrant::Config.config
+      Vagrant::Config.reset!
+      assert !config.equal?(Vagrant::Config.config)
+    end
+
+    should "empty the runners" do
+      assert !Vagrant::Config.config_runners.empty?
+      Vagrant::Config.reset!
+      assert Vagrant::Config.config_runners.empty?
+    end
+  end
+
+  context "accessing configuration" do
+    setup do
+      Vagrant::Config.run { |config| }
+      Vagrant::Config.execute!
+    end
+
+    should "forward config to the class method" do
+      assert_equal Vagrant.config, Vagrant::Config.config
+    end
+  end
+
+  context "initializing" do
+    teardown do
+      Vagrant::Config.instance_variable_set(:@config_runners, nil)
+      Vagrant::Config.instance_variable_set(:@config, nil)
+    end
+
+    should "not run the blocks right away" do
+      obj = mock("obj")
+      obj.expects(:foo).never
+      Vagrant::Config.run { |config| obj.foo }
+      Vagrant::Config.run { |config| obj.foo }
+      Vagrant::Config.run { |config| obj.foo }
+    end
+
+    should "run the blocks when execute! is ran" do
+      obj = mock("obj")
+      obj.expects(:foo).times(2)
+      Vagrant::Config.run { |config| obj.foo }
+      Vagrant::Config.run { |config| obj.foo }
+      Vagrant::Config.execute!
+    end
+
+    should "run the blocks with the same config object" do
+      Vagrant::Config.run { |config| assert config }
+      Vagrant::Config.run { |config| assert config }
+      Vagrant::Config.execute!
+    end
+
+    should "not be loaded, initially" do
+      assert !Vagrant::Config.config.loaded?
+    end
+
+    should "be loaded after running" do
+      Vagrant::Config.run {}
+      Vagrant::Config.execute!
+      assert Vagrant::Config.config.loaded?
+    end
+  end
+
+  context "base class" do
+    setup do
+      @base = Vagrant::Config::Base.new
+    end
+
+    should "forward [] access to methods" do
+      @base.expects(:foo).once
+      @base[:foo]
+    end
+
+    should "return a hash of instance variables" do
+      data = { :foo => "bar", :bar => "baz" }
+
+      data.each do |iv, value|
+        @base.instance_variable_set("@#{iv}".to_sym, value)
+      end
+
+      result = @base.instance_variables_hash
+      assert_equal data.length, result.length
+
+      data.each do |iv, value|
+        assert_equal value, result[iv]
+      end
+    end
+
+    should "convert instance variable hash to json" do
+      @json = mock("json")
+      @iv_hash = mock("iv_hash")
+      @iv_hash.expects(:to_json).once.returns(@json)
+      @base.expects(:instance_variables_hash).returns(@iv_hash)
+      assert_equal @json, @base.to_json
+    end
+  end
+
+  context "chef config" do
+    setup do
+      @config = Vagrant::Config::ChefConfig.new
+      @config.json = "HEY"
+    end
+
+    should "not include the 'json' key in the config dump" do
+      result = JSON.parse(@config.to_json)
+      assert !result.has_key?("json")
+    end
+  end
+end