vagrantup 1.0.7 → 1.1.0

data/test/unit_legacy/vagrant/util/busy_test.rb

@@ -1,106 +0,0 @@
-require "test_helper"
-
-class BusyUtilTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Util::Busy
-  end
-
-  context "registering" do
-    setup do
-      @callback = lambda { puts "FOO" }
-      Signal.stubs(:trap)
-    end
-
-    teardown do
-      @klass.registered.clear
-    end
-
-    should "trap the signal on the first registration" do
-      Signal.expects(:trap).with("INT").once
-      @klass.register(@callback)
-      @klass.register(lambda { puts "BAR" })
-    end
-
-    should "not register the same callback multiple times" do
-      @klass.register(@callback)
-      @klass.register(@callback)
-      @klass.register(@callback)
-      assert_equal 1, @klass.registered.length
-      assert_equal @callback, @klass.registered.first
-    end
-  end
-
-  context "unregistering" do
-    setup do
-      Signal.stubs(:trap)
-
-      @callback = lambda { puts "FOO" }
-    end
-
-    teardown do
-      @klass.registered.clear
-    end
-
-    should "remove the callback and set the trap to DEFAULT when removing final" do
-      @klass.register(@callback)
-      Signal.expects(:trap).with("INT", "DEFAULT").once
-      @klass.unregister(@callback)
-      assert @klass.registered.empty?
-    end
-
-    should "not reset signal trap if not final callback" do
-      @klass.register(@callback)
-      @klass.register(lambda { puts "BAR" })
-      Signal.expects(:trap).never
-      @klass.unregister(@callback)
-    end
-  end
-
-  context "marking for busy" do
-    setup do
-      @callback = lambda { "foo" }
-    end
-
-    should "register, call the block, then unregister" do
-      waiter = mock("waiting")
-      proc = lambda { waiter.ping! }
-
-      seq = sequence('seq')
-      @klass.expects(:register).with(@callback).in_sequence(seq)
-      waiter.expects(:ping!).in_sequence(seq)
-      @klass.expects(:unregister).with(@callback).in_sequence(seq)
-
-      @klass.busy(@callback, &proc)
-    end
-
-    should "unregister callback even if block raises exception" do
-      waiter = mock("waiting")
-      proc = lambda { waiter.ping! }
-
-      seq = sequence('seq')
-      @klass.expects(:register).with(@callback).in_sequence(seq)
-      waiter.expects(:ping!).raises(Exception.new("uh oh!")).in_sequence(seq)
-      @klass.expects(:unregister).with(@callback).in_sequence(seq)
-
-      assert_raises(Exception) { @klass.busy(@callback, &proc) }
-    end
-  end
-
-  context "firing callbacks" do
-    setup do
-      Signal.stubs(:trap)
-    end
-
-    teardown do
-      @klass.registered.clear
-    end
-
-    should "just call the registered callbacks" do
-      waiting = mock("waiting")
-      waiting.expects(:ping!).once
-
-      @klass.register(lambda { waiting.ping! })
-      @klass.fire_callbacks
-    end
-  end
-end

data/test/unit_legacy/vagrant/util/counter_test.rb

@@ -1,29 +0,0 @@
-require "test_helper"
-
-class CounterUtilTest < Test::Unit::TestCase
-  setup do
-    @klass = Class.new do
-      extend Vagrant::Util::Counter
-    end
-  end
-
-  context "basic counter" do
-    should "get and update the counter" do
-      assert_equal 1, @klass.get_and_update_counter
-      assert_equal 2, @klass.get_and_update_counter
-    end
-  end
-
-  context "multiple classes with a counter" do
-    setup do
-      @klass2 = Class.new do
-        extend Vagrant::Util::Counter
-      end
-    end
-
-    should "not affect other classes" do
-      assert_equal 1, @klass.get_and_update_counter
-      assert_equal 1, @klass2.get_and_update_counter
-    end
-  end
-end

data/test/unit_legacy/vagrant/util/platform_test.rb

