vagrantup 0.4.3.dev → 0.5.0

data/test/vagrant/commands/status_test.rb

@@ -1,40 +0,0 @@
-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
-    should "show local status by default" do
-      @instance.expects(:show_local_status).once
-      @instance.expects(:show_global_status).never
-      @instance.execute
-    end
-
-    should "show global status if flagged" do
-      @instance.expects(:show_local_status).never
-      @instance.expects(:show_global_status).once
-      @instance.execute(["--global"])
-    end
-
-    should "show help if too many args are given" do
-      @instance.expects(:show_help).once
-      @instance.execute(["1","2","3"])
-    end
-
-    should "pass the VM name to local status if given" do
-      @instance.expects(:show_local_status).with("foo").once
-      @instance.execute(["foo"])
-    end
-  end
-end

data/test/vagrant/commands/suspend_test.rb

@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CommandsSuspendTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Commands::Suspend
-
-    @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([], :suspend)
-      @instance.execute
-    end
-  end
-
-  context "suspending 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.suspend_single(:foo)
-    end
-
-    should "suspend if its created" do
-      @foo_vm.stubs(:created?).returns(true)
-      @foo_vm.expects(:suspend).once
-      @instance.execute(["foo"])
-    end
-
-    should "do nothing if its not created" do
-      @foo_vm.stubs(:created?).returns(false)
-      @foo_vm.expects(:suspend).never
-      @instance.suspend_single(:foo)
-    end
-  end
-end

data/test/vagrant/commands/up_test.rb

