vagrantup 1.0.7 → 1.1.0

data/test/unit/vagrant/action/builtin/call_test.rb

@@ -0,0 +1,145 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Action::Builtin::Call do
+  let(:app) { lambda { |env| } }
+  let(:env) { {} }
+
+  it "should yield the env to the block" do
+    received = nil
+
+    callable = lambda do |env|
+      env[:result] = "value"
+    end
+
+    described_class.new(app, env, callable) do |env, builder|
+      received = env[:result]
+    end.call({})
+
+    received.should == "value"
+  end
+
+  it "should update the original env with any changes" do
+    callable = lambda { |env| }
+    next_step = lambda { |env| env[:inner] = true }
+
+    described_class.new(app, env, callable) do |_env, builder|
+      builder.use next_step
+    end.call(env)
+
+    env[:inner].should == true
+  end
+
+  it "should call the callable with the original environment" do
+    received = nil
+    callable = lambda { |env| received = env[:foo] }
+
+    described_class.new(app, env, callable) do |_env, _builder|
+      # Nothing.
+    end.call({ :foo => :bar })
+
+    received.should == :bar
+   end
+
+  it "should call the next builder" do
+    received = nil
+    callable = lambda { |env| }
+    next_step = lambda { |env| received = "value" }
+
+    described_class.new(app, env, callable) do |_env, builder|
+      builder.use next_step
+    end.call({})
+
+    received.should == "value"
+  end
+
+  it "should call the next builder with the original environment" do
+    received = nil
+    callable = lambda { |env| }
+    next_step = lambda { |env| received = env[:foo] }
+
+    described_class.new(app, env, callable) do |_env, builder|
+      builder.use next_step
+    end.call({ :foo => :bar })
+
+    received.should == :bar
+  end
+
+  it "should instantiate the callable with the extra args" do
+    env = {}
+
+    callable = Class.new do
+      def initialize(app, env, arg)
+        env[:arg] = arg
+      end
+
+      def call(env); end
+    end
+
+    result = nil
+    instance = described_class.new(app, env, callable, :foo) do |inner_env, _builder|
+      result = inner_env[:arg]
+    end
+    instance.call(env)
+
+    result.should == :foo
+  end
+
+  it "should call the recover method for the sequence in an error" do
+    # Basic variables
+    callable = lambda { |env| }
+
+    # Build the steps for the test
+    basic_step = Class.new do
+      def initialize(app, env)
+        @app = app
+        @env = env
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+
+    step_a = Class.new(basic_step) do
+      def call(env)
+        env[:steps] << :call_A
+        super
+      end
+
+      def recover(env)
+        env[:steps] << :recover_A
+      end
+    end
+
+    step_b = Class.new(basic_step) do
+      def call(env)
+        env[:steps] << :call_B
+        super
+      end
+
+      def recover(env)
+        env[:steps] << :recover_B
+      end
+    end
+
+    instance = described_class.new(app, env, callable) do |_env, builder|
+      builder.use step_a
+      builder.use step_b
+    end
+
+    env[:steps] = []
+    instance.call(env)
+    instance.recover(env)
+
+    env[:steps].should == [:call_A, :call_B, :recover_B, :recover_A]
+  end
+
+  it "should recover even if it failed in the callable" do
+    callable = lambda { |env| raise "error" }
+
+    instance = described_class.new(app, env, callable) { |_env, _builder| }
+    instance.call(env) rescue nil
+    expect { instance.recover(env) }.
+      to_not raise_error
+  end
+end

data/test/unit/vagrant/action/builtin/confirm_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Action::Builtin::Confirm do
+  let(:app) { lambda { |env| } }
+  let(:env) { { :ui => double("ui") } }
+  let(:message) { "foo" }
+
+  ["y", "Y"].each do |valid|
+    it "should set the result to true if '#{valid}' is given" do
+      env[:ui].should_receive(:ask).with(message).and_return(valid)
+      described_class.new(app, env, message).call(env)
+      env[:result].should be
+    end
+  end
+
+  it "should set the result to true if force matches" do
+    force_key = :tubes
+    env[force_key] = true
+    described_class.new(app, env, message, force_key).call(env)
+    env[:result].should be
+  end
+
+  it "should ask if force is not true" do
+    force_key = :tubes
+    env[force_key] = false
+    env[:ui].should_receive(:ask).with(message).and_return("nope")
+    described_class.new(app, env, message).call(env)
+    env[:result].should_not be
+  end
+
+  it "should set result to false if anything else is given" do
+    env[:ui].should_receive(:ask).with(message).and_return("nope")
+    described_class.new(app, env, message).call(env)
+    env[:result].should_not be
+  end
+end