@@ -1,18 +0,0 @@
-require "test_helper"
-
-class PlatformTest < Test::Unit::TestCase
-  context "file options" do
-    should "include add binary bit to options on windows platform" do
-      # This constant is not defined on non-windows platforms, so define it here
-      File::BINARY = 4096 unless defined?(File::BINARY)
-
-      Vagrant::Util::Platform.stubs(:windows?).returns(true)
-      assert_equal Vagrant::Util::Platform.tar_file_options, File::CREAT|File::EXCL|File::WRONLY|File::BINARY
-    end
-
-    should "not include binary bit on other platforms" do
-      Vagrant::Util::Platform.stubs(:windows?).returns(false)
-      assert_equal Vagrant::Util::Platform.tar_file_options, File::CREAT|File::EXCL|File::WRONLY
-    end
-  end
-end

data/test/unit_legacy/vagrant/util/stacked_proc_runner_test.rb

@@ -1,43 +0,0 @@
-require "test_helper"
-
-class StackedProcRunnerUtilTest < Test::Unit::TestCase
-  class TestClass
-    include Vagrant::Util::StackedProcRunner
-  end
-
-  setup do
-    @instance = TestClass.new
-    @instance.proc_stack.clear
-  end
-
-  should "not run the procs right away" do
-    obj = mock("obj")
-    obj.expects(:foo).never
-    @instance.push_proc { |config| obj.foo }
-    @instance.push_proc { |config| obj.foo }
-    @instance.push_proc { |config| obj.foo }
-  end
-
-  should "run the blocks when run_procs! is ran" do
-    obj = mock("obj")
-    obj.expects(:foo).times(2)
-    @instance.push_proc { obj.foo }
-    @instance.push_proc { obj.foo }
-    @instance.run_procs!
-  end
-
-  should "run the blocks with the same arguments" do
-    passed_config = mock("config")
-    @instance.push_proc { |config| assert passed_config.equal?(config) }
-    @instance.push_proc { |config| assert passed_config.equal?(config) }
-    @instance.run_procs!(passed_config)
-  end
-
-  should "not clear the blocks after running" do
-    obj = mock("obj")
-    obj.expects(:foo).times(2)
-    @instance.push_proc { obj.foo }
-    @instance.run_procs!
-    @instance.run_procs!
-  end
-end

data/test/unit_legacy/vagrant/util/template_renderer_test.rb

