vagrant 1.0.7 → 1.5.0

data/test/unit/vagrant/environment_test.rb

@@ -1,220 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-require "pathname"
-
-require "vagrant/util/file_mode"
-
-require "support/tempdir"
-
-describe Vagrant::Environment do
-  include_context "unit"
-
-  let(:home_path) { Pathname.new(Tempdir.new.path) }
-  let(:instance)  { described_class.new(:home_path => home_path) }
-
-  describe "current working directory" do
-    it "is the cwd by default" do
-      described_class.new.cwd.should == Pathname.new(Dir.pwd)
-    end
-
-    it "is set to the cwd given" do
-      directory = File.dirname(__FILE__)
-      instance = described_class.new(:cwd => directory)
-      instance.cwd.should == Pathname.new(directory)
-    end
-
-    it "is set to the environmental variable VAGRANT_CWD" do
-      pending "A good temporary ENV thing"
-    end
-
-    it "raises an exception if the CWD doesn't exist" do
-      expect { described_class.new(:cwd => "doesntexist") }.
-        to raise_error(Vagrant::Errors::EnvironmentNonExistentCWD)
-    end
-  end
-
-  describe "home path" do
-    it "is set to the home path given" do
-      dir = Tempdir.new.path
-      instance = described_class.new(:home_path => dir)
-      instance.home_path.should == Pathname.new(dir)
-    end
-
-    it "is set to the environmental variable VAGRANT_HOME" do
-      pending "A good temporary ENV thing"
-    end
-
-    it "is set to the DEFAULT_HOME by default" do
-      expected = Pathname.new(File.expand_path(described_class::DEFAULT_HOME))
-      described_class.new.home_path.should == expected
-    end
-
-    it "throws an exception if inaccessible" do
-      expect {
-        described_class.new(:home_path => "/")
-      }.to raise_error(Vagrant::Errors::HomeDirectoryNotAccessible)
-    end
-  end
-
-  describe "copying the private SSH key" do
-    it "copies the SSH key into the home directory" do
-      env = isolated_environment
-      instance = described_class.new(:home_path => env.homedir)
-
-      pk = env.homedir.join("insecure_private_key")
-      pk.should be_exist
-      Vagrant::Util::FileMode.from_octal(pk.stat.mode).should == "600"
-    end
-  end
-
-  it "has a box collection pointed to the proper directory" do
-    collection = instance.boxes
-    collection.should be_kind_of(Vagrant::BoxCollection)
-    collection.directory.should == instance.boxes_path
-  end
-
-  describe "action runner" do
-    it "has an action runner" do
-      instance.action_runner.should be_kind_of(Vagrant::Action::Runner)
-    end
-
-    it "has a `ui` in the globals" do
-      result = nil
-      callable = lambda { |env| result = env[:ui] }
-
-      instance.action_runner.run(callable)
-      result.should eql(instance.ui)
-    end
-  end
-
-  describe "action registry" do
-    it "has an action registry" do
-      instance.action_registry.should be_kind_of(Vagrant::Registry)
-    end
-
-    it "should have the built-in actions in the registry" do
-      instance.action_registry.get(:provision).should_not be_nil
-    end
-  end
-
-  describe "primary VM" do
-    before do
-      # This is really nasty but we do this to remove the dependency on
-      # having VirtualBox installed to run tests.
-      Vagrant::Driver::VirtualBox.stub(:new) do |uuid|
-        double("vm-#{uuid}")
-      end
-    end
-
-    it "should be the only VM if not a multi-VM environment" do
-      instance.primary_vm.should == instance.vms.values.first
-    end
-
-    it "should be the VM marked as the primary" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant::Config.run do |config|
-  config.vm.define :foo
-  config.vm.define :bar, :primary => true
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      env.primary_vm.should == env.vms[:bar]
-    end
-  end
-
-  describe "loading configuration" do
-    it "should load global configuration" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant::Config.run do |config|
-  config.vagrant.dotfile_name = "foo"
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      env.config.global.vagrant.dotfile_name.should == "foo"
-    end
-
-    it "should load from a custom Vagrantfile" do
-      environment = isolated_environment do |env|
-        env.file("non_standard_name", <<-VF)
-Vagrant::Config.run do |config|
-  config.vagrant.dotfile_name = "custom"
-end
-VF
-      end
-
-      env = environment.create_vagrant_env(:vagrantfile_name => "non_standard_name")
-      env.config.global.vagrant.dotfile_name.should == "custom"
-    end
-
-    it "should load VM configuration" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant::Config.run do |config|
-  config.vagrant.dotfile_name = "foo"
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      env.config.for_vm(:default).vm.name.should == :default
-    end
-
-    it "should load VM configuration with multiple VMs" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant::Config.run do |config|
-  config.vm.define :foo do |vm|
-    vm.ssh.port = 100
-  end
-
-  config.vm.define :bar do |vm|
-    vm.ssh.port = 200
-  end
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      env.config.for_vm(:foo).ssh.port.should == 100
-      env.config.for_vm(:bar).ssh.port.should == 200
-    end
-
-    it "should load box configuration" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant::Config.run do |config|
-  config.vm.box = "base"
-end
-VF
-
-        env.box("base", <<-VF)
-Vagrant::Config.run do |config|
-  config.ssh.port = 100
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      env.config.for_vm(:default).ssh.port.should == 100
-    end
-  end
-
-  describe "ui" do
-    it "should be a silent UI by default" do
-      described_class.new.ui.should be_kind_of(Vagrant::UI::Silent)
-    end
-
-    it "should be a UI given in the constructor" do
-      # Create a custom UI for our test
-      class CustomUI < Vagrant::UI::Interface; end
-
-      instance = described_class.new(:ui_class => CustomUI)
-      instance.ui.should be_kind_of(CustomUI)
-    end
-  end
-end

