bmabey-vagrant 0.2.0

data/test/vagrant/busy_test.rb

@@ -0,0 +1,83 @@
+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(2)
+        end
+      end
+      # Give the thread time to start
+      sleep(1)
+
+      # 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,307 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class CommandsTest < Test::Unit::TestCase
+  setup do
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:vm).returns(@persisted_vm)
+    @env.stubs(:require_persisted_vm)
+    Vagrant::Environment.stubs(:load!).returns(@env)
+  end
+
+  context "instance methods" do
+    setup do
+      @commands = Vagrant::Commands.new(@env)
+    end
+
+    context "initialization" do
+      should "set up the environment variable" do
+        env = mock("env")
+        command = Vagrant::Commands.new(env)
+        assert_equal env, command.env
+      end
+    end
+
+    context "up" do
+      setup do
+        @new_vm = mock("vm")
+        @new_vm.stubs(:execute!)
+
+        @env.stubs(:vm).returns(nil)
+        @env.stubs(:require_box)
+        @env.stubs(:create_vm).returns(@new_vm)
+      end
+
+      should "require a box" do
+        @env.expects(:require_box).once
+        @commands.up
+      end
+
+      should "call the up action on VM if it doesn't exist" do
+        @new_vm.expects(:execute!).with(Vagrant::Actions::VM::Up).once
+        @commands.up
+      end
+
+      should "call start on the persisted vm if it exists" do
+        @env.stubs(:vm).returns(@persisted_vm)
+        @persisted_vm.expects(:start).once
+        @env.expects(:create_vm).never
+        @commands.up
+      end
+    end
+
+    context "down" do
+      setup do
+        @persisted_vm.stubs(:destroy)
+      end
+
+      should "require a persisted VM" do
+        @env.expects(:require_persisted_vm).once
+        @commands.down
+      end
+
+      should "destroy the persisted VM and the VM image" do
+        @persisted_vm.expects(:destroy).once
+        @commands.down
+      end
+    end
+
+    context "reload" do
+      should "require a persisted VM" do
+        @env.expects(:require_persisted_vm).once
+        @commands.reload
+      end
+
+      should "call the `reload` action on the VM" do
+        @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Reload).once
+        @commands.reload
+      end
+    end
+
+    context "ssh" do
+      setup do
+        @env.ssh.stubs(:connect)
+      end
+
+      should "require a persisted VM" do
+        @env.expects(:require_persisted_vm).once
+        @commands.ssh
+      end
+
+      should "connect to SSH" do
+        @env.ssh.expects(:connect).once
+        @commands.ssh
+      end
+    end
+
+    context "halt" do
+      should "require a persisted VM" do
+        @env.expects(:require_persisted_vm).once
+        @commands.halt
+      end
+
+      should "call the `halt` action on the VM" do
+        @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Halt).once
+        @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
+        @env.expects(:require_persisted_vm).once
+        @commands.suspend
+      end
+
+      should "suspend the VM" do
+        @persisted_vm.expects(:suspend).once
+        @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
+        @env.expects(:require_persisted_vm).once
+        @commands.resume
+      end
+
+      should "save the state of the VM" do
+        @persisted_vm.expects(:resume).once
+        @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
+        @env.expects(:require_persisted_vm).once
+        @commands.package
+      end
+
+      should "error and exit if the VM is not powered off" do
+        @persisted_vm.stubs(:powered_off?).returns(false)
+        @commands.expects(:error_and_exit).with(:vm_power_off_to_package).once
+        @persisted_vm.expects(:package).never
+        @commands.package
+      end
+
+      should "call package on the persisted VM" do
+        @persisted_vm.expects(:package).once
+        @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
+        @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
+        @commands.package(out_path)
+      end
+    end
+
+    context "box" do
+      setup do
+        @commands.stubs(:box_foo)
+        @commands.stubs(:box_add)
+        @commands.stubs(:box_remove)
+      end
+
+      should "error and exit if the first argument is not a valid subcommand" do
+        @commands.expects(:error_and_exit).with(:command_box_invalid).once
+        @commands.box(["foo"])
+      end
+
+      should "not error and exit if the first argument is a valid subcommand" do
+        commands = ["add", "remove", "list"]
+
+        commands.each do |command|
+          @commands.expects(:error_and_exit).never
+          @commands.expects("box_#{command}".to_sym).once
+          @commands.box([command])
+        end
+      end
+
+      should "forward any additional arguments" do
+        @commands.expects(:box_add).with(@env, 1,2,3).once
+        @commands.box(["add",1,2,3])
+      end
+    end
+
+    context "box list" do
+      setup do
+        @boxes = ["foo", "bar"]
+
+        Vagrant::Box.stubs(:all).returns(@boxes)
+        @commands.stubs(:wrap_output)
+      end
+
+      should "call all on box and sort the results" do
+        @all = mock("all")
+        @all.expects(:sort).returns(@boxes)
+        Vagrant::Box.expects(:all).with(@env).returns(@all)
+        @commands.box_list(@env)
+      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(@env, @name, @path).once
+        @commands.box_add(@env, @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)
+        @commands.expects(:error_and_exit).with(:box_remove_doesnt_exist).once
+        @commands.box_remove(@env, @name)
+      end
+
+      should "call destroy on the box if it exists" do
+        @box = mock("box")
+        Vagrant::Box.expects(:find).with(@env, @name).returns(@box)
+        @box.expects(:destroy).once
+        @commands.box_remove(@env, @name)
+      end
+    end
+  end
+
+  context "class methods" do
+    context "init" do
+      setup do
+        @file = mock("file")
+        @file.stubs(:write)
+        File.stubs(:open).yields(@file)
+        @rootfile_path = File.join(Dir.pwd, Vagrant::Environment::ROOTFILE_NAME)
+
+        Vagrant::Util::TemplateRenderer.stubs(:render)
+      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).with(:rootfile_already_exists).once
+        Vagrant::Commands.init
+      end
+
+      should "write to the rootfile path using the template renderer" do
+        result = "foo"
+        Vagrant::Util::TemplateRenderer.expects(:render).returns(result).once
+        @file.expects(:write).with(result).once
+        File.expects(:open).with(@rootfile_path, 'w+').yields(@file)
+
+        Vagrant::Commands.init
+      end
+
+      should "use the given base box if given" do
+        box = "zooo"
+        Vagrant::Util::TemplateRenderer.expects(:render).with(Vagrant::Environment::ROOTFILE_NAME, :default_box => box)
+        Vagrant::Commands.init(box)
+      end
+
+      should "use the default `base` if no box is given" do
+        Vagrant::Util::TemplateRenderer.expects(:render).with(Vagrant::Environment::ROOTFILE_NAME, :default_box => "base")
+        Vagrant::Commands.init
+      end
+    end
+
+    context "executing commands in the current environment" do
+      should "load the environment then send the command to the commands instance" do
+        method = :foo
+        args = [1,2,3]
+
+        Vagrant::Environment.expects(:load!).returns(@env)
+        @env.commands.expects(:send).with(method, *args).once
+        Vagrant::Commands.execute(method, *args)
+      end
+    end
+  end
+end