@@ -1,145 +0,0 @@
-require "test_helper"
-
-class TemplateRendererUtilTest < Test::Unit::TestCase
-  context "initializing" do
-    should "set the template to the given argument" do
-      r = Vagrant::Util::TemplateRenderer.new("foo")
-      assert_equal "foo", r.template
-    end
-
-    should "set any additional variables" do
-      r = Vagrant::Util::TemplateRenderer.new("foo", {:bar => :baz})
-      assert_equal :baz, r.bar
-    end
-  end
-
-  context "rendering" do
-    setup do
-      @template = "foo"
-      @r = Vagrant::Util::TemplateRenderer.new(@template)
-      @r.stubs(:full_template_path).returns(@template + "!")
-
-      @contents = "bar"
-
-      @file = mock("file")
-      @file.stubs(:read).returns(@contents)
-      File.stubs(:open).yields(@file)
-    end
-
-    should "open the template file for reading" do
-      File.expects(:open).with(@r.full_template_path, 'r').once
-      @r.render
-    end
-
-    should "set the template to the file contents, render, then set it back" do
-      result = "bar"
-
-      template_seq = sequence("template_seq")
-      @r.expects(:template=).with(@file.read).in_sequence(template_seq)
-      @r.expects(:render_string).returns(result).in_sequence(template_seq)
-      @r.expects(:template=).with(@template).in_sequence(template_seq)
-      assert_equal result, @r.render
-    end
-
-    should "render the ERB file in the context of the renderer" do
-      result = "bar"
-      template = "<%= foo %>"
-      @r.foo = result
-      @file.expects(:read).returns(template)
-      assert_equal result, @r.render
-    end
-  end
-
-  context "rendering as string" do
-    setup do
-      @result = "foo"
-      @erb = mock("erb")
-      @erb.stubs(:result).returns(@result)
-
-      @r = Vagrant::Util::TemplateRenderer.new("foo")
-    end
-
-    should "simply render the template as a string" do
-      Erubis::Eruby.expects(:new).with(@r.template, :trim => true).returns(@erb)
-      @erb.expects(:result).returns(@result)
-      assert_equal @result, @r.render_string
-    end
-  end
-
-  context "the full template path" do
-    setup do
-      @template = "foo"
-      @r = Vagrant::Util::TemplateRenderer.new(@template)
-    end
-
-    should "be the ERB file in the templates directory" do
-      result = Vagrant.source_root.join("templates", "#{@template}.erb")
-      assert_equal result.to_s, @r.full_template_path
-    end
-
-    should "remove duplicate path separators" do
-      @r.template = "foo///bar"
-      result = Vagrant.source_root.join("templates", "foo", "bar.erb")
-      assert_equal result.to_s, @r.full_template_path
-    end
-  end
-
-  context "class methods" do
-    context "render_with method" do
-      setup do
-        @template = "foo"
-        @r = Vagrant::Util::TemplateRenderer.new(@template)
-        @r.stubs(:render)
-
-        @method = :rawr
-
-        Vagrant::Util::TemplateRenderer.stubs(:new).with(@template, {}).returns(@r)
-      end
-
-      should "use the second argument as the template" do
-        Vagrant::Util::TemplateRenderer.expects(:new).with(@template, {}).returns(@r)
-        Vagrant::Util::TemplateRenderer.render_with(@method, @template)
-      end
-
-      should "send in additional argument to the renderer" do
-        data = {:hey => :foo}
-        Vagrant::Util::TemplateRenderer.expects(:new).with(@template, data).returns(@r)
-        Vagrant::Util::TemplateRenderer.render_with(@method, @template, data)
-      end
-
-      should "yield a block if given with the renderer as the argument" do
-        @r.expects(:yielded=).with(true).once
-        Vagrant::Util::TemplateRenderer.render_with(@method, @template) do |r|
-          r.yielded = true
-        end
-      end
-
-      should "render the result using the given method" do
-        result = mock('result')
-        @r.expects(@method).returns(result)
-        assert_equal result, Vagrant::Util::TemplateRenderer.render_with(@method, @template)
-      end
-
-      should "convert the given method to a sym prior to calling" do
-        @r.expects(@method.to_sym).returns(nil)
-        Vagrant::Util::TemplateRenderer.render_with(@method.to_s, @template)
-      end
-    end
-
-    context "render method" do
-      should "call render_with the render! method" do
-        args = ["foo", "bar", "baz"]
-        Vagrant::Util::TemplateRenderer.expects(:render_with).with(:render, *args)
-        Vagrant::Util::TemplateRenderer.render(*args)
-      end
-    end
-
-    context "render_string method" do
-      should "call render_with the render! method" do
-        args = ["foo", "bar", "baz"]
-        Vagrant::Util::TemplateRenderer.expects(:render_with).with(:render_string, *args)
-        Vagrant::Util::TemplateRenderer.render_string(*args)
-      end
-    end
-  end
-end

data/test/unit_legacy/vagrant/vm_test.rb

