vagrantup 0.4.3.dev → 0.5.0

data/test/vagrant/commands/init_test.rb

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

@@ -1,104 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CommandsPackageTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::Package
-
-    @env = mock_environment
-    @instance = @klass.new(@env)
-  end
-
-  context "executing" do
-    should "package base if a base is given" do
-      @instance.expects(:package_base).once
-      @instance.execute(["--base","foo"])
-    end
-
-    should "package single if no name is given" do
-      @instance.expects(:package_single).with(nil).once
-      @instance.execute
-    end
-
-    should "package single if a name is given" do
-      @instance.expects(:package_single).with("foo").once
-      @instance.execute(["foo"])
-    end
-  end
-
-  context "packaging base" do
-    should "error and exit if no VM is found" do
-      Vagrant::VM.expects(:find).with("foo", @instance.env).returns(nil)
-      @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => "foo").once
-      @instance.execute(["--base", "foo"])
-    end
-
-    should "package the VM like any other VM" do
-      vm = mock("vm")
-      Vagrant::VM.expects(:find).with("foo", @instance.env).returns(vm)
-      @instance.expects(:package_vm).with(vm).once
-      @instance.execute(["--base", "foo"])
-    end
-  end
-
-  context "packaging a single VM" do
-    setup do
-      @vm = mock("vm")
-      @vm.stubs(:created?).returns(true)
-
-      @vms = {:bar => @vm}
-      @env.stubs(:vms).returns(@vms)
-      @env.stubs(:multivm?).returns(false)
-    end
-
-    should "error and exit if no name is given in a multi-vm env" do
-      @env.stubs(:multivm?).returns(true)
-      @instance.expects(:error_and_exit).with(:package_multivm).once
-      @instance.package_single(nil)
-    end
-
-    should "error and exit if the VM doesn't exist" do
-      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
-      @instance.package_single(:foo)
-    end
-
-    should "error and exit if the VM is not created" do
-      @vm.stubs(:created?).returns(false)
-      @instance.expects(:error_and_exit).with(:environment_not_created).once
-      @instance.package_single(:bar)
-    end
-
-    should "use the first VM is no name is given in a single VM environment" do
-      @instance.expects(:package_vm).with(@vm).once
-      @instance.package_single(nil)
-    end
-
-    should "package the VM" do
-      @instance.expects(:package_vm).with(@vm).once
-      @instance.package_single(:bar)
-    end
-  end
-
-  context "packaging a VM" do
-    setup do
-      @vm = mock("vm")
-      @vm.stubs(:powered_off?).returns(true)
-
-      @options = {}
-      @instance.stubs(:options).returns(@options)
-    end
-
-    should "error and exit if VM is not powered off" do
-      @vm.stubs(:powered_off?).returns(false)
-      @instance.expects(:error_and_exit).with(:vm_power_off_to_package).once
-      @instance.package_vm(@vm)
-    end
-
-    should "package the VM with the proper arguments" do
-      @options[:output] = "foo.box"
-      @options[:include] = :bar
-
-      @vm.expects(:package).with(@options).once
-      @instance.package_vm(@vm)
-    end
-  end
-end

data/test/vagrant/commands/provision_test.rb

@@ -1,60 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CommandsProvisionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::Provision
-    @env = mock_environment
-    @instance = @klass.new(@env)
-  end
-
-  context "executing" do
-    should "provision all if no name is given" do
-      @instance.expects(:all_or_single).with([], :provision).once
-      @instance.execute
-    end
-  end
-
-  context "provisioning a single VM" do
-    setup do
-      @foo_vm = mock("vm")
-      @foo_vm.stubs(:env).returns(@env)
-      @foo_vm.stubs(:created?).returns(true)
-
-      @vm_for_real = mock("vm for real")
-      @foo_vm.stubs(:vm).returns(@vm_for_real)
-      vms = { :foo => @foo_vm }
-      @env.stubs(:vms).returns(vms)
-    end
-
-    should "error and exit if the VM doesn't exist" do
-      @env.stubs(:vms).returns({})
-      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => 'foo').once
-      @instance.execute(["foo"])
-    end
-
-    should "reload if it's running" do
-      @vm_for_real.stubs(:running?).returns(true)
-      @foo_vm.expects(:provision).once
-      @instance.execute(["foo"])
-    end
-
-    should "do log to info if it's not running" do
-      logger = mock("logger")
-      logger.expects(:info)
-      @env.stubs(:logger).returns(logger)
-      @vm_for_real.stubs(:running?).returns(false)
-      @foo_vm.expects(:provision).never
-      @instance.execute(["foo"])
-    end
-
-    should "do log to info if it's not created" do
-      logger = mock("logger")
-      logger.expects(:info)
-      @env.stubs(:logger).returns(logger)
-      @foo_vm.stubs(:created?).returns(false)
-      @foo_vm.expects(:provision).never
-      @instance.execute(["foo"])
-    end
-  end
-
-end