data/test/vagrant/config_test.rb

@@ -0,0 +1,256 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ConfigTest < Test::Unit::TestCase
+  context "the ssh config" do
+    setup do
+      @env = mock_environment
+      @env.stubs(:root_path).returns("foo")
+    end
+
+    should "expand any path when requesting the value" do
+      result = File.expand_path(@env.config.ssh[:private_key_path], @env.root_path)
+      assert_equal result, @env.config.ssh.private_key_path
+    end
+  end
+
+  context "adding configures" do
+    should "forward the method to the Top class" do
+      key = mock("key")
+      klass = mock("klass")
+      Vagrant::Config::Top.expects(:configures).with(key, klass)
+      Vagrant::Config.configures(key, klass)
+    end
+  end
+
+  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 proc stack" do
+      assert !Vagrant::Config.proc_stack.empty?
+      Vagrant::Config.reset!
+      assert Vagrant::Config.proc_stack.empty?
+    end
+
+    should "reload the config object based on the given environment" do
+      env = mock("env")
+      Vagrant::Config.expects(:config).with(env).once
+      Vagrant::Config.reset!(env)
+    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
+    setup do
+      Vagrant::Config.reset!
+    end
+
+    should "add the given block to the proc stack" do
+      proc = Proc.new {}
+      Vagrant::Config.run(&proc)
+      assert_equal [proc], Vagrant::Config.proc_stack
+    end
+
+    should "run the proc stack with the config when execute is called" do
+      Vagrant::Config.expects(:run_procs!).with(Vagrant::Config.config).once
+      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
+
+    should "return the configuration on execute!" do
+      Vagrant::Config.run {}
+      result = Vagrant::Config.execute!
+      assert result.equal?(Vagrant.config)
+    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 "top config class" do
+    setup do
+      @configures_list = []
+      Vagrant::Config::Top.stubs(:configures_list).returns(@configures_list)
+    end
+
+    context "adding configure keys" do
+      setup do
+        @key = "top_config_foo"
+        @klass = mock("klass")
+      end
+
+      should "add key and klass to configures list" do
+        @configures_list.expects(:<<).with([@key, @klass])
+        Vagrant::Config::Top.configures(@key, @klass)
+      end
+    end
+
+    context "configuration keys on instance" do
+      setup do
+        @configures_list.clear
+      end
+
+      should "initialize each configurer and set it to its key" do
+        env = mock('env')
+
+        5.times do |i|
+          key = "key#{i}"
+          klass = mock("klass#{i}")
+          instance = mock("instance#{i}")
+          instance.expects(:env=).with(env)
+          klass.expects(:new).returns(instance)
+          @configures_list << [key, klass]
+        end
+
+        Vagrant::Config::Top.new(env)
+      end
+
+      should "allow reading via methods" do
+        key = "my_foo_bar_key"
+        klass = mock("klass")
+        instance = mock("instance")
+        instance.stubs(:env=)
+        klass.expects(:new).returns(instance)
+        Vagrant::Config::Top.configures(key, klass)
+
+        config = Vagrant::Config::Top.new
+        assert_equal instance, config.send(key)
+      end
+    end
+
+    context "loaded status" do
+      setup do
+        @top= Vagrant::Config::Top.new
+      end
+
+      should "not be loaded by default" do
+        assert !@top.loaded?
+      end
+
+      should "be loaded after calling loaded!" do
+        @top.loaded!
+        assert @top.loaded?
+      end
+    end
+  end
+
+  context "vagrant configuration" do
+    setup do
+      @config = Vagrant::Config::VagrantConfig.new
+    end
+
+    should "return nil if home is nil" do
+      File.expects(:expand_path).never
+      assert @config.home.nil?
+    end
+
+    should "expand the path if home is not nil" do
+      @config.home = "foo"
+      File.expects(:expand_path).with("foo").once.returns("result")
+      assert_equal "result", @config.home
+    end
+  end
+
+  context "VM configuration" do
+    setup do
+      @env = mock_environment
+      @config = @env.config.vm
+      @env.config.ssh.username = @username
+    end
+
+    should "include the stacked proc runner module" do
+      assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
+    end
+
+    should "add the customize proc to the proc stack" do
+      proc = Proc.new {}
+      @config.customize(&proc)
+      assert_equal [proc], @config.proc_stack
+    end
+
+    context "uid/gid" do
+      should "return the shared folder UID if set" do
+        @config.shared_folder_uid = "foo"
+        assert_equal "foo", @config.shared_folder_uid
+      end
+
+      should "return the SSH username if UID not set" do
+        @config.shared_folder_uid = nil
+        assert_equal @username, @config.shared_folder_uid
+      end
+
+      should "return the shared folder GID if set" do
+        @config.shared_folder_gid = "foo"
+        assert_equal "foo", @config.shared_folder_gid
+      end
+
+      should "return the SSH username if GID not set" do
+        @config.shared_folder_gid = nil
+        assert_equal @username, @config.shared_folder_gid
+      end
+    end
+  end
+end