@@ -1,300 +0,0 @@
-require "test_helper"
-
-class VMTest < Test::Unit::TestCase
-  setup do
-    @env = vagrant_env
-  end
-
-  context "finding a VM" do
-    should "return return an uncreated VM object if the VM is not found" do
-      VirtualBox::VM.expects(:find).returns(nil)
-      result = Vagrant::VM.find("foo")
-      assert result.is_a?(Vagrant::VM)
-      assert !result.created?
-    end
-
-    should "return a Vagrant::VM object for that VM if found" do
-      VirtualBox::VM.expects(:find).with("foo").returns("bar")
-      result = Vagrant::VM.find("foo", @env)
-      assert result.is_a?(Vagrant::VM)
-      assert_equal "bar", result.vm
-    end
-  end
-
-  context "vagrant VM instance" do
-    setup do
-      @vm_name = "foo"
-      @mock_vm = mock("vm")
-      @mock_vm.stubs(:running?).returns(false)
-      @vm = Vagrant::VM.new(:env => @env, :vm => @mock_vm, :name => @vm_name)
-      @mock_vm.stubs(:uuid).returns("foo")
-    end
-
-    context "checking if created" do
-      should "return true if the VM object is not nil" do
-        @vm.stubs(:vm).returns(:foo)
-        assert @vm.created?
-      end
-
-      should "return false if the VM object is nil" do
-        @vm.stubs(:vm).returns(nil)
-        assert !@vm.created?
-      end
-    end
-
-    context "setting the VM" do
-      setup do
-        @raw_vm = mock("vm")
-        @raw_vm.stubs(:uuid).returns("foobar")
-      end
-
-      should "set the VM" do
-        @vm.vm = @raw_vm
-        assert_equal @raw_vm, @vm.vm
-      end
-
-      should "add the VM to the active list" do
-        assert @env.local_data.empty?
-        @vm.vm = @raw_vm
-        assert_equal @raw_vm.uuid, @env.local_data[:active][@vm.name.to_s]
-      end
-
-      should "remove the VM from the active list if nil is given" do
-        @env.local_data[:active] = { @vm.name.to_s => "foo" }
-
-        assert @env.local_data[:active].has_key?(@vm.name.to_s) # sanity
-        @vm.vm = nil
-
-        # This becomes empty because vm= will commit the local data which
-        # actually prunes out the empty values.
-        assert @env.local_data.empty?
-      end
-    end
-
-    context "accessing the SSH object" do
-      setup do
-        # Reset this to nil to force the reload
-        @vm.instance_variable_set(:@ssh, nil)
-
-        @ssh = mock("ssh")
-        Vagrant::SSH.stubs(:new).returns(@ssh)
-      end
-
-      should "load it the first time, and only load it once" do
-        Vagrant::SSH.expects(:new).with(@vm.env).once.returns(@ssh)
-        @vm.ssh
-        @vm.ssh
-        @vm.ssh
-      end
-    end
-
-    context "loading associated system" do
-      should "error and exit if system is not specified" do
-        @vm.env.config.vm.system = nil
-
-        assert_raises(Vagrant::Errors::VMSystemError) {
-          @vm.load_system!
-        }
-      end
-
-      should "load the given system if specified" do
-        fake_class = Class.new(Vagrant::Systems::Base)
-
-        assert_nothing_raised { @vm.load_system!(fake_class) }
-        assert @vm.system.is_a?(fake_class)
-      end
-
-      context "with a class" do
-        should "initialize class if given" do
-          @vm.env.config.vm.system = Vagrant::Systems::Linux
-
-          assert_nothing_raised { @vm.load_system!}
-          assert @vm.system.is_a?(Vagrant::Systems::Linux)
-        end
-
-        should "raise error if class has invalid parent" do
-          @vm.env.config.vm.system = Class.new
-          assert_raises(Vagrant::Errors::VMSystemError) {
-            @vm.load_system!
-          }
-        end
-      end
-
-      context "with a symbol" do
-        should "initialize proper symbols" do
-          valid = {
-            :linux => Vagrant::Systems::Linux,
-            :solaris => Vagrant::Systems::Solaris
-          }
-
-          valid.each do |symbol, klass|
-            @vm.env.config.vm.system = symbol
-
-            assert_nothing_raised { @vm.load_system! }
-            assert @vm.system.is_a?(klass)
-            assert_equal @vm, @vm.system.vm
-          end
-        end
-
-        should "error and exit with invalid symbol" do
-          @vm.env.config.vm.system = :shall_never_exist
-
-          assert_raises(Vagrant::Errors::VMSystemError) {
-            @vm.load_system!
-          }
-        end
-      end
-
-      context "loading the distro" do
-        setup do
-          @vm.vm.stubs(:running?).returns(true)
-        end
-
-        should "not replace the distro if it is nil" do
-          @vm.env.config.vm.system = Class.new(Vagrant::Systems::Base)
-
-          @vm.load_system!
-          assert @vm.system.is_a?(@vm.env.config.vm.system)
-        end
-
-        should "replace the distro if it is not nil" do
-          @vm.env.config.vm.system = Class.new(Vagrant::Systems::Base) do
-            def distro_dispatch
-              :linux
-            end
-          end
-
-          @vm.load_system!
-          assert @vm.system.is_a?(Vagrant::Systems::Linux)
-        end
-      end
-    end
-
-    context "uuid" do
-      should "call UUID on VM object" do
-        uuid = mock("uuid")
-        @mock_vm.expects(:uuid).once.returns(uuid)
-        assert_equal uuid, @vm.uuid
-      end
-
-      should "return nil if vm is nil" do
-        @vm.expects(:vm).returns(nil)
-        assert @vm.uuid.nil?
-      end
-    end
-
-    context "reloading" do
-      should "load the same VM and set it" do
-        new_vm = mock("vm")
-        VirtualBox::VM.expects(:find).with(@mock_vm.uuid).returns(new_vm)
-        @vm.reload!
-        assert_equal new_vm, @vm.vm
-      end
-    end
-
-    context "packaging" do
-      should "execute the package action" do
-        @vm.env.actions.expects(:run).once.with() do |action, options|
-          assert_equal :package, action
-          assert_equal :bar, options[:foo]
-          true
-        end
-
-        @vm.package(:foo => :bar)
-      end
-    end
-
-    context "upping" do
-      should "execute the up action" do
-        @vm.env.actions.expects(:run).with(:up, nil).once
-        @vm.up
-      end
-
-      should "forward options to the action sequence" do
-        @vm.env.actions.expects(:run).with(:up, :foo => :bar).once
-        @vm.up(:foo => :bar)
-      end
-    end
-
-    context "halting" do
-      should "execute the halt action" do
-        @vm.env.actions.expects(:run).with(:halt, :foo => :bar).once
-        @vm.halt({:foo => :bar})
-      end
-    end
-
-    context "reloading action" do
-      should "execute the reload action" do
-        @vm.env.actions.expects(:run).with(:reload).once
-        @vm.reload
-      end
-    end
-
-    context "provisioning" do
-      should "execute the provision action" do
-        @vm.env.actions.expects(:run).with(:provision).once
-        @vm.provision
-      end
-    end
-
-    context "destroying" do
-      should "execute the destroy action" do
-        @vm.env.actions.expects(:run).with(:destroy).once
-        @vm.destroy
-      end
-    end
-
-    context "suspending" do
-      should "execute the suspend action" do
-        @vm.env.actions.expects(:run).with(:suspend).once
-        @vm.suspend
-      end
-    end
-
-    context "resuming" do
-      should "execute the resume action" do
-        @vm.env.actions.expects(:run).with(:resume).once
-        @vm.resume
-      end
-    end
-
-    context "starting" do
-      setup do
-        @mock_vm.stubs(:running?).returns(false)
-        @mock_vm.stubs(:saved?).returns(false)
-        @mock_vm.stubs(:accessible?).returns(true)
-      end
-
-      should "not do anything if the VM is already running" do
-        @mock_vm.stubs(:running?).returns(true)
-        @vm.expects(:execute!).never
-        @vm.start
-      end
-
-      should "execute the resume action if saved" do
-        @mock_vm.expects(:saved?).returns(true)
-        @vm.expects(:resume).once
-        @vm.env.actions.expects(:run).with(:start, nil).never
-        @vm.start
-      end
-
-      should "execute the start action" do
-        @vm.env.actions.expects(:run).with(:start, nil).once
-        @vm.start
-      end
-
-      should "forward options to the action sequence" do
-        @vm.env.actions.expects(:run).with(:start, :foo => :bar).once
-        @vm.start(:foo => :bar)
-      end
-
-      should "raise an exception if the VM is not accessible" do
-        @mock_vm.stubs(:accessible?).returns(false)
-
-        assert_raises(Vagrant::Errors::VMInaccessible) {
-          @vm.start
-        }
-      end
-    end
-  end
-end