data/test/vagrant/commands/reload_test.rb

@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CommandsReloadTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::Reload
-
-    @env = mock_environment
-    @instance = @klass.new(@env)
-  end
-
-  context "executing" do
-    should "call all or single for the method" do
-      @instance.expects(:all_or_single).with([], :reload)
-      @instance.execute
-    end
-  end
-
-  context "reloading a single VM" do
-    setup do
-      @foo_vm = mock("vm")
-      @foo_vm.stubs(:env).returns(@env)
-      vms = { :foo => @foo_vm }
-      @env.stubs(:vms).returns(vms)
-    end
-
-    should "error and exit if the VM doesn't exist" do
-      @env.stubs(:vms).returns({})
-      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
-      @instance.reload_single(:foo)
-    end
-
-    should "reload if its created" do
-      @foo_vm.stubs(:created?).returns(true)
-      @foo_vm.expects(:reload).once
-      @instance.execute(["foo"])
-    end
-
-    should "do nothing if its not created" do
-      @foo_vm.stubs(:created?).returns(false)
-      @foo_vm.expects(:reload).never
-      @instance.reload_single(:foo)
-    end
-  end
-end

data/test/vagrant/commands/resume_test.rb

@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CommandsResumeTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::Resume
-
-    @env = mock_environment
-    @instance = @klass.new(@env)
-  end
-
-  context "executing" do
-    should "call all or single for the method" do
-      @instance.expects(:all_or_single).with([], :resume)
-      @instance.execute
-    end
-  end
-
-  context "resuming a single VM" do
-    setup do
-      @foo_vm = mock("vm")
-      @foo_vm.stubs(:env).returns(@env)
-      vms = { :foo => @foo_vm }
-      @env.stubs(:vms).returns(vms)
-    end
-
-    should "error and exit if the VM doesn't exist" do
-      @env.stubs(:vms).returns({})
-      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
-      @instance.resume_single(:foo)
-    end
-
-    should "resume if its created" do
-      @foo_vm.stubs(:created?).returns(true)
-      @foo_vm.expects(:resume).once
-      @instance.execute(["foo"])
-    end
-
-    should "do nothing if its not created" do
-      @foo_vm.stubs(:created?).returns(false)
-      @foo_vm.expects(:resume).never
-      @instance.resume_single(:foo)
-    end
-  end
-end

data/test/vagrant/commands/ssh_config_test.rb

@@ -1,77 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CommandsSSHConfigTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::SSHConfig
-
-    @env = mock_environment
-    @env.stubs(:require_root_path)
-    @instance = @klass.new(@env)
-  end
-
-  context "executing" do
-    setup do
-      @instance.stubs(:show_single)
-    end
-
-    should "require root path" do
-      @env.expects(:require_root_path).once
-      @instance.execute
-    end
-
-    should "call show_single with given argument" do
-      @instance.expects(:show_single).with("foo").once
-      @instance.execute(["foo"])
-    end
-  end
-
-  context "showing a single entry" do
-    setup do
-      @ssh = mock("ssh")
-      @ssh.stubs(:port).returns(2197)
-
-      @bar = mock("vm")
-      @bar.stubs(:env).returns(mock_environment)
-      @bar.stubs(:ssh).returns(@ssh)
-
-      @vms = {:bar => @bar}
-      @env.stubs(:multivm?).returns(true)
-      @env.stubs(:vms).returns(@vms)
-
-      @data = {
-        :host_key => "vagrant",
-        :ssh_user => @bar.env.config.ssh.username,
-        :ssh_port => @bar.ssh.port,
-        :private_key_path => @bar.env.config.ssh.private_key_path
-      }
-
-      @instance.stubs(:puts)
-    end
-
-    should "error if name is nil and multivm" do
-      @env.stubs(:multivm?).returns(true)
-      @instance.expects(:error_and_exit).with(:ssh_config_multivm).once
-      @instance.show_single(nil)
-    end
-
-    should "error if the VM is not found" do
-      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => "foo").once
-      @instance.show_single("foo")
-    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.show_single(:bar)
-    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(["bar", "--host", host])
-    end
-  end
-end

