vagrant-fixed-ssh 1.0.7

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

@@ -0,0 +1,16 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Environment do
+  let(:instance) { described_class.new }
+
+  it "should be a hash" do
+    instance.should be_empty
+    instance["foo"] = "bar"
+    instance["foo"].should == "bar"
+  end
+
+  it "should be a hash accessible by string or symbol" do
+    instance["foo"] = "bar"
+    instance[:foo].should == "bar"
+  end
+end

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

@@ -0,0 +1,65 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Runner do
+  let(:registry) do
+    d = double("registry")
+    d.stub(:get)
+    d
+  end
+
+  let(:instance) { described_class.new(registry) }
+
+  it "should raise an error if an invalid callable is given" do
+    expect { instance.run(7) }.to raise_error(ArgumentError, /must be a callable/)
+  end
+
+  it "should be able to use a Proc as a callable" do
+    callable = Proc.new { raise Exception, "BOOM" }
+    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
+  end
+
+  it "should be able to use a Class as a callable" do
+    callable = Class.new do
+      def initialize(app, env)
+      end
+
+      def call(env)
+        raise Exception, "BOOM"
+      end
+    end
+
+    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
+  end
+
+  it "should pass options into hash given to callable" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance.run(callable, "data" => "foo")
+    result.should == "foo"
+  end
+
+  it "should pass global options into the hash" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance = described_class.new(registry, "data" => "bar")
+    instance.run(callable)
+    result.should == "bar"
+  end
+
+  it "should yield the block passed to the init method to get lazy loaded globals" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance = described_class.new(registry) { { "data" => "bar" } }
+    instance.run(callable)
+    result.should == "bar"
+  end
+end

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

@@ -0,0 +1,92 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Warden do
+  let(:data) { { :data => [] } }
+  let(:instance) { described_class.new }
+
+  # 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)
+    Proc.new { |env| env[:data] << data }
+  end
+
+  it "calls the actions like normal" do
+    instance = described_class.new([appender_proc(1), appender_proc(2)], data)
+    instance.call(data)
+
+    data[:data].should == [1, 2]
+  end
+
+  it "starts a recovery sequence when an exception is raised" do
+    class Action
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def recover(env)
+        env[:recover] << 1
+      end
+    end
+
+    class ActionTwo
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def recover(env)
+        env[:recover] << 2
+      end
+    end
+
+    error_proc = Proc.new { raise "ERROR!" }
+
+    data     = { :recover => [] }
+    instance = described_class.new([Action, ActionTwo, error_proc], data)
+
+    # The error should be raised back up
+    expect { instance.call(data) }.
+      to raise_error(RuntimeError)
+
+    # Verify the recovery process goes in reverse order
+    data[:recover].should == [2, 1]
+
+    # Verify that the error is available in the data
+    data["vagrant.error"].should be_kind_of(RuntimeError)
+  end
+
+  it "does not do a recovery sequence if SystemExit is raised" do
+    class Action
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def recover(env)
+        env[:recover] = true
+      end
+    end
+
+    # Make a proc that just calls "abort" which raises a
+    # SystemExit exception.
+    error_proc = Proc.new { abort }
+
+    instance = described_class.new([Action, error_proc], data)
+
+    # The SystemExit should come through
+    expect { instance.call(data) }.to raise_error(SystemExit)
+
+    # The recover should not have been called
+    data.has_key?(:recover).should_not be
+  end
+end

