tnargav 1.2.2

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

@@ -0,0 +1,242 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Builder do
+  let(:data) { { :data => [] } }
+
+  # This returns a proc that can be used with the builder
+  # that simply appends data to an array in the env.
+  def appender_proc(data)
+    result = Proc.new { |env| env[:data] << data }
+
+    # Define a to_s on it for helpful output
+    result.define_singleton_method(:to_s) do
+      "<Appender: #{data}>"
+    end
+
+    result
+  end
+
+  context "copying" do
+    it "should copy the stack" do
+      copy = subject.dup
+      copy.stack.object_id.should_not == subject.stack.object_id
+    end
+  end
+
+  context "build" do
+    it "should provide build as a shortcut for basic sequences" do
+      data = {}
+      proc = Proc.new { |env| env[:data] = true }
+
+      subject = described_class.build(proc)
+      subject.call(data)
+
+      data[:data].should == true
+    end
+  end
+
+  context "basic `use`" do
+    it "should add items to the stack and make them callable" do
+      data = {}
+      proc = Proc.new { |env| env[:data] = true }
+
+      subject.use proc
+      subject.call(data)
+
+      data[:data].should == true
+    end
+
+    it "should be able to add multiple items" do
+      data = {}
+      proc1 = Proc.new { |env| env[:one] = true }
+      proc2 = Proc.new { |env| env[:two] = true }
+
+      subject.use proc1
+      subject.use proc2
+      subject.call(data)
+
+      data[:one].should == true
+      data[:two].should == true
+    end
+
+    it "should be able to add another builder" do
+      data  = {}
+      proc1 = Proc.new { |env| env[:one] = true }
+
+      # Build the first builder
+      one   = described_class.new
+      one.use proc1
+
+      # Add it to this builder
+      two   = described_class.new
+      two.use one
+
+      # Call the 2nd and verify results
+      two.call(data)
+      data[:one].should == true
+    end
+  end
+
+  context "inserting" do
+    it "can insert at an index" do
+      subject.use appender_proc(1)
+      subject.insert(0, appender_proc(2))
+      subject.call(data)
+
+      data[:data].should == [2, 1]
+    end
+
+    it "can insert by name" do
+      # Create the proc then make sure it has a name
+      bar_proc = appender_proc(2)
+      def bar_proc.name; :bar; end
+
+      subject.use appender_proc(1)
+      subject.use bar_proc
+      subject.insert_before :bar, appender_proc(3)
+      subject.call(data)
+
+      data[:data].should == [1, 3, 2]
+    end
+
+    it "can insert next to a previous object" do
+      proc2 = appender_proc(2)
+      subject.use appender_proc(1)
+      subject.use proc2
+      subject.insert(proc2, appender_proc(3))
+      subject.call(data)
+
+      data[:data].should == [1, 3, 2]
+    end
+
+    it "can insert before" do
+      subject.use appender_proc(1)
+      subject.insert_before 0, appender_proc(2)
+      subject.call(data)
+
+      data[:data].should == [2, 1]
+    end
+
+    it "can insert after" do
+      subject.use appender_proc(1)
+      subject.use appender_proc(3)
+      subject.insert_after 0, appender_proc(2)
+      subject.call(data)
+
+      data[:data].should == [1, 2, 3]
+    end
+
+    it "merges middleware stacks of other builders" do
+      wrapper_class = Proc.new do |letter|
+        Class.new do
+          def initialize(app, env)
+            @app = app
+          end
+
+          define_method(:call) do |env|
+            env[:data] << "#{letter}1"
+            @app.call(env)
+            env[:data] << "#{letter}2"
+          end
+        end
+      end
+
+      proc2 = appender_proc(2)
+      subject.use appender_proc(1)
+      subject.use proc2
+
+      builder = described_class.new
+      builder.use wrapper_class.call("A")
+      builder.use wrapper_class.call("B")
+
+      subject.insert(proc2, builder)
+      subject.call(data)
+
+      data[:data].should == [1, "A1", "B1", 2, "B2", "A2"]
+    end
+
+    it "raises an exception if an invalid object given for insert" do
+      expect { subject.insert "object", appender_proc(1) }.
+        to raise_error(RuntimeError)
+    end
+
+    it "raises an exception if an invalid object given for insert_after" do
+      expect { subject.insert_after "object", appender_proc(1) }.
+        to raise_error(RuntimeError)
+    end
+  end
+
+  context "replace" do
+    it "can replace an object" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
+
+      subject.use proc1
+      subject.replace proc1, proc2
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+
+    it "can replace by index" do
+      proc1 = appender_proc(1)
+      proc2 = appender_proc(2)
+
+      subject.use proc1
+      subject.replace 0, proc2
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+  end
+
+  context "deleting" do
+    it "can delete by object" do
+      proc1 = appender_proc(1)
+
+      subject.use proc1
+      subject.use appender_proc(2)
+      subject.delete proc1
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+
+    it "can delete by index" do
+      proc1 = appender_proc(1)
+
+      subject.use proc1
+      subject.use appender_proc(2)
+      subject.delete 0
+      subject.call(data)
+
+      data[:data].should == [2]
+    end
+  end
+
+  describe "action hooks" do
+    it "applies them properly" do
+      hook = double("hook")
+      hook.stub(:apply) do |builder|
+        builder.use appender_proc(2)
+      end
+
+      data[:action_hooks] = [hook]
+
+      subject.use appender_proc(1)
+      subject.call(data)
+
+      data[:data].should == [1, 2]
+      data[:action_hooks_already_ran].should == true
+    end
+
+    it "applies without prepend/append if it has already" do
+      hook = double("hook")
+      hook.should_receive(:apply).with(anything, { :no_prepend_or_append => true }).once
+
+      data[:action_hooks] = [hook]
+      data[:action_hooks_already_ran] = true
+      subject.call(data)
+    end
+  end
+end

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(:capability)
+
+    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(:capability)
+
+    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(:capability).with(: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