vagrant-fixed-ssh 1.0.7

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

@@ -0,0 +1,79 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Config::Loader do
+  include_context "unit"
+
+  let(:instance) { described_class.new }
+
+  it "should ignore non-existent load order keys" do
+    instance.load_order = [:foo]
+    instance.load
+  end
+
+  it "should load and return the configuration" do
+    proc = Proc.new do |config|
+      config.vagrant.dotfile_name = "foo"
+    end
+
+    instance.load_order = [:proc]
+    instance.set(:proc, proc)
+    config = instance.load
+
+    config.vagrant.dotfile_name.should == "foo"
+  end
+
+  it "should only run the same proc once" do
+    count = 0
+    proc = Proc.new do |config|
+      config.vagrant.dotfile_name = "foo"
+      count += 1
+    end
+
+    instance.load_order = [:proc]
+    instance.set(:proc, proc)
+
+    5.times do
+      result = instance.load
+
+      # Verify the config result
+      result.vagrant.dotfile_name.should == "foo"
+
+      # Verify the count is only one
+      count.should == 1
+    end
+  end
+
+  it "should only load configuration files once" do
+    $_config_data = 0
+
+    # We test both setting a file multiple times as well as multiple
+    # loads, since both should not cache the data.
+    file = temporary_file("$_config_data += 1")
+    instance.load_order = [:file]
+    5.times { instance.set(:file, file) }
+    5.times { instance.load }
+
+    $_config_data.should == 1
+  end
+
+  it "should not clear the cache if setting to the same value multiple times" do
+    $_config_data = 0
+
+    file = temporary_file("$_config_data += 1")
+
+    instance.load_order = [:proc]
+    instance.set(:proc, file)
+    5.times { instance.load }
+
+    instance.set(:proc, file)
+    5.times { instance.load }
+
+    $_config_data.should == 1
+  end
+
+  it "should raise proper error if there is a syntax error in a Vagrantfile" do
+    instance.load_order = [:file]
+    expect { instance.set(:file, temporary_file("Vagrant:^Config")) }.
+      to raise_exception(Vagrant::Errors::VagrantfileSyntaxError)
+  end
+end

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

