vagrant 0.1.0

data/test/vagrant/downloaders/base_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class BaseDownloaderTest < Test::Unit::TestCase
+  should "include the util class so subclasses have access to it" do
+    assert Vagrant::Downloaders::Base.include?(Vagrant::Util)
+  end
+
+  context "base instance" do
+    setup do
+      @base = Vagrant::Downloaders::Base.new
+    end
+
+    should "implement prepare which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:download!)
+        @base.download!("source", "destination")
+      end
+    end
+  end
+end

data/test/vagrant/downloaders/file_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class FileDownloaderTest < Test::Unit::TestCase
+  setup do
+    @downloader, @tempfile = mock_downloader(Vagrant::Downloaders::File)
+    @uri = "foo.box"
+  end
+
+  context "downloading" do
+    setup do
+      @file = mock("file")
+      @file.stubs(:read)
+      @file.stubs(:eof?).returns(false)
+      @downloader.stubs(:open).yields(@file)
+    end
+
+    should "open with the given uri" do
+      @downloader.expects(:open).with(@uri).once
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "buffer the read from the file and write to the tempfile" do
+      data = mock("data")
+      write_seq = sequence("write_seq")
+      @file.stubs(:eof?).returns(false).in_sequence(write_seq)
+      @file.expects(:read).returns(data).in_sequence(write_seq)
+      @tempfile.expects(:write).with(data).in_sequence(write_seq)
+      @file.stubs(:eof?).returns(true).in_sequence(write_seq)
+      @downloader.download!(@uri, @tempfile)
+    end
+  end
+end

data/test/vagrant/downloaders/http_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class HttpDownloaderTest < Test::Unit::TestCase
+  setup do
+    @downloader, @tempfile = mock_downloader(Vagrant::Downloaders::HTTP)
+    @downloader.stubs(:report_progress)
+    @downloader.stubs(:complete_progress)
+    @uri = "foo.box"
+  end
+
+  context "downloading" do
+    setup do
+      @parsed_uri = mock("parsed")
+      URI.stubs(:parse).with(@uri).returns(@parsed_uri)
+    end
+
+    should "parse the URI and use that parsed URI for Net::HTTP" do
+      URI.expects(:parse).with(@uri).returns(@parsed_uri).once
+      Net::HTTP.expects(:get_response).with(@parsed_uri).once
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "read the body of the response and place each segment into the file" do
+      response = mock("response")
+      response.stubs(:content_length)
+      segment = mock("segment")
+      segment.stubs(:length).returns(7)
+
+      Net::HTTP.stubs(:get_response).yields(response)
+      response.expects(:read_body).once.yields(segment)
+      @tempfile.expects(:write).with(segment).once
+
+      @downloader.download!(@uri, @tempfile)
+    end
+  end
+
+  context "reporting progress" do
+    # TODO: Testing for this, probably
+  end
+end

data/test/vagrant/env_test.rb