data/test/unit/vagrant/action/builtin/env_set_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Action::Builtin::EnvSet do
+  let(:app) { lambda { |env| } }
+  let(:env) { {} }
+
+  it "should set the new environment" do
+    described_class.new(app, env, :foo => :bar).call(env)
+
+    env[:foo].should == :bar
+  end
+
+  it "should call the next middleware" do
+    callable = lambda { |env| env[:called] = env[:foo] }
+
+    env[:called].should be_nil
+    described_class.new(callable, env, :foo => :yep).call(env)
+    env[:called].should == :yep
+  end
+end

data/test/unit/vagrant/action/builtin/graceful_halt_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Action::Builtin::GracefulHalt do
+  let(:app) { lambda { |env| } }
+  let(:env) { { :machine => machine, :ui => ui } }
+  let(:machine) do
+    result = double("machine")
+    result.stub(:config).and_return(machine_config)
+    result.stub(:guest).and_return(machine_guest)
+    result.stub(:state).and_return(machine_state)
+    result
+  end
+  let(:machine_config) do
+    double("machine_config").tap do |top_config|
+      vm_config = double("machien_vm_config")
+      vm_config.stub(:graceful_halt_retry_count => 2)
+      vm_config.stub(:graceful_halt_retry_interval => 0)
+      top_config.stub(:vm => vm_config)
+    end
+  end
+  let(:machine_guest) { double("machine_guest") }
+  let(:machine_state) do
+    double("machine_state").tap do |result|
+      result.stub(:id).and_return(:unknown)
+    end
+  end
+  let(:target_state) { :target }
+  let(:ui) do
+    double("ui").tap do |result|
+      result.stub(:info)
+    end
+  end
+
+  it "should do nothing if force is specified" do
+    env[:force_halt] = true
+
+    machine_guest.should_not_receive(:halt)
+
+    described_class.new(app, env, target_state).call(env)
+
+    env[:result].should == false
+  end
+
+  it "should do nothing if there is an invalid source state" do
+    machine_state.stub(:id).and_return(:invalid_source)
+    machine_guest.should_not_receive(:halt)
+
+    described_class.new(app, env, target_state, :target_source).call(env)
+
+    env[:result].should == false
+  end
+
+  it "should gracefully halt and wait for the target state" do
+    machine_guest.should_receive(:halt).once
+    machine_state.stub(:id).and_return(target_state)
+
+    described_class.new(app, env, target_state).call(env)
+
+    env[:result].should == true
+  end
+end

data/test/unit/vagrant/action/builtin/lock_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Action::Builtin::Lock do
+  let(:app) { lambda { |env| } }
+  let(:env) { {} }
+  let(:lock_path) do
+    @__lock_path = Tempfile.new("vagrant-test-lock")
+    @__lock_path.path.to_s
+  end
+
+  let(:options) do
+    {
+      :exception => Class.new(StandardError),
+      :path      => lock_path
+    }
+  end
+
+  it "should require a path" do
+    expect { described_class.new(app, env) }.
+      to raise_error(ArgumentError)
+
+    expect { described_class.new(app, env, :path => "foo") }.
+      to raise_error(ArgumentError)
+
+    expect { described_class.new(app, env, :exception => "foo") }.
+      to raise_error(ArgumentError)
+
+    expect { described_class.new(app, env, :path => "bar", :exception => "foo") }.
+      to_not raise_error
+  end
+
+  it "should allow the path to be a proc" do
+    inner_acquire = true
+    app = lambda do |env|
+      File.open(lock_path, "w+") do |f|
+        inner_acquire = f.flock(File::LOCK_EX | File::LOCK_NB)
+      end
+    end
+
+    options[:path] = lambda { |env| lock_path }
+
+    instance = described_class.new(app, env, options)
+    instance.call(env)
+
+    inner_acquire.should == false
+  end
+
+  it "should allow the exception to be a proc" do
+    exception = options[:exception]
+    options[:exception] = lambda { |env| exception }
+
+    File.open(lock_path, "w+") do |f|
+      # Acquire lock
+      f.flock(File::LOCK_EX | File::LOCK_NB).should == 0
+
+      # Test!
+      instance = described_class.new(app, env, options)
+      expect { instance.call(env) }.
+        to raise_error(exception)
+    end
+  end
+
+  it "should call the middleware with the lock held" do
+    inner_acquire = true
+    app = lambda do |env|
+      File.open(lock_path, "w+") do |f|
+        inner_acquire = f.flock(File::LOCK_EX | File::LOCK_NB)
+      end
+    end
+
+    instance = described_class.new(app, env, options)
+    instance.call(env)
+
+    inner_acquire.should == false
+  end
+
+  it "should raise an exception if the lock is already held" do
+    File.open(lock_path, "w+") do |f|
+      # Acquire lock
+      f.flock(File::LOCK_EX | File::LOCK_NB).should == 0
+
+      # Test!
+      instance = described_class.new(app, env, options)
+      expect { instance.call(env) }.
+        to raise_error(options[:exception])
+    end
+  end
+
+  it "should allow nesting locks within the same middleware sequence" do
+    called = false
+    app = lambda { |env| called = true }
+    inner = described_class.new(app, env, options)
+    outer = described_class.new(inner, env, options)
+    outer.call(env)
+
+    called.should == true
+  end
+end

