vagrant 0.2.0 → 0.3.0

data/test/vagrant/commands/down_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsDownTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Down
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "just error and exit" do
+      @instance.expects(:error_and_exit).with(:command_deprecation_down)
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/halt_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsHaltTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Halt
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "call the `halt` action on the VM" do
+      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Halt).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/init_test.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsInitTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Init
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+  end
+
+  context "execute" do
+    should "create the vagrantfile with the first arg" do
+      args = [:foo]
+      @instance.expects(:create_vagrantfile).with(args.first)
+      @instance.execute(args)
+    end
+  end
+
+  context "creating the vagrantfile" do
+    setup do
+      @file = mock("file")
+      @file.stubs(:write)
+      File.stubs(:open).yields(@file)
+      @rootfile_path = File.join(Dir.pwd, Vagrant::Environment::ROOTFILE_NAME)
+
+      Vagrant::Util::TemplateRenderer.stubs(:render)
+    end
+
+    should "error and exit if a rootfile already exists" do
+      File.expects(:exist?).with(@rootfile_path).returns(true)
+      @instance.expects(:error_and_exit).with(:rootfile_already_exists).once
+      @instance.create_vagrantfile
+    end
+
+    should "write to the rootfile path using the template renderer" do
+      result = "foo"
+      Vagrant::Util::TemplateRenderer.expects(:render).returns(result).once
+      @file.expects(:write).with(result).once
+      File.expects(:open).with(@rootfile_path, 'w+').yields(@file)
+
+      @instance.create_vagrantfile
+    end
+
+    should "use the given base box if given" do
+      box = "zooo"
+      Vagrant::Util::TemplateRenderer.expects(:render).with(Vagrant::Environment::ROOTFILE_NAME, :default_box => box)
+      @instance.create_vagrantfile(box)
+    end
+
+    should "use the default `base` if no box is given" do
+      Vagrant::Util::TemplateRenderer.expects(:render).with(Vagrant::Environment::ROOTFILE_NAME, :default_box => "base")
+      @instance.create_vagrantfile
+    end
+  end
+end

data/test/vagrant/commands/package_test.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsPackageTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Package
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    setup do
+      @persisted_vm.stubs(:package)
+      @persisted_vm.stubs(:powered_off?).returns(true)
+    end
+
+    context "with no base specified" do
+      should "require a persisted vm" do
+        @env.expects(:require_persisted_vm).once
+        @instance.execute
+      end
+    end
+
+    context "with base specified" do
+      setup do
+        @vm = mock("vm")
+
+        Vagrant::VM.stubs(:find).with(@name).returns(@vm)
+        @vm.stubs(:env=).with(@env)
+        @env.stubs(:vm=)
+
+        @name = "bar"
+      end
+
+      should "find the given base and set it on the env" do
+        Vagrant::VM.expects(:find).with(@name).returns(@vm)
+        @vm.expects(:env=).with(@env)
+        @env.expects(:vm=).with(@vm)
+
+        @instance.execute(["foo", "--base", @name])
+      end
+
+      should "error if the VM is not found" do
+        Vagrant::VM.expects(:find).with(@name).returns(nil)
+        @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => @name).once
+
+        @instance.execute(["foo", "--base", @name])
+      end
+    end
+
+    context "shared (with and without base specified)" do
+      should "error and exit if the VM is not powered off" do
+        @persisted_vm.stubs(:powered_off?).returns(false)
+        @instance.expects(:error_and_exit).with(:vm_power_off_to_package).once
+        @persisted_vm.expects(:package).never
+        @instance.execute
+      end
+
+      should "call package on the persisted VM" do
+        @persisted_vm.expects(:package).once
+        @instance.execute
+      end
+
+      should "pass the out path and include_files to the package method" do
+        out_path = mock("out_path")
+        include_files = "foo"
+        @persisted_vm.expects(:package).with(out_path, [include_files]).once
+        @instance.execute([out_path, "--include", include_files])
+      end
+
+      should "default to an empty array when not include_files are specified" do
+        out_path = mock("out_path")
+        @persisted_vm.expects(:package).with(out_path, []).once
+        @instance.execute([out_path])
+      end
+    end
+  end
+end

data/test/vagrant/commands/reload_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsReloadTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Reload
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "call the `reload` action on the VM" do
+      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Reload).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/resume_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsResumeTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Resume
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    setup do
+      @persisted_vm.stubs(:resume)
+      @persisted_vm.stubs(:saved?).returns(true)
+    end
+
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "save the state of the VM" do
+      @persisted_vm.expects(:resume).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/ssh_config_test.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsSSHConfigTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::SSHConfig
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    setup do
+      @ssh = mock("ssh")
+      @ssh.stubs(:port).returns(2197)
+      @env.stubs(:ssh).returns(@ssh)
+      @env.stubs(:require_root_path)
+
+      @instance.stubs(:puts)
+
+      @data = {
+        :host_key => "vagrant",
+        :ssh_user => @env.config.ssh.username,
+        :ssh_port => @env.ssh.port,
+        :private_key_path => @env.config.ssh.private_key_path
+      }
+    end
+
+    should "require root path" do
+      @env.expects(:require_root_path).once
+      @instance.execute
+    end
+
+    should "output rendered template" do
+      result = mock("result")
+      Vagrant::Util::TemplateRenderer.expects(:render).with("ssh_config", @data).returns(result)
+
+      @instance.expects(:puts).with(result).once
+      @instance.execute
+    end
+
+    should "render with the given host name if given" do
+      host = "foo"
+      @data[:host_key] = host
+      Vagrant::Util::TemplateRenderer.expects(:render).with("ssh_config", @data)
+      @instance.execute(["--host", host])
+    end
+  end
+end

