vagrant 1.0.7 → 1.5.0

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

@@ -1,16 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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