data/test/vagrant/commands/ssh_test.rb

@@ -1,129 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CommandsSSHTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::SSH
-
-    @env = mock_environment
-    @instance = @klass.new(@env)
-  end
-
-  context "executing" do
-    should "connect to the given argument" do
-      @instance.expects(:ssh_connect).with("foo").once
-      @instance.execute(["foo"])
-    end
-
-    should "connect with nil name if none is given" do
-      @instance.expects(:ssh_connect).with(nil).once
-      @instance.execute
-    end
-
-    should "execute if commands are given" do
-      @env.stubs(:vms).returns(:foo => mock("foo"))
-      @instance.expects(:ssh_execute).with("foo", @env.vms[:foo]).once
-      @instance.execute(["foo","-e","bar"])
-    end
-
-    should "execute over every VM if none is specified with a command" do
-      vms = {
-        :foo => mock("foo"),
-        :bar => mock("bar")
-      }
-
-      @env.stubs(:vms).returns(vms)
-      vms.each do |key, vm|
-        @instance.expects(:ssh_execute).with(key, vm).once
-      end
-
-      @instance.execute(["--execute", "bar"])
-    end
-  end
-
-  context "ssh executing" do
-    setup do
-      @name = :foo
-
-      @ssh_conn = mock("connection")
-      @ssh_conn.stubs(:exec!)
-
-      @ssh = mock("ssh")
-      @ssh.stubs(:execute).yields(@ssh_conn)
-
-      @vm = mock("vm")
-      @vm.stubs(:created?).returns(true)
-      @vm.stubs(:ssh).returns(@ssh)
-      @vm.stubs(:env).returns(@env)
-    end
-
-    should "error and exit if invalid VM given" do
-      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => @name).once
-      @instance.ssh_execute(@name, nil)
-    end
-
-    should "error and exit if VM isn't created" do
-      @vm.stubs(:created?).returns(false)
-      @instance.expects(:error_and_exit).with(:environment_not_created).once
-      @instance.ssh_execute(@name, @vm)
-    end
-
-    should "execute each command" do
-      commands = [:a,:b,:c]
-      @instance.stubs(:options).returns(:execute => commands)
-      commands.each do |cmd|
-        @ssh_conn.expects(:exec!).with(cmd).once
-      end
-
-      @instance.ssh_execute(@name, @vm)
-    end
-  end
-
-  context "ssh connecting" do
-    setup do
-      @vm = mock("vm")
-      @vm.stubs(:created?).returns(true)
-
-      @vms = {:bar => @vm}
-      @env.stubs(:vms).returns(@vms)
-      @env.stubs(:multivm?).returns(false)
-    end
-
-    should "error and exit if no VM is specified and multivm and no primary VM" do
-      @env.stubs(:multivm?).returns(true)
-      @env.stubs(:primary_vm).returns(nil)
-      @instance.expects(:error_and_exit).with(:ssh_multivm).once
-      @instance.ssh_connect(nil)
-    end
-
-    should "use the primary VM if it exists and no name is specified" do
-      vm = mock("vm")
-      ssh = mock("ssh")
-      vm.stubs(:created?).returns(true)
-      vm.stubs(:ssh).returns(ssh)
-
-      @env.stubs(:multivm?).returns(true)
-      @env.stubs(:primary_vm).returns(vm)
-      ssh.expects(:connect).once
-      @instance.ssh_connect(nil)
-    end
-
-    should "error and exit if VM is nil" do
-      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
-      @instance.ssh_connect(:foo)
-    end
-
-    should "error and exit if VM isn't created" do
-      @vm.stubs(:created?).returns(false)
-      @instance.expects(:error_and_exit).with(:environment_not_created).once
-      @instance.ssh_connect(:bar)
-    end
-
-    should "ssh connect" do
-      ssh = mock("ssh")
-      @vm.stubs(:ssh).returns(ssh)
-      ssh.expects(:connect)
-
-      @instance.ssh_connect(:bar)
-    end
-  end
-end