@@ -0,0 +1,293 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class EnvTest < Test::Unit::TestCase
+  def mock_persisted_vm(returnvalue="foovm")
+    filemock = mock("filemock")
+    filemock.expects(:read).returns("foo")
+    Vagrant::VM.expects(:find).with("foo").returns(returnvalue)
+    File.expects(:open).with(Vagrant::Env.dotfile_path).once.yields(filemock)
+    Vagrant::Env.load_vm!
+  end
+
+  setup do
+    mock_config
+    Vagrant::Box.stubs(:find).returns("foo")
+  end
+
+  context "requiring a VM" do
+    should "error and exit if no persisted VM was found" do
+      assert_nil Vagrant::Env.persisted_vm
+      Vagrant::Env.expects(:error_and_exit).once
+      Vagrant::Env.require_persisted_vm
+    end
+
+    should "return and continue if persisted VM is found" do
+      mock_persisted_vm
+      Vagrant::Env.expects(:error_and_exit).never
+      Vagrant::Env.require_persisted_vm
+    end
+  end
+
+  context "loading home directory" do
+    setup do
+      @home_dir = File.expand_path(Vagrant.config.vagrant.home)
+
+      File.stubs(:directory?).returns(true)
+      FileUtils.stubs(:mkdir_p)
+    end
+
+    should "create each directory if it doesn't exist" do
+      create_seq = sequence("create_seq")
+      File.stubs(:directory?).returns(false)
+      Vagrant::Env::HOME_SUBDIRS.each do |subdir|
+        FileUtils.expects(:mkdir_p).with(File.join(@home_dir, subdir)).in_sequence(create_seq)
+      end
+
+      Vagrant::Env.load_home_directory!
+    end
+
+    should "not create directories if they exist" do
+      File.stubs(:directory?).returns(true)
+      FileUtils.expects(:mkdir_p).never
+      Vagrant::Env.load_home_directory!
+    end
+  end
+
+  context "loading config" do
+    setup do
+      @root_path = "/foo"
+      Vagrant::Env.stubs(:root_path).returns(@root_path)
+      Vagrant::Env.stubs(:box).returns(nil)
+      File.stubs(:exist?).returns(false)
+      Vagrant::Config.stubs(:execute!)
+      Vagrant::Config.stubs(:reset!)
+    end
+
+    should "reset the configuration object" do
+      Vagrant::Config.expects(:reset!).once
+      Vagrant::Env.load_config!
+    end
+
+    should "load from the project root" do
+      File.expects(:exist?).with(File.join(PROJECT_ROOT, "config", "default.rb")).once
+      Vagrant::Env.load_config!
+    end
+
+    should "load from the root path" do
+      File.expects(:exist?).with(File.join(@root_path, Vagrant::Env::ROOTFILE_NAME)).once
+      Vagrant::Env.load_config!
+    end
+
+    should "not load from the root path if nil" do
+      Vagrant::Env.stubs(:root_path).returns(nil)
+      File.expects(:exist?).with(File.join(@root_path, Vagrant::Env::ROOTFILE_NAME)).never
+      Vagrant::Env.load_config!
+    end
+
+    should "not load from the box directory if it is nil" do
+      Vagrant::Env.expects(:box).once.returns(nil)
+      Vagrant::Env.load_config!
+    end
+
+    should "load from the box directory if it is not nil" do
+      dir = "foo"
+      box = mock("box")
+      box.stubs(:directory).returns(dir)
+      Vagrant::Env.expects(:box).twice.returns(box)
+      File.expects(:exist?).with(File.join(dir, Vagrant::Env::ROOTFILE_NAME)).once
+      Vagrant::Env.load_config!
+    end
+
+    should "load the files only if exist? returns true" do
+      File.expects(:exist?).once.returns(true)
+      Vagrant::Env.expects(:load).once
+      Vagrant::Env.load_config!
+    end
+
+    should "not load the files if exist? returns false" do
+      Vagrant::Env.expects(:load).never
+      Vagrant::Env.load_config!
+    end
+
+    should "execute after loading" do
+      File.expects(:exist?).once.returns(true)
+      Vagrant::Env.expects(:load).once
+      Vagrant::Config.expects(:execute!).once
+      Vagrant::Env.load_config!
+    end
+  end
+
+  context "initial load" do
+    test "load! should load the config and set the persisted_uid" do
+      Vagrant::Env.expects(:load_config!).once
+      Vagrant::Env.expects(:load_vm!).once
+      Vagrant::Env.expects(:load_root_path!).with(Pathname.new(Dir.pwd), {}).once
+      Vagrant::Env.expects(:load_home_directory!).once
+      Vagrant::Env.expects(:load_box!).once
+      Vagrant::Env.load!
+    end
+  end
+
+  context "persisting the VM into a file" do
+    setup do
+      mock_config
+    end
+
+    test "should save it to the dotfile path" do
+      vm = mock("vm")
+      vm.stubs(:uuid).returns("foo")
+
+      filemock = mock("filemock")
+      filemock.expects(:write).with(vm.uuid)
+      File.expects(:open).with(Vagrant::Env.dotfile_path, 'w+').once.yields(filemock)
+      Vagrant::Env.persist_vm(vm)
+    end
+  end
+
+  context "loading the UUID out from the persisted file" do
+    test "loading of the uuid from the dotfile" do
+      mock_persisted_vm
+      assert_equal 'foovm', Vagrant::Env.persisted_vm
+    end
+
+    should "do nothing if the root path is nil" do
+      File.expects(:open).never
+      Vagrant::Env.stubs(:root_path).returns(nil)
+      Vagrant::Env.load_vm!
+    end
+
+    test "uuid should be nil if dotfile didn't exist" do
+      File.expects(:open).raises(Errno::ENOENT)
+      Vagrant::Env.load_vm!
+      assert_nil Vagrant::Env.persisted_vm
+    end
+
+    test "should build up the dotfile out of the root path and the dotfile name" do
+      assert_equal File.join(Vagrant::Env.root_path, Vagrant.config.vagrant.dotfile_name), Vagrant::Env.dotfile_path
+    end
+  end
+
+  context "loading the root path" do
+    test "should walk the parent directories looking for rootfile" do
+      Vagrant::Env.expects(:error_and_exit).once
+
+      paths = [
+        Pathname.new("/foo/bar/baz"),
+        Pathname.new("/foo/bar"),
+        Pathname.new("/foo")
+      ]
+
+      search_seq = sequence("search_seq")
+      paths.each do |path|
+        File.expects(:exist?).with("#{path}/#{Vagrant::Env::ROOTFILE_NAME}").returns(false).in_sequence(search_seq)
+      end
+
+      assert_nil Vagrant::Env.load_root_path!(paths.first)
+    end
+
+    test "should print out an error and exit if not found" do
+      path = Pathname.new("/")
+
+      Vagrant::Env.expects(:error_and_exit).once
+      Vagrant::Env.load_root_path!(path)
+    end
+
+    should "return false if suppress errors is set and no root path is found" do
+      path = Pathname.new("/")
+
+      Vagrant::Env.expects(:error_and_exit).never
+      assert !Vagrant::Env.load_root_path!(path, :suppress_errors => true)
+    end
+
+    should "pipe suppress errors flag through recursion" do
+      path = Pathname.new("/foo/bar/baz")
+      File.expects(:exist?).times(3).returns(false)
+
+      Vagrant::Env.expects(:error_and_exit).never
+      assert !Vagrant::Env.load_root_path!(path, :suppress_errors => true)
+    end
+
+    test "should set the path for the rootfile" do
+      path = "/foo"
+      File.expects(:exist?).with("#{path}/#{Vagrant::Env::ROOTFILE_NAME}").returns(true)
+
+      assert Vagrant::Env.load_root_path!(Pathname.new(path))
+      assert_equal path, Vagrant::Env.root_path
+    end
+  end
+
+  context "home directory paths" do
+    should "return the expanded config for `home_path`" do
+      assert_equal File.expand_path(Vagrant.config.vagrant.home), Vagrant::Env.home_path
+    end
+
+    should "return the home_path joined with tmp for a tmp path" do
+      @home_path = "foo"
+      Vagrant::Env.stubs(:home_path).returns(@home_path)
+      assert_equal File.join(@home_path, "tmp"), Vagrant::Env.tmp_path
+    end
+
+    should "return the boxes path" do
+      @home_path = "foo"
+      Vagrant::Env.stubs(:home_path).returns(@home_path)
+      assert_equal File.join(@home_path, "boxes"), Vagrant::Env.boxes_path
+    end
+  end
+
+  context "loading box" do
+    setup do
+      @box = mock("box")
+
+      Vagrant::Env.stubs(:load_config!)
+    end
+
+    should "not load the box if its not set" do
+      mock_config do |config|
+        config.vm.box = nil
+      end
+
+      Vagrant::Box.expects(:find).never
+      Vagrant::Env.load_box!
+    end
+
+    should "set the box to what is found by the Box class" do
+      Vagrant::Box.expects(:find).with(Vagrant.config.vm.box).once.returns(@box)
+      Vagrant::Env.load_box!
+      assert @box.equal?(Vagrant::Env.box)
+    end
+
+    should "load the config if a box is loaded" do
+      Vagrant::Env.expects(:load_config!).once
+      Vagrant::Box.expects(:find).returns(@box)
+      Vagrant::Env.load_box!
+    end
+  end
+
+  context "requiring boxes" do
+    should "error and exit if no box is found" do
+      mock_config do |config|
+        config.vm.box = nil
+      end
+
+      Vagrant::Env.expects(:box).returns(nil)
+      Vagrant::Env.expects(:error_and_exit).once.with() do |msg|
+        assert msg =~ /no base box was specified/i
+        true
+      end
+      Vagrant::Env.require_box
+    end
+
+    should "error and exit if box is specified but doesn't exist" do
+      mock_config do |config|
+        config.vm.box = "foo"
+      end
+
+      Vagrant::Env.expects(:box).returns(nil)
+      Vagrant::Env.expects(:error_and_exit).once.with() do |msg|
+        assert msg =~ /does not exist/i
+        true
+      end
+      Vagrant::Env.require_box
+    end
+  end
+end