data/test/unit/vagrant/action/builtin/ssh_exec_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require "vagrant/util/ssh"
+
+describe Vagrant::Action::Builtin::SSHExec do
+  let(:app) { lambda { |env| } }
+  let(:env) { { :machine => machine } }
+  let(:machine) do
+    result = double("machine")
+    result.stub(:ssh_info).and_return(machine_ssh_info)
+    result
+  end
+  let(:machine_ssh_info) { {} }
+  let(:ssh_klass) { Vagrant::Util::SSH }
+
+  before(:each) do
+    # Stub the methods so that even if we test incorrectly, no side
+    # effects actually happen.
+    ssh_klass.stub(:check_key_permissions)
+    ssh_klass.stub(:exec)
+  end
+
+  it "should raise an exception if SSH is not ready" do
+    not_ready_machine = double("machine")
+    not_ready_machine.stub(:ssh_info).and_return(nil)
+
+    env[:machine] = not_ready_machine
+    expect { described_class.new(app, env).call(env) }.
+      to raise_error(Vagrant::Errors::SSHNotReady)
+  end
+
+  it "should check key permissions then exec" do
+    machine_ssh_info[:private_key_path] = "/foo"
+
+    ssh_klass.should_receive(:check_key_permissions).
+      with(Pathname.new(machine_ssh_info[:private_key_path])).
+      once.
+      ordered
+
+    ssh_klass.should_receive(:exec).
+      with(machine_ssh_info, nil).
+      once.
+      ordered
+
+    described_class.new(app, env).call(env)
+  end
+
+  it "should exec with the options given in `ssh_opts`" do
+    ssh_opts = { :foo => :bar }
+
+    ssh_klass.should_receive(:exec).
+      with(machine_ssh_info, ssh_opts)
+
+    env[:ssh_opts] = ssh_opts
+    described_class.new(app, env).call(env)
+  end
+end

data/test/unit/vagrant/action/hook_test.rb

@@ -0,0 +1,101 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/action/builder"
+require "vagrant/action/hook"
+
+describe Vagrant::Action::Hook do
+  describe "defaults" do
+    its("after_hooks")   { should be_empty }
+    its("before_hooks")  { should be_empty }
+    its("append_hooks")  { should be_empty }
+    its("prepend_hooks") { should be_empty }
+  end
+
+  describe "before hooks" do
+    let(:existing) { "foo" }
+
+    it "should append them" do
+      block = Proc.new {}
+
+      subject.before(existing, 1)
+      subject.before(existing, 2)
+      subject.before(existing, 3, :arg, &block)
+
+      subject.before_hooks[existing].should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "after hooks" do
+    let(:existing) { "foo" }
+
+    it "should append them" do
+      block = Proc.new {}
+
+      subject.after(existing, 1)
+      subject.after(existing, 2)
+      subject.after(existing, 3, :arg, &block)
+
+      subject.after_hooks[existing].should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "append" do
+    it "should make a list" do
+      block = Proc.new {}
+
+      subject.append(1)
+      subject.append(2)
+      subject.append(3, :arg, &block)
+
+      subject.append_hooks.should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "prepend" do
+    it "should make a list" do
+      block = Proc.new {}
+
+      subject.prepend(1)
+      subject.prepend(2)
+      subject.prepend(3, :arg, &block)
+
+      subject.prepend_hooks.should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "applying" do
+    let(:builder) { Vagrant::Action::Builder.new }
+
+    it "should build the proper stack" do
+      subject.prepend("1", 2)
+      subject.append("9")
+      subject.after("1", "2")
+      subject.before("9", "8")
+
+      subject.apply(builder)
+
+      builder.stack.should == [
+        ["1", [2], nil],
+        ["2", [], nil],
+        ["8", [], nil],
+        ["9", [], nil]
+      ]
+    end
+  end
+end