data/test/unit/vagrant/hosts_test.rb

@@ -1,36 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-
-describe Vagrant::Hosts do
-  let(:registry) { Vagrant::Registry.new }
-
-  it "detects the host that matches true" do
-    foo_klass = Class.new(Vagrant::Hosts::Base) do
-      def self.match?; false; end
-    end
-
-    bar_klass = Class.new(Vagrant::Hosts::Base) do
-      def self.match?; true; end
-    end
-
-    registry.register(:foo, foo_klass)
-    registry.register(:bar, bar_klass)
-
-    described_class.detect(registry).should == bar_klass
-  end
-
-  it "detects the host that matches true with the highest precedence first" do
-    foo_klass = Class.new(Vagrant::Hosts::Base) do
-      def self.match?; true; end
-    end
-
-    bar_klass = Class.new(Vagrant::Hosts::Base) do
-      def self.match?; true; end
-      def self.precedence; 9; end
-    end
-
-    registry.register(:foo, foo_klass)
-    registry.register(:bar, bar_klass)
-
-    described_class.detect(registry).should == bar_klass
-  end
-end

data/test/unit/vagrant/registry_test.rb

@@ -1,74 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-
-describe Vagrant::Registry do
-  let(:instance) { described_class.new }
-
-  it "should return nil for nonexistent items" do
-    instance.get("foo").should be_nil
-  end
-
-  it "should register a simple key/value" do
-    instance.register("foo", "value")
-    instance.get("foo").should == "value"
-  end
-
-  it "should register an item without calling the block yet" do
-    expect do
-      instance.register("foo") do
-        raise Exception, "BOOM!"
-      end
-    end.to_not raise_error
-  end
-
-  it "should call and return the result of a block when asking for the item" do
-    object = Object.new
-    instance.register("foo") do
-      object
-    end
-
-    instance.get("foo").should eql(object)
-  end
-
-  it "should be able to get the item with []" do
-    object = Object.new
-    instance.register("foo") { object }
-
-    instance["foo"].should eql(object)
-  end
-
-  it "should cache the result of the item so they can be modified" do
-    # Make the proc generate a NEW array each time
-    instance.register("foo") { [] }
-
-    # Test that modifying the result modifies the actual cached
-    # value. This verifies we're caching.
-    instance.get("foo").should == []
-    instance.get("foo") << "value"
-    instance.get("foo").should == ["value"]
-  end
-
-  it "should be enumerable" do
-    instance.register("foo", "foovalue")
-    instance.register("bar", "barvalue")
-
-    keys   = []
-    values = []
-    instance.each do |key, value|
-      keys << key
-      values << value
-    end
-
-    keys.sort.should == ["bar", "foo"]
-    values.sort.should == ["barvalue", "foovalue"]
-  end
-
-  it "should be able to convert to a hash" do
-    instance.register("foo", "foovalue")
-    instance.register("bar", "barvalue")
-
-    result = instance.to_hash
-    result.should be_a(Hash)
-    result["foo"].should == "foovalue"
-    result["bar"].should == "barvalue"
-  end
-end