@@ -0,0 +1,17 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Config::SSHConfig do
+  include_context "unit"
+
+  [:forward_agent, :forward_x11].each do |bool_setting|
+    it "merges boolean #{bool_setting} properly" do
+      a = described_class.new
+      a.send("#{bool_setting}=", true)
+
+      b = described_class.new
+
+      c = a.merge(b)
+      c.send(bool_setting).should be
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/registry"
+
+describe Vagrant::Config::Top do
+  include_context "unit"
+
+  let(:registry) { Vagrant::Registry.new }
+  let(:instance) { described_class.new(registry) }
+
+  it "should load in the proper config class" do
+    registry.register(:foo, Object)
+
+    instance.foo.should be_kind_of(Object)
+  end
+
+  it "should load the proper config class only once" do
+    registry.register(:foo, Object)
+
+    obj = instance.foo
+    instance.foo.should eql(obj)
+  end
+
+  it "still raises a method missing error if invalid key" do
+    expect { instance.foo }.to raise_error(NoMethodError)
+  end
+
+  describe "merging" do
+    let(:foo_class) do
+      Class.new do
+        attr_accessor :one
+        attr_accessor :two
+
+        def merge(other)
+          result = self.class.new
+          result.one = other.one || one
+          result.two = other.two || two
+          result
+        end
+      end
+    end
+
+    it "merges each key by calling `merge` on the class" do
+      registry.register(:foo, foo_class)
+
+      instance.foo.one = 1
+      instance.foo.two = 2
+
+      another = described_class.new(registry)
+      another.foo.one = 2
+
+      result = instance.merge(another)
+      result.foo.one.should == 2
+      result.foo.two.should == 2
+    end
+
+    it "merges keys that aren't in the source instance" do
+      reg = Vagrant::Registry.new
+      reg.register(:foo, foo_class)
+
+      another = described_class.new(reg)
+      another.foo.one = 2
+
+      result = instance.merge(another)
+      result.foo.one.should == 2
+      result.foo.two.should be_nil
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Config::VMConfig do
+  include_context "unit"
+
+  it "merges by appending forwarded ports" do
+    a = described_class.new
+    a.forward_port 80, 8080
+
+    b = described_class.new
+    b.forward_port 100, 1000
+
+    c = a.merge(b)
+    c.forwarded_ports.length.should == 2
+    c.forwarded_ports[0][:guestport].should == 80
+    c.forwarded_ports[0][:hostport].should == 8080
+    c.forwarded_ports[1][:guestport].should == 100
+    c.forwarded_ports[1][:hostport].should == 1000
+  end
+
+  it "merges by merging shared folders" do
+    a = described_class.new
+    a.share_folder "a", "/guest", "/host"
+    a.share_folder "b", "/guest", "/host"
+
+    b = described_class.new
+    b.share_folder "c", "/guest", "/host"
+
+    c = a.merge(b)
+    c.shared_folders.has_key?("a").should be
+    c.shared_folders.has_key?("b").should be
+    c.shared_folders.has_key?("c").should be
+  end
+
+  it "merges by appending networks" do
+    a = described_class.new
+    a.network :hostonly, "192.168.33.10"
+
+    b = described_class.new
+    b.network :hostonly, "192.168.33.11"
+
+    c = a.merge(b)
+    c.networks.length.should == 2
+    c.networks[0].should == [:hostonly, ["192.168.33.10"]]
+    c.networks[1].should == [:hostonly, ["192.168.33.11"]]
+  end
+
+  it "merges by appending provisioners" do
+    a = described_class.new
+    a.provision :foo
+
+    b = described_class.new
+    b.provision :bar
+
+    c = a.merge(b)
+    c.provisioners.length.should == 2
+    c.provisioners[0].shortcut.should == :foo
+    c.provisioners[1].shortcut.should == :bar
+  end
+
+  it "merges by appending customizations" do
+    a = described_class.new
+    a.customize "a"
+
+    b = described_class.new
+    b.customize "b"
+
+    c = a.merge(b)
+    c.customizations.should == ["a", "b"]
+  end
+end

data/test/unit/vagrant/config_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::Config do
+  it "should not execute the proc on configuration" do
+    described_class.run do
+      raise Exception, "Failure."
+    end
+  end
+
+  it "should capture configuration procs" do
+    receiver = double()
+
+    procs = described_class.capture_configures do
+      described_class.run do
+        receiver.hello!
+      end
+    end
+
+    # Verify the structure of the result
+    procs.should be_kind_of(Array)
+    procs.length.should == 1
+
+    # Verify that the proper proc was captured
+    receiver.should_receive(:hello!).once
+    procs[0].call
+  end
+end

data/test/unit/vagrant/data_store_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path("../../base", __FILE__)
+
+require 'pathname'
+
+describe Vagrant::DataStore do
+  include_context "unit"
+
+  let(:db_file) do
+    # We create a tempfile and force an explicit close/unlink
+    # but save the path so that we can re-use it multiple times
+    temp = Tempfile.new("vagrant")
+    result = Pathname.new(temp.path)
+    temp.close
+    temp.unlink
+
+    result
+  end
+
+  let(:instance)    { described_class.new(db_file) }
+
+  it "initializes a new DB file" do
+    instance[:data] = true
+    instance.commit
+    instance[:data].should == true
+
+    test = described_class.new(db_file)
+    test[:data].should == true
+  end
+
+  it "initializes empty if the file contains invalid data" do
+    db_file.open("w+") { |f| f.write("NOPE!") }
+    described_class.new(db_file).should be_empty
+  end
+
+  it "initializes empty if the file doesn't exist" do
+    described_class.new("NOPENOPENOPENOPENPEPEPEPE").should be_empty
+  end
+
+  it "raises an error if the path given is a directory" do
+    db_file.delete if db_file.exist?
+    db_file.mkdir
+
+    expect { described_class.new(db_file) }.
+      to raise_error(Vagrant::Errors::DotfileIsDirectory)
+  end
+
+  it "cleans nil and empties when committing" do
+    instance[:data] = { :bar => nil }
+    instance[:another] = {}
+    instance.commit
+
+    # The instance is now empty because the data was nil
+    instance.should be_empty
+  end
+
+  it "deletes the data file if the store is empty when saving" do
+    instance[:data] = true
+    instance.commit
+
+    another = described_class.new(db_file)
+    another[:data] = nil
+    another.commit
+
+    # The file should no longer exist
+    db_file.should_not be_exist
+  end
+
+  it "works if the DB file is nil" do
+    store = described_class.new(nil)
+    store[:foo] = "bar"
+    store[:foo].should == "bar"
+  end
+
+  it "throws an exception if attempting to commit a data store with no file" do
+    store = described_class.new(nil)
+    expect { store.commit }.
+      to raise_error(StandardError)
+  end
+end

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

@@ -0,0 +1,18 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Downloaders::Base do
+  let(:ui) { double("ui") }
+  let(:instance) { described_class.new(ui) }
+
+  it "should not match anything by default" do
+    described_class.match?("foo").should_not be
+  end
+
+  it "should implement `prepare`" do
+    instance.prepare("foo").should be_nil
+  end
+
+  it "should implement `download!`" do
+    instance.download!("foo", "bar").should be_nil
+  end
+end

data/test/unit/vagrant/downloaders/file_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "tempfile"
+
+describe Vagrant::Downloaders::File do
+  let(:ui) { double("ui") }
+  let(:instance) { described_class.new(ui) }
+
+  describe "matching" do
+    it "should match an existing file" do
+      described_class.match?(__FILE__).should be
+    end
+
+    it "should not match non-existent files" do
+      described_class.match?(File.join(__FILE__, "nowaywaywaywayayway")).should_not be
+    end
+
+    it "should match files where the path needs to be expanded" do
+      old_home = ENV["HOME"]
+      begin
+        # Create a temporary file
+        temp = Tempfile.new("vagrant")
+
+        # Set our home directory to be this directory so we can use
+        # "~" paths
+        ENV["HOME"] = File.dirname(temp.path)
+
+        # Test that we can find the temp file
+        described_class.match?("~/#{File.basename(temp.path)}").should be
+      ensure
+        ENV["HOME"] = old_home
+      end
+    end
+  end
+
+  describe "preparing" do
+    it "should raise an exception if the file does not exist" do
+      path = File.join(__FILE__, "nopenopenope")
+      File.exist?(path).should_not be
+
+      expect { instance.prepare(path) }.to raise_error(Vagrant::Errors::DownloaderFileDoesntExist)
+    end
+
+    it "should raise an exception if the file is a directory" do
+      path = File.dirname(__FILE__)
+      File.should be_directory(path)
+
+      expect { instance.prepare(path) }.to raise_error(Vagrant::Errors::DownloaderFileDoesntExist)
+    end
+
+    it "should find files that use shell expansions" do
+      old_home = ENV["HOME"]
+      begin
+        # Create a temporary file
+        temp = Tempfile.new("vagrant")
+
+        # Set our home directory to be this directory so we can use
+        # "~" paths
+        ENV["HOME"] = File.dirname(temp.path)
+
+        # Test that we can find the temp file
+        expect { instance.prepare("~/#{File.basename(temp.path)}") }.
+          to_not raise_error
+      ensure
+        ENV["HOME"] = old_home
+      end
+    end
+  end
+
+  describe "downloading" do
+    it "should copy the source to the destination" do
+      pending "setup paths"
+    end
+  end
+end

data/test/unit/vagrant/downloaders/http_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Downloaders::HTTP do
+  let(:ui) { double("ui") }
+  let(:instance) { described_class.new(ui) }
+
+  describe "matching" do
+    it "should match URLs" do
+      described_class.match?("http://google.com/foo.box").should be
+      described_class.match?("https://google.com/foo.box").should be
+      described_class.match?("http://foo:bar@google.com/foo.box").should be
+      described_class.match?("http://google.com:8500/foo.box").should be
+    end
+  end
+
+  describe "downloading" do
+    # Integration tests only.
+  end
+end