tnargav 1.3.5 → 1.3.6

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/downloader_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/downloader"
+
+describe Vagrant::Util::Downloader do
+  let(:source) { "foo" }
+  let(:destination) { "bar" }
+  let(:exit_code) { 0 }
+
+  let(:subprocess_result) do
+    double("subprocess_result").tap do |result|
+      result.stub(:exit_code => exit_code)
+      result.stub(:stderr => "")
+    end
+  end
+
+  subject { described_class.new(source, destination) }
+
+  before :each do
+    Vagrant::Util::Subprocess.stub(:execute).and_return(subprocess_result)
+  end
+
+  describe "#download!" do
+    let(:curl_options) {
+      ["--fail", "--location", "--max-redirs", "10", "--user-agent", described_class::USER_AGENT, "--output", destination, source, {}]
+    }
+
+    context "with a good exit status" do
+      let(:exit_code) { 0 }
+
+      it "downloads the file and returns true" do
+        Vagrant::Util::Subprocess.should_receive(:execute).
+          with("curl", *curl_options).
+          and_return(subprocess_result)
+
+        subject.download!.should be
+      end
+    end
+
+    context "with a bad exit status" do
+      let(:exit_code) { 1 }
+
+      it "raises an exception" do
+        Vagrant::Util::Subprocess.should_receive(:execute).
+          with("curl", *curl_options).
+          and_return(subprocess_result)
+
+        expect { subject.download! }.
+          to raise_error(Vagrant::Errors::DownloaderError)
+      end
+    end
+
+    context "with a UI" do
+      pending "tests for a UI"
+    end
+  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
+

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

@@ -0,0 +1,16 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/line_ending_helpers"
+
+describe Vagrant::Util::LineEndingHelpers do
+  let(:klass) do
+    Class.new do
+      extend Vagrant::Util::LineEndingHelpers
+    end
+  end
+
+  it "should convert DOS to unix-style line endings" do
+    klass.dos_to_unix("foo\r\nbar\r\n").should == "foo\nbar\n"
+  end
+end
+

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

@@ -0,0 +1,17 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/network_ip"
+
+describe Vagrant::Util::NetworkIP do
+  let(:klass) do
+    Class.new do
+      extend Vagrant::Util::NetworkIP
+    end
+  end
+
+  describe "network address" do
+    it "calculates it properly" do
+      klass.network_address("192.168.2.234", "255.255.255.0").should == "192.168.2.0"
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/retryable"
+
+describe Vagrant::Util::Retryable do
+  let(:klass) do
+    Class.new do
+      extend Vagrant::Util::Retryable
+    end
+  end
+
+  it "doesn't retry by default" do
+    tries = 0
+
+    block = lambda do
+      tries += 1
+      raise RuntimeError, "Try"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(&block) }.
+      to raise_error(RuntimeError)
+
+    # It should've tried once
+    tries.should == 1
+  end
+
+  it "retries the set number of times" do
+    tries = 0
+
+    block = lambda do
+      tries += 1
+      raise RuntimeError, "Try"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(:tries => 5, &block) }.
+      to raise_error(RuntimeError)
+
+    # It should've tried all specified times
+    tries.should == 5
+  end
+
+  it "only retries on the given exception" do
+    tries = 0
+
+    block = lambda do
+      tries += 1
+      raise StandardError, "Try"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(:tries => 5, :on => RuntimeError, &block) }.
+      to raise_error(StandardError)
+
+    # It should've never tried since it was a different kind of error
+    tries.should == 1
+  end
+
+  it "can retry on multiple types of errors" do
+    tries = 0
+
+    foo_error = Class.new(StandardError)
+    bar_error = Class.new(StandardError)
+
+    block = lambda do
+      tries += 1
+      raise foo_error, "Try" if tries == 1
+      raise bar_error, "Try" if tries == 2
+      raise RuntimeError, "YAY"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(:tries => 5, :on => [foo_error, bar_error], &block) }.
+      to raise_error(RuntimeError)
+
+    # It should've never tried since it was a different kind of error
+    tries.should == 3
+  end
+
+  it "doesn't sleep between tries by default" do
+    block = lambda do
+      raise RuntimeError, "Try"
+    end
+
+    # Sleep should never be called
+    klass.should_not_receive(:sleep)
+
+    # Run it.
+    expect { klass.retryable(:tries => 5, &block) }.
+      to raise_error(RuntimeError)
+  end
+
+  it "sleeps specified amount between retries" do
+    block = lambda do
+      raise RuntimeError, "Try"
+    end
+
+    # Sleep should be called between each retry
+    klass.should_receive(:sleep).with(10).exactly(4).times
+
+    # Run it.
+    expect { klass.retryable(:tries => 5, :sleep => 10, &block) }.
+      to raise_error(RuntimeError)
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'tmpdir'
+
+require File.expand_path("../../../base", __FILE__)
+
+require 'vagrant/util/safe_chdir'
+
+describe Vagrant::Util::SafeChdir do
+  it "should change directories" do
+    expected = nil
+    result   = nil
+    temp_dir = Dir.mktmpdir
+
+    Dir.chdir(temp_dir) do
+      expected = Dir.pwd
+    end
+
+    described_class.safe_chdir(temp_dir) do
+      result = Dir.pwd
+    end
+
+    result.should == expected
+  end
+
+  it "should allow recursive chdir" do
+    expected  = nil
+    result    = nil
+    temp_path = Dir.mktmpdir
+
+    Dir.chdir(temp_path) do
+      expected = Dir.pwd
+    end
+
+    expect do
+      described_class.safe_chdir(Dir.mktmpdir) do
+        described_class.safe_chdir(temp_path) do
+          result = Dir.pwd
+        end
+      end
+    end.to_not raise_error
+
+    result.should == expected
+  end
+end

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

@@ -0,0 +1,48 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/scoped_hash_override"
+
+describe Vagrant::Util::ScopedHashOverride do
+  let(:klass) do
+    Class.new do
+      extend Vagrant::Util::ScopedHashOverride
+    end
+  end
+
+  it "should not mess with non-overrides" do
+    original = {
+      :key => "value",
+      :another_value => "foo"
+    }
+
+    klass.scoped_hash_override(original, "foo").should == original
+  end
+
+  it "should override if the scope matches" do
+    original = {
+      :key => "value",
+      :scope__key => "replaced"
+    }
+
+    expected = {
+      :key => "replaced"
+    }
+
+    klass.scoped_hash_override(original, "scope").should == expected
+  end
+
+  it "should ignore non-matching scopes" do
+    original = {
+      :key => "value",
+      :scope__key => "replaced",
+      :another__key => "value"
+    }
+
+    expected = {
+      :key => "replaced",
+      :another__key => "value"
+    }
+
+    klass.scoped_hash_override(original, "scope").should == expected
+  end
+end

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

@@ -0,0 +1,30 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/platform"
+require "vagrant/util/ssh"
+
+describe Vagrant::Util::SSH do
+  include_context "unit"
+
+  describe "checking key permissions" do
+    let(:key_path) { temporary_file }
+
+    it "should do nothing on Windows" do
+      Vagrant::Util::Platform.stub(:windows?).and_return(true)
+
+      key_path.chmod(0700)
+
+      # Get the mode now and verify that it is untouched afterwards
+      mode = key_path.stat.mode
+      described_class.check_key_permissions(key_path)
+      key_path.stat.mode.should == mode
+    end
+
+    it "should fix the permissions" do
+      key_path.chmod(0644)
+
+      described_class.check_key_permissions(key_path)
+      key_path.stat.mode.should == 0100600
+    end
+  end
+end