data/test/unit/vagrant/util/ansi_escape_code_remover_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/ansi_escape_code_remover"
-
-describe Vagrant::Util::ANSIEscapeCodeRemover do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::ANSIEscapeCodeRemover
-    end
-  end
-
-  it "should remove ANSI escape codes" do
-    klass.remove_ansi_escape_codes("\e[Hyo").should == "yo"
-  end
-end
-

data/test/unit/vagrant/util/file_checksum_test.rb

@@ -1,23 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-require 'digest/md5'
-require 'digest/sha1'
-
-require 'vagrant/util/file_checksum'
-
-describe FileChecksum do
-  include_context "unit"
-
-  let(:environment) { isolated_environment }
-
-  it "should return a valid checksum for a file" do
-    file = environment.workdir.join("file")
-    file.open("w+") { |f| f.write("HELLO!") }
-
-    # Check multiple digests
-    instance = described_class.new(file, Digest::MD5)
-    instance.checksum.should == "9ac96c64417b5976a58839eceaa77956"
-
-    instance = described_class.new(file, Digest::SHA1)
-    instance.checksum.should == "264b207c7913e461c43d0f63d2512f4017af4755"
-  end
-end

data/test/unit/vagrant/util/hash_with_indifferent_access_test.rb

@@ -1,38 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/hash_with_indifferent_access"
-
-describe Vagrant::Util::HashWithIndifferentAccess do
-  let(:instance) { described_class.new }
-
-  it "is a Hash" do
-    instance.should be_kind_of(Hash)
-  end
-
-  it "allows indifferent access when setting with a string" do
-    instance["foo"] = "bar"
-    instance[:foo].should == "bar"
-  end
-
-  it "allows indifferent access when setting with a symbol" do
-    instance[:foo] = "bar"
-    instance["foo"].should == "bar"
-  end
-
-  it "allows indifferent key lookup" do
-    instance["foo"] = "bar"
-    instance.key?(:foo).should be
-    instance.has_key?(:foo).should be
-    instance.include?(:foo).should be
-    instance.member?(:foo).should be
-  end
-
-  it "allows for defaults to be passed in via an initializer block" do
-    instance = described_class.new do |h,k|
-      h[k] = "foo"
-    end
-
-    instance[:foo].should == "foo"
-    instance["bar"].should == "foo"
-  end
-end

data/test/unit/vagrant/util/is_port_open_test.rb

@@ -1,53 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "socket"
-
-require "vagrant/util/is_port_open"
-
-describe Vagrant::Util::IsPortOpen do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::IsPortOpen
-    end
-  end
-
-  let(:open_port)   { 52811 }
-  let(:closed_port) { 52811 }
-
-  it "should report open ports" do
-    # Start a thread which listens on a port
-    thr = Thread.new do
-      server = TCPServer.new(open_port)
-      Thread.current[:running] = true
-
-      # Wait until we're told to die
-      Thread.current[:die]     = false
-      while !Thread.current[:die]
-        Thread.pass
-      end
-
-      # Die!
-      server.close
-    end
-
-    # Wait until the server is running
-    while !thr[:running]
-      Thread.pass
-    end
-
-    # Verify that we report the port is open
-    klass.is_port_open?("localhost", open_port).should be
-
-    # Kill the thread
-    thr[:die] = true
-    thr.join
-  end
-
-  it "should report closed ports" do
-    # This CAN fail, since port 52811 might actually be in use, but I'm
-    # not sure what to do except choose some random port and hope for the
-    # best, really.
-    klass.is_port_open?("localhost", closed_port).should_not be
-  end
-end
-