data/test/unit/vagrant/box_collection_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::BoxCollection do
+  include_context "unit"
+
+  let(:environment) { isolated_environment }
+  let(:action_runner) { double("action runner") }
+  let(:instance)    { described_class.new(environment.boxes_dir, action_runner) }
+
+  it "should list all available boxes" do
+    # No boxes yet.
+    instance.length.should == 0
+
+    # Add some boxes to the environment and try again
+    environment.box("foo")
+    environment.box("bar")
+    instance.reload!
+    instance.length.should == 2
+  end
+
+  describe "finding" do
+    it "should return nil if it can't find the box" do
+      instance.find("foo").should be_nil
+    end
+
+    it "should return a box instance for any boxes it does find" do
+      environment.box("foo")
+      result = instance.find("foo")
+      result.should be_kind_of(Vagrant::Box)
+      result.name.should == "foo"
+    end
+  end
+
+  it "should throw an error if the box already exists when adding" do
+    environment.box("foo")
+    expect { instance.add("foo", "bar") }.to raise_error(Vagrant::Errors::BoxAlreadyExists)
+  end
+
+  it "should add the box" do
+    name = "foo"
+    url  = "bar"
+
+    # Test the invocation of the action runner with the proper name
+    # and parameters. We leave the testing of the actual stack to
+    # acceptance tests, and individual pieces to unit tests of each
+    # step.
+    options = {
+      :box_name => name,
+      :box_url => url,
+      :box_directory => instance.directory.join(name)
+    }
+    action_runner.should_receive(:run).with(:box_add, options)
+
+    instance.add(name, url)
+  end
+end

data/test/unit/vagrant/box_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::Box do
+  let(:name)          { "foo" }
+  let(:directory)     { "bar" }
+  let(:action_runner) { double("action_runner") }
+  let(:instance)      { described_class.new(name, directory, action_runner) }
+
+  it "provides the name" do
+    instance.name.should == name
+  end
+
+  it "can destroy itself" do
+    # Simply test the messages to the action runner
+    options = {
+      :box_name => name,
+      :box_directory => directory
+    }
+    action_runner.should_receive(:run).with(:box_remove, options)
+
+    instance.destroy
+  end
+
+  it "can repackage itself" do
+    # Simply test the messages to the action runner
+    options = {
+      :box_name => name,
+      :box_directory => directory
+    }
+    action_runner.should_receive(:run).with(:box_repackage, options)
+
+    instance.repackage
+  end
+end

data/test/unit/vagrant/command/base_test.rb

