vagrant-fixed-ssh 1.0.7

data/test/unit/vagrant/environment_test.rb

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

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

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

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

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

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

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