@@ -1,47 +0,0 @@
-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)
-  end
-
-  context "executing" do
-    should "call all or single for the method" do
-      @instance.expects(:all_or_single).with([], :up)
-      @instance.execute
-    end
-  end
-
-  context "upping a single VM" do
-    setup do
-      @vm = mock("vm")
-      @vm.stubs(:env).returns(@env)
-
-      @vms = {: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.up_single(:foo)
-    end
-
-    should "start created VMs" do
-      @vm.stubs(:created?).returns(true)
-      @vm.expects(:start).once
-      @instance.up_single(:foo)
-    end
-
-    should "up non-created VMs" do
-      @vm.stubs(:created?).returns(false)
-      @vm.env.expects(:require_box).once
-      @vm.expects(:up).once
-      @vm.expects(:start).never
-      @instance.up_single(:foo)
-    end
-  end
-end

data/test/vagrant/config_test.rb

@@ -1,287 +0,0 @@
-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
-      result = File.expand_path(@env.config.ssh[:private_key_path], @env.root_path)
-      assert_equal result, @env.config.ssh.private_key_path
-    end
-  end
-
-  context "adding configures" do
-    should "forward the method to the Top class" do
-      key = mock("key")
-      klass = mock("klass")
-      Vagrant::Config::Top.expects(:configures).with(key, klass)
-      Vagrant::Config.configures(key, klass)
-    end
-  end
-
-  context "resetting" do
-    setup do
-      Vagrant::Config.run { |config| }
-      Vagrant::Config.execute!
-    end
-
-    should "return the same config object typically" do
-      config = Vagrant::Config.config
-      assert config.equal?(Vagrant::Config.config)
-    end
-
-    should "create a new object if cleared" do
-      config = Vagrant::Config.config
-      Vagrant::Config.reset!
-      assert !config.equal?(Vagrant::Config.config)
-    end
-
-    should "empty the proc stack" do
-      assert !Vagrant::Config.proc_stack.empty?
-      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 "initializing" do
-    setup do
-      Vagrant::Config.reset!
-    end
-
-    should "add the given block to the proc stack" do
-      proc = Proc.new {}
-      Vagrant::Config.run(&proc)
-      assert_equal [proc], Vagrant::Config.proc_stack
-    end
-
-    should "run the proc stack with the config when execute is called" do
-      Vagrant::Config.expects(:run_procs!).with(Vagrant::Config.config).once
-      Vagrant::Config.execute!
-    end
-
-    should "not be loaded, initially" do
-      assert !Vagrant::Config.config.loaded?
-    end
-
-    should "be loaded after running" do
-      Vagrant::Config.run {}
-      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.is_a?(Vagrant::Config::Top)
-    end
-
-    should "use given configuration object if given" do
-      fake_env = mock("env")
-      config = Vagrant::Config::Top.new(fake_env)
-      result = Vagrant::Config.execute!(config)
-      assert_equal config.env, result.env
-    end
-  end
-
-  context "base class" do
-    setup do
-      @base = Vagrant::Config::Base.new
-    end
-
-    should "forward [] access to methods" do
-      @base.expects(:foo).once
-      @base[:foo]
-    end
-
-    should "return a hash of instance variables" do
-      data = { :foo => "bar", :bar => "baz" }
-
-      data.each do |iv, value|
-        @base.instance_variable_set("@#{iv}".to_sym, value)
-      end
-
-      result = @base.instance_variables_hash
-      assert_equal data.length, result.length
-
-      data.each do |iv, value|
-        assert_equal value, result[iv]
-      end
-    end
-
-    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
-
-  context "top config class" do
-    setup do
-      @configures_list = []
-      Vagrant::Config::Top.stubs(:configures_list).returns(@configures_list)
-    end
-
-    context "adding configure keys" do
-      setup do
-        @key = "top_config_foo"
-        @klass = mock("klass")
-      end
-
-      should "add key and klass to configures list" do
-        @configures_list.expects(:<<).with([@key, @klass])
-        Vagrant::Config::Top.configures(@key, @klass)
-      end
-    end
-
-    context "configuration keys on instance" do
-      setup do
-        @configures_list.clear
-      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(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)
-
-        config = Vagrant::Config::Top.new
-        assert_equal instance, config.send(key)
-      end
-    end
-
-    context "loaded status" do
-      setup do
-        @top= Vagrant::Config::Top.new
-      end
-
-      should "not be loaded by default" do
-        assert !@top.loaded?
-      end
-
-      should "be loaded after calling loaded!" do
-        @top.loaded!
-        assert @top.loaded?
-      end
-    end
-  end
-
-  context "vagrant configuration" do
-    setup do
-      @config = Vagrant::Config::VagrantConfig.new
-    end
-
-    should "return nil if home is nil" do
-      File.expects(:expand_path).never
-      assert @config.home.nil?
-    end
-
-    should "expand the path if home is not nil" do
-      @config.home = "foo"
-      File.expects(:expand_path).with("foo").once.returns("result")
-      assert_equal "result", @config.home
-    end
-  end
-
-  context "VM configuration" do
-    setup do
-      @env = mock_environment
-      @config = @env.config.vm
-      @env.config.ssh.username = @username
-    end
-
-    context "defining VMs" do
-      should "store the proc by name but not run it" do
-        foo = mock("proc")
-        foo.expects(:call).never
-
-        proc = Proc.new { foo.call }
-        @config.define(:name, &proc)
-        assert @config.defined_vms[:name].proc_stack.include?(proc)
-      end
-
-      should "store the options" do
-        @config.define(:name, :set => true)
-        assert @config.defined_vms[:name].options[:set]
-      end
-
-      should "not have multi-VMs by default" do
-        assert !@config.has_multi_vms?
-      end
-
-      should "have multi-VMs once one is specified" do
-        @config.define(:foo) {}
-        assert @config.has_multi_vms?
-      end
-    end
-
-    context "customizing" do
-      should "include the stacked proc runner module" do
-        assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
-      end
-
-      should "add the customize proc to the proc stack" do
-        proc = Proc.new {}
-        @config.customize(&proc)
-        assert_equal [proc], @config.proc_stack
-      end
-    end
-
-    context "uid/gid" do
-      should "return the shared folder UID if set" do
-        @config.shared_folder_uid = "foo"
-        assert_equal "foo", @config.shared_folder_uid
-      end
-
-      should "return the SSH username if UID not set" do
-        @config.shared_folder_uid = nil
-        assert_equal @username, @config.shared_folder_uid
-      end
-
-      should "return the shared folder GID if set" do
-        @config.shared_folder_gid = "foo"
-        assert_equal "foo", @config.shared_folder_gid
-      end
-
-      should "return the SSH username if GID not set" do
-        @config.shared_folder_gid = nil
-        assert_equal @username, @config.shared_folder_gid
-      end
-    end
-  end
-end

data/test/vagrant/downloaders/base_test.rb

@@ -1,28 +0,0 @@
-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
-      @env = mock_environment
-      @base = Vagrant::Downloaders::Base.new(@env)
-    end
-
-    should "implement prepare which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:prepare)
-        @base.prepare("source")
-      end
-    end
-
-    should "implement download! which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:download!)
-        @base.download!("source", "destination")
-      end
-    end
-  end
-end