@@ -0,0 +1,150 @@
+require File.expand_path("../../../base", __FILE__)
+require 'optparse'
+
+describe Vagrant::Command::Base do
+  describe "parsing options" do
+    let(:klass) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :parse_options
+      end
+    end
+
+    it "returns the remaining arguments" do
+      options = {}
+      opts = OptionParser.new do |opts|
+        opts.on("-f") do |f|
+          options[:f] = f
+        end
+      end
+
+      result = klass.new(["-f", "foo"], nil).parse_options(opts)
+
+      # Check the results
+      options[:f].should be
+      result.should == ["foo"]
+    end
+
+    it "creates an option parser if none is given" do
+      result = klass.new(["foo"], nil).parse_options(nil)
+      result.should == ["foo"]
+    end
+
+    ["-h", "--help"].each do |help_string|
+      it "returns nil and prints the help if '#{help_string}' is given" do
+        instance = klass.new([help_string], nil)
+        instance.should_receive(:safe_puts)
+        instance.parse_options(OptionParser.new).should be_nil
+      end
+    end
+
+    it "raises an error if invalid options are given" do
+      instance = klass.new(["-f"], nil)
+      expect { instance.parse_options(OptionParser.new) }.
+        to raise_error(Vagrant::Errors::CLIInvalidOptions)
+    end
+  end
+
+  describe "target VMs" do
+    let(:klass) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :with_target_vms
+      end
+    end
+
+    let(:environment) do
+      env = double("environment")
+      env.stub(:root_path => "foo")
+      env
+    end
+
+    let(:instance)    { klass.new([], environment) }
+
+    it "should raise an exception if a root_path is not available" do
+      environment.stub(:root_path => nil)
+
+      expect { instance.with_target_vms }.
+        to raise_error(Vagrant::Errors::NoEnvironmentError)
+    end
+
+    it "should raise an exception if a name is given in a non-multivm environment" do
+      environment.stub(:multivm?).and_return(false)
+
+      expect { instance.with_target_vms("foo") }.
+        to raise_error(Vagrant::Errors::MultiVMEnvironmentRequired)
+    end
+
+    it "should yield every VM in order is no name is given" do
+      foo_vm = double("foo")
+      foo_vm.stub(:name).and_return("foo")
+
+      bar_vm = double("bar")
+      bar_vm.stub(:name).and_return("bar")
+
+      environment.stub(:multivm? => true,
+                       :vms => { "foo" => foo_vm, "bar" => bar_vm },
+                       :vms_ordered => [foo_vm, bar_vm])
+
+      vms = []
+      instance.with_target_vms do |vm|
+        vms << vm
+      end
+
+      vms.should == [foo_vm, bar_vm]
+    end
+
+    it "raises an exception if the named VM doesn't exist" do
+      environment.stub(:multivm? => true, :vms => {})
+
+      expect { instance.with_target_vms("foo") }.
+        to raise_error(Vagrant::Errors::VMNotFoundError)
+    end
+
+    it "yields the given VM if a name is given" do
+      foo_vm = double("foo")
+      foo_vm.stub(:name).and_return(:foo)
+
+      environment.stub(:multivm? => true,
+                       :vms => { :foo => foo_vm, :bar => nil })
+
+      vms = []
+      instance.with_target_vms("foo") { |vm| vms << vm }
+      vms.should == [foo_vm]
+    end
+  end
+
+  describe "splitting the main and subcommand args" do
+    let(:instance) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :split_main_and_subcommand
+      end.new(nil, nil)
+    end
+
+    it "should work when given all 3 parts" do
+      result = instance.split_main_and_subcommand(["-v", "status", "-h", "-v"])
+      result.should == [["-v"], "status", ["-h", "-v"]]
+    end
+
+    it "should work when given only a subcommand and args" do
+      result = instance.split_main_and_subcommand(["status", "-h"])
+      result.should == [[], "status", ["-h"]]
+    end
+
+    it "should work when given only main flags" do
+      result = instance.split_main_and_subcommand(["-v", "-h"])
+      result.should == [["-v", "-h"], nil, []]
+    end
+
+    it "should work when given only a subcommand" do
+      result = instance.split_main_and_subcommand(["status"])
+      result.should == [[], "status", []]
+    end
+
+    it "works when there are other non-flag args after the subcommand" do
+      result = instance.split_main_and_subcommand(["-v", "box", "add", "-h"])
+      result.should == [["-v"], "box", ["add", "-h"]]
+    end
+  end
+end

data/test/unit/vagrant/config/base_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Config::Base do
+  include_context "unit"
+
+  let(:foo_class) do
+    Class.new(described_class) do
+      attr_accessor :one
+      attr_accessor :two
+    end
+  end
+
+  it "should merge by default by simply copying each instance variable" do
+    one = foo_class.new
+    one.one = 2
+    one.two = 1
+
+    two = foo_class.new
+    two.two = 5
+
+    result = one.merge(two)
+    result.one.should == 2
+    result.two.should == 5
+  end
+
+  it "doesn't merge values that start with a double underscore" do
+    bar_class = Class.new(foo_class) do
+      class_variable_set(:@@counter, 0)
+
+      def initialize
+        @__test = self.class.send(:class_variable_get, :@@counter)
+        self.class.send(:class_variable_set, :@@counter, @__test + 1)
+      end
+    end
+
+    one = bar_class.new
+    one.one = 2
+    one.two = 1
+
+    two = bar_class.new
+    two.two = 5
+
+    # Verify the counters
+    one.instance_variable_get(:@__test).should == 0
+    two.instance_variable_get(:@__test).should == 1
+    one.merge(two).instance_variable_get(:@__test).should == 2
+  end
+end