data/test/vagrant/commands/ssh_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsSSHTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::SSH
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    setup do
+      @env.ssh.stubs(:connect)
+    end
+
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "connect to SSH" do
+      @env.ssh.expects(:connect).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/status_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsStatusTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Status
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    # TODO
+  end
+end

data/test/vagrant/commands/suspend_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsSuspendTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Suspend
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+
+    @env = mock_environment
+    @env.stubs(:require_persisted_vm)
+    @env.stubs(:vm).returns(@persisted_vm)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    setup do
+      @persisted_vm.stubs(:suspend)
+      @persisted_vm.stubs(:saved?).returns(false)
+    end
+
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "suspend the VM" do
+      @persisted_vm.expects(:suspend).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/up_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsUpTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Up
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+  end
+
+  context "executing" do
+    setup do
+      @new_vm = mock("vm")
+      @new_vm.stubs(:execute!)
+
+      @env.stubs(:vm).returns(nil)
+      @env.stubs(:require_box)
+      @env.stubs(:create_vm).returns(@new_vm)
+    end
+
+    should "require a box" do
+      @env.expects(:require_box).once
+      @instance.execute
+    end
+
+    should "call the up action on VM if it doesn't exist" do
+      @new_vm.expects(:execute!).with(Vagrant::Actions::VM::Up).once
+      @instance.execute
+    end
+
+    should "call start on the persisted vm if it exists" do
+      @env.stubs(:vm).returns(@persisted_vm)
+      @persisted_vm.expects(:start).once
+      @env.expects(:create_vm).never
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/config_test.rb

@@ -2,10 +2,14 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class ConfigTest < Test::Unit::TestCase
   context "the ssh config" do
+    setup do
+      @env = mock_environment
+      @env.stubs(:root_path).returns("foo")
+    end
+
     should "expand any path when requesting the value" do
-      Vagrant::Env.stubs(:root_path).returns('foo')
-      File.stubs(:expand_path).with(Vagrant.config.ssh[:private_key_path], 'foo').returns('success')
-      assert Vagrant.config.ssh.private_key_path, 'success'
+      result = File.expand_path(@env.config.ssh[:private_key_path], @env.root_path)
+      assert_equal result, @env.config.ssh.private_key_path
     end
   end
 
@@ -40,6 +44,12 @@ class ConfigTest < Test::Unit::TestCase
       Vagrant::Config.reset!
       assert Vagrant::Config.proc_stack.empty?
     end
+
+    should "reload the config object based on the given environment" do
+      env = mock("env")
+      Vagrant::Config.expects(:config).with(env).once
+      Vagrant::Config.reset!(env)
+    end
   end
 
   context "accessing configuration" do
@@ -78,6 +88,12 @@ class ConfigTest < Test::Unit::TestCase
       Vagrant::Config.execute!
       assert Vagrant::Config.config.loaded?
     end
+
+    should "return the configuration on execute!" do
+      Vagrant::Config.run {}
+      result = Vagrant::Config.execute!
+      assert result.equal?(Vagrant.config)
+    end
   end
 
   context "base class" do
@@ -105,12 +121,20 @@ class ConfigTest < Test::Unit::TestCase
       end
     end
 
-    should "convert instance variable hash to json" do
-      @json = mock("json")
-      @iv_hash = mock("iv_hash")
-      @iv_hash.expects(:to_json).once.returns(@json)
-      @base.expects(:instance_variables_hash).returns(@iv_hash)
-      assert_equal @json, @base.to_json
+    context "converting to JSON" do
+      should "convert instance variable hash to json" do
+        @json = mock("json")
+        @iv_hash = mock("iv_hash")
+        @iv_hash.expects(:to_json).once.returns(@json)
+        @base.expects(:instance_variables_hash).returns(@iv_hash)
+        assert_equal @json, @base.to_json
+      end
+
+      should "not include env in the JSON hash" do
+        @base.env = "FOO"
+        hash = @base.instance_variables_hash
+        assert !hash.has_key?(:env)
+      end
     end
   end
 
@@ -138,21 +162,25 @@ class ConfigTest < Test::Unit::TestCase
       end
 
       should "initialize each configurer and set it to its key" do
+        env = mock('env')
+
         5.times do |i|
           key = "key#{i}"
           klass = mock("klass#{i}")
           instance = mock("instance#{i}")
+          instance.expects(:env=).with(env)
           klass.expects(:new).returns(instance)
           @configures_list << [key, klass]
         end
 
-        Vagrant::Config::Top.new
+        Vagrant::Config::Top.new(env)
       end
 
       should "allow reading via methods" do
         key = "my_foo_bar_key"
         klass = mock("klass")
         instance = mock("instance")
+        instance.stubs(:env=)
         klass.expects(:new).returns(instance)
         Vagrant::Config::Top.configures(key, klass)
 
@@ -196,16 +224,13 @@ class ConfigTest < Test::Unit::TestCase
 
   context "VM configuration" do
     setup do
-      @config = Vagrant::Config::VMConfig.new
-      @username = "bob"
-
-      mock_config do |config|
-        config.ssh.username = @username
-      end
+      @env = mock_environment
+      @config = @env.config.vm
+      @env.config.ssh.username = @username
     end
 
     should "include the stacked proc runner module" do
-      assert @config.class.included_modules.include?(Vagrant::StackedProcRunner)
+      assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
     end
 
     should "add the customize proc to the proc stack" do