data/test/vagrant/ssh_test.rb

@@ -0,0 +1,95 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class SshTest < Test::Unit::TestCase
+  setup do
+    mock_config
+  end
+
+  context "connecting to SSH" do
+    setup do
+      @script = Vagrant::SSH::SCRIPT
+    end
+
+    test "should call exec with defaults when no options are supplied" do
+      ssh = Vagrant.config.ssh
+      Kernel.expects(:exec).with("#{@script} #{ssh[:username]} #{ssh[:password]} #{ssh[:host]} #{Vagrant::SSH.port}")
+      Vagrant::SSH.connect
+    end
+
+    test "should call exec with supplied params" do
+      args = {:username => 'bar', :password => 'baz', :host => 'bak', :port => 'bag'}
+      Kernel.expects(:exec).with("#{@script} #{args[:username]} #{args[:password]} #{args[:host]} #{args[:port]}")
+      Vagrant::SSH.connect(args)
+    end
+  end
+
+  context "executing ssh commands" do
+    should "call net::ssh.start with the proper names" do
+      Net::SSH.expects(:start).once.with() do |host, username, opts|
+        assert_equal Vagrant.config.ssh.host, host
+        assert_equal Vagrant.config.ssh.username, username
+        assert_equal Vagrant::SSH.port, opts[:port]
+        assert_equal Vagrant.config.ssh.password, opts[:password]
+        true
+      end
+      Vagrant::SSH.execute
+    end
+
+    should "use custom host if set" do
+      Vagrant.config.ssh.host = "foo"
+      Net::SSH.expects(:start).with(Vagrant.config.ssh.host, Vagrant.config.ssh.username, anything).once
+      Vagrant::SSH.execute
+    end
+  end
+
+  context "SCPing files to the remote host" do
+    should "use Vagrant::SSH execute to setup an SCP connection and upload" do
+      scp = mock("scp")
+      ssh = mock("ssh")
+      scp.expects(:upload!).with("foo", "bar").once
+      Net::SCP.expects(:new).with(ssh).returns(scp).once
+      Vagrant::SSH.expects(:execute).yields(ssh).once
+      Vagrant::SSH.upload!("foo", "bar")
+    end
+  end
+
+  context "checking if host is up" do
+    setup do
+      mock_config
+    end
+
+    should "return true if SSH connection works" do
+      Net::SSH.expects(:start).yields("success")
+      assert Vagrant::SSH.up?
+    end
+
+    should "return false if SSH connection times out" do
+      Net::SSH.expects(:start)
+      assert !Vagrant::SSH.up?
+    end
+
+    should "return false if the connection is refused" do
+      Net::SSH.expects(:start).raises(Errno::ECONNREFUSED)
+      assert_nothing_raised {
+        assert !Vagrant::SSH.up?
+      }
+    end
+
+    should "return false if the connection is dropped" do
+      Net::SSH.expects(:start).raises(Net::SSH::Disconnect)
+      assert_nothing_raised {
+        assert !Vagrant::SSH.up?
+      }
+    end
+  end
+
+  context "getting the ssh port" do
+    should "return the configured port by default" do
+      assert_equal Vagrant.config.vm.forwarded_ports[Vagrant.config.ssh.forwarded_port_key][:hostport], Vagrant::SSH.port
+    end
+
+    should "return the port given in options if it exists" do
+      assert_equal "47", Vagrant::SSH.port({ :port => "47" })
+    end
+  end
+end