vagrant 0.4.2 → 0.5.0

data/test/vagrant/actions/vm/network_test.rb

@@ -1,291 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class NetworkTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Network)
-    @runner.stubs(:system).returns(linux_system(@vm))
-
-    @interfaces = []
-    VirtualBox::Global.global.host.stubs(:network_interfaces).returns(@interfaces)
-  end
-
-  def mock_interface(options=nil)
-    options = {
-      :interface_type => :host_only,
-      :name => "foo"
-    }.merge(options || {})
-
-    interface = mock("interface")
-    options.each do |k,v|
-      interface.stubs(k).returns(v)
-    end
-
-    @interfaces << interface
-    interface
-  end
-
-  context "preparing" do
-    should "verify no bridge collisions for each network enabled" do
-      @runner.env.config.vm.network("foo")
-      @action.expects(:verify_no_bridge_collision).once.with() do |options|
-        assert_equal "foo", options[:ip]
-        true
-      end
-
-      @action.prepare
-    end
-  end
-
-  context "before destroy" do
-    setup do
-      @network_adapters = []
-      @vm.stubs(:network_adapters).returns(@network_adapters)
-    end
-
-    def stub_interface(length=5)
-      interface = mock("interface")
-      adapter = mock("adapter")
-      adapter.stubs(:host_interface_object).returns(interface)
-      interface.stubs(:attached_vms).returns(Array.new(length))
-
-      @network_adapters << adapter
-      interface
-    end
-
-    should "destroy only the unused network interfaces" do
-      stub_interface(5)
-      stub_interface(7)
-      results = [stub_interface(1), stub_interface(1)]
-
-      results.each do |result|
-        result.expects(:destroy).once
-      end
-
-      @action.before_destroy
-    end
-  end
-
-  context "before boot" do
-    setup do
-      @action.stubs(:enable_network?).returns(false)
-    end
-
-    should "do nothing if network should not be enabled" do
-      @action.expects(:assign_network).never
-      @action.before_boot
-    end
-
-    should "assign the network if host only networking is enabled" do
-      @action.stubs(:enable_network?).returns(true)
-      @action.expects(:assign_network).once
-      @action.before_boot
-    end
-  end
-
-  context "after boot" do
-    setup do
-      @runner.env.config.vm.network("foo")
-      @action.stubs(:enable_network?).returns(true)
-    end
-
-    should "prepare the host only network, then enable them" do
-      run_seq = sequence("run")
-      @runner.system.expects(:prepare_host_only_network).once.in_sequence(run_seq)
-      @runner.system.expects(:enable_host_only_network).once.in_sequence(run_seq)
-      @action.after_boot
-    end
-
-    should "do nothing if network is not enabled" do
-      @action.stubs(:enable_network?).returns(false)
-      @runner.system.expects(:prepare_host_only_network).never
-      @action.after_boot
-    end
-  end
-
-  context "checking if network is enabled" do
-    should "return true if the network options are set" do
-      @runner.env.config.vm.network("foo")
-      assert @action.enable_network?
-    end
-
-    should "return false if the network was not set" do
-      assert !@action.enable_network?
-    end
-  end
-
-  context "assigning the network" do
-    setup do
-      @network_name = "foo"
-      @action.stubs(:network_name).returns(@network_name)
-
-      @network_adapters = []
-      @vm.stubs(:network_adapters).returns(@network_adapters)
-
-      @options = {
-        :ip => "foo",
-        :adapter => 7
-      }
-
-      @runner.env.config.vm.network(@options[:ip], @options)
-    end
-
-    should "setup the specified network adapter" do
-      adapter = mock("adapter")
-      @network_adapters[@options[:adapter]] = adapter
-
-      adapter.expects(:enabled=).with(true).once
-      adapter.expects(:attachment_type=).with(:host_only).once
-      adapter.expects(:host_interface=).with(@network_name).once
-      adapter.expects(:save).once
-
-      @action.assign_network
-    end
-  end
-
-  context "verify no bridge collision" do
-    setup do
-      @action.stubs(:matching_network?).returns(false)
-      @options = { :ip => :foo, :netmask => :bar, :name => nil }
-    end
-
-    should "do nothing if everything is okay" do
-      mock_interface
-
-      assert_nothing_raised { @action.verify_no_bridge_collision(@options) }
-    end
-
-    should "raise an exception if a collision is found" do
-      mock_interface(:interface_type => :bridged)
-      @action.stubs(:matching_network?).returns(true)
-
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.verify_no_bridge_collision(@options)
-      }
-    end
-  end
-
-  context "network name" do
-    setup do
-      @action.stubs(:matching_network?).returns(false)
-
-      @options = { :ip => :foo, :netmask => :bar, :name => nil }
-    end
-
-    should "return the network which matches" do
-      result = mock("result")
-      interface = mock_interface(:name => result)
-
-      @action.expects(:matching_network?).with(interface, @options).returns(true)
-      assert_equal result, @action.network_name(@options)
-    end
-
-    should "ignore non-host only interfaces" do
-      @options[:name] = "foo"
-      mock_interface(:name => @options[:name],
-                     :interface_type => :bridged)
-
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.network_name(@options)
-      }
-    end
-
-    should "return the network which matches the name if given" do
-      @options[:name] = "foo"
-
-      interface = mock_interface(:name => @options[:name])
-      assert_equal @options[:name], @action.network_name(@options)
-    end
-
-    should "error and exit if the given network name is not found" do
-      @options[:name] = "foo"
-
-      @interfaces.expects(:create).never
-
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.network_name(@options)
-      }
-    end
-
-    should "create a network for the IP and netmask" do
-      result = mock("result")
-      network_ip = :foo
-
-      interface = mock_interface(:name => result)
-      interface.expects(:enable_static).with(network_ip, @options[:netmask])
-      @interfaces.expects(:create).returns(interface)
-      @action.expects(:network_ip).with(@options[:ip], @options[:netmask]).once.returns(network_ip)
-
-      assert_equal result, @action.network_name(@options)
-    end
-  end
-
-  context "checking for a matching network" do
-    setup do
-      @interface = mock("interface")
-      @interface.stubs(:network_mask).returns("foo")
-      @interface.stubs(:ip_address).returns("192.168.0.1")
-
-      @options = {
-        :netmask => "foo",
-        :ip => "baz"
-      }
-    end
-
-    should "return false if the netmasks don't match" do
-      @options[:netmask] = "bar"
-      assert @interface.network_mask != @options[:netmask] # sanity
-      assert !@action.matching_network?(@interface, @options)
-    end
-
-    should "return true if the netmasks yield the same IP" do
-      tests = [["255.255.255.0", "192.168.0.1", "192.168.0.45"],
-               ["255.255.0.0", "192.168.45.1", "192.168.28.7"]]
-
-      tests.each do |netmask, interface_ip, guest_ip|
-        @options[:netmask] = netmask
-        @options[:ip] = guest_ip
-        @interface.stubs(:network_mask).returns(netmask)
-        @interface.stubs(:ip_address).returns(interface_ip)
-
-        assert @action.matching_network?(@interface, @options)
-      end
-    end
-  end
-
-  context "applying the netmask" do
-    should "return the proper result" do
-      tests = {
-        ["192.168.0.1","255.255.255.0"] => [192,168,0,0],
-        ["192.168.45.10","255.255.255.0"] => [192,168,45,0]
-      }
-
-      tests.each do |k,v|
-        assert_equal v, @action.apply_netmask(*k)
-      end
-    end
-  end
-
-  context "splitting an IP" do
-    should "return the proper result" do
-      tests = {
-        "192.168.0.1" => [192,168,0,1]
-      }
-
-      tests.each do |k,v|
-        assert_equal v, @action.split_ip(k)
-      end
-    end
-  end
-
-  context "network IP" do
-    should "return the proper result" do
-      tests = {
-        ["192.168.0.45", "255.255.255.0"] => "192.168.0.1"
-      }
-
-      tests.each do |args, result|
-        assert_equal result, @action.network_ip(*args)
-      end
-    end
-  end
-end

data/test/vagrant/actions/vm/package_test.rb

@@ -1,254 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class PackageActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package)
-  end
-
-  context "initialization" do
-    def get_action(output, include_files)
-      runner, vm, action = mock_action(Vagrant::Actions::VM::Package, {
-                                         :output => output,
-                                         :include => include_files
-                                       })
-      return action
-    end
-
-    should "make out_path 'package' by default if nil is given" do
-      action = get_action(nil, [])
-      assert_equal "package", action.out_path
-    end
-
-    should "make include files an empty array by default" do
-      action = get_action("foo", nil)
-      assert action.include_files.is_a?(Array)
-      assert action.include_files.empty?
-    end
-  end
-
-  context "executing" do
-    setup do
-      @action.stubs(:compress)
-    end
-
-    should "compress" do
-      package_seq = sequence("package_seq")
-      @action.expects(:compress).in_sequence(package_seq)
-      @action.execute!
-    end
-  end
-
-  context "out path" do
-    should "be the specified output file if given" do
-      result = mock("result")
-      @action.options[:output] = result
-      assert_equal result, @action.out_path
-    end
-
-    should "default to 'package'" do
-      @action.options[:output] = nil
-      assert_equal "package", @action.out_path
-    end
-  end
-
-  context "include files" do
-    should "specified array if given" do
-      @action.options[:include] = [1,2,3]
-      assert_equal @action.options[:include], @action.include_files
-    end
-
-    should "be an empty array by default" do
-      @action.options[:include] = nil
-      assert_equal [], @action.include_files
-    end
-  end
-
-  context "tar path" do
-    should "be the temporary directory with the name and extension attached" do
-      pwd = "foo"
-      FileUtils.stubs(:pwd).returns(pwd)
-      assert_equal File.join(pwd, "#{@action.out_path}#{@runner.env.config.package.extension}"), @action.tar_path
-    end
-  end
-
-  context "temp path" do
-    setup do
-      @export = mock("export")
-      @action.expects(:export_action).returns(@export)
-    end
-
-    should "use the export action's temp dir" do
-      path = mock("path")
-      @export.expects(:temp_dir).returns(path)
-      @action.temp_path
-    end
-  end
-
-  context "copying include files" do
-    setup do
-      @include_files = []
-      @action.stubs(:include_files).returns(@include_files)
-
-      @temp_path = "foo"
-      @action.stubs(:temp_path).returns(@temp_path)
-    end
-
-    should "do nothing if no include files are specified" do
-      assert @action.include_files.empty?
-      FileUtils.expects(:mkdir_p).never
-      FileUtils.expects(:cp).never
-      @action.copy_include_files
-    end
-
-    should "create the include directory and copy files to it" do
-      include_dir = File.join(@action.temp_path, "include")
-      copy_seq = sequence("copy_seq")
-      FileUtils.expects(:mkdir_p).with(include_dir).once.in_sequence(copy_seq)
-
-      5.times do |i|
-        file = mock("f#{i}")
-        @include_files << file
-        FileUtils.expects(:cp).with(file, include_dir).in_sequence(copy_seq)
-      end
-
-      @action.copy_include_files
-    end
-  end
-
-  context "creating vagrantfile" do
-    setup do
-      @temp_path = "foo"
-      @action.stubs(:temp_path).returns(@temp_path)
-
-      @network_adapter = mock("nic")
-      @network_adapter.stubs(:mac_address).returns("mac_address")
-      @vm.stubs(:network_adapters).returns([@network_adapter])
-    end
-
-    should "write the rendered vagrantfile to temp_path Vagrantfile" do
-      f = mock("file")
-      rendered = mock("rendered")
-      File.expects(:open).with(File.join(@action.temp_path, "Vagrantfile"), "w").yields(f)
-      Vagrant::Util::TemplateRenderer.expects(:render).returns(rendered).with("package_Vagrantfile", {
-        :base_mac => @runner.vm.network_adapters.first.mac_address
-      })
-      f.expects(:write).with(rendered)
-
-      @action.create_vagrantfile
-    end
-  end
-
-  context "compression" do
-    setup do
-      @tar_path = "foo"
-      @action.stubs(:tar_path).returns(@tar_path)
-
-      @temp_path = "foo"
-      @action.stubs(:temp_path).returns(@temp_path)
-
-      @include_files = []
-      @action.stubs(:include_files).returns(@include_files)
-
-      @pwd = "bar"
-      FileUtils.stubs(:pwd).returns(@pwd)
-      FileUtils.stubs(:cd)
-
-      @file = mock("file")
-      File.stubs(:open).yields(@file)
-
-      @output = mock("output")
-      @tar = Archive::Tar::Minitar
-      Archive::Tar::Minitar::Output.stubs(:open).yields(@output)
-      @tar.stubs(:pack_file)
-
-      @action.stubs(:copy_include_files)
-      @action.stubs(:create_vagrantfile)
-    end
-
-    should "open the tar file with the tar path properly" do
-      File.expects(:open).with(@tar_path, Vagrant::Util::Platform.tar_file_options).once
-      @action.compress
-    end
-
-    should "open tar file" do
-      Archive::Tar::Minitar::Output.expects(:open).with(@file).once
-      @action.compress
-    end
-
-    #----------------------------------------------------------------
-    # Methods below this comment test the block yielded by Minitar open
-    #----------------------------------------------------------------
-    should "cd to the directory and append the directory" do
-      @files = []
-      compress_seq = sequence("compress_seq")
-
-      FileUtils.expects(:pwd).once.returns(@pwd).in_sequence(compress_seq)
-      @action.expects(:copy_include_files).once.in_sequence(compress_seq)
-      @action.expects(:create_vagrantfile).once.in_sequence(compress_seq)
-      FileUtils.expects(:cd).with(@temp_path).in_sequence(compress_seq)
-      Dir.expects(:glob).returns(@files).in_sequence(compress_seq)
-
-      5.times do |i|
-        file = mock("file#{i}")
-        @tar.expects(:pack_file).with(file, @output).once.in_sequence(compress_seq)
-        @files << file
-      end
-
-      FileUtils.expects(:cd).with(@pwd).in_sequence(compress_seq)
-      @action.compress
-    end
-
-    should "pop back to the current directory even if an exception is raised" do
-      cd_seq = sequence("cd_seq")
-      FileUtils.expects(:cd).with(@temp_path).raises(Exception).in_sequence(cd_seq)
-      FileUtils.expects(:cd).with(@pwd).in_sequence(cd_seq)
-
-      assert_raises(Exception) {
-        @action.compress
-      }
-    end
-  end
-
-  context "preparing the action" do
-    context "checking include files" do
-      setup do
-        @include_files = ['fooiest', 'booiest']
-        @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, {
-                                              :include => @include_files
-                                            })
-        @runner.stubs(:find_action).returns("foo")
-      end
-
-      should "check that all the include files exist" do
-        @include_files.each do |file|
-          File.expects(:exists?).with(file).returns(true)
-        end
-        @action.prepare
-      end
-
-      should "raise an exception if the output file already exists" do
-        File.expects(:exist?).with(@action.tar_path).returns(false)
-        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
-      end
-
-      should "raise an exception when an include file does not exist" do
-        File.expects(:exists?).once.returns(false)
-        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
-      end
-    end
-
-    context "loading export reference" do
-      should "find and store a reference to the export action" do
-        @export = mock("export")
-        @runner.expects(:find_action).with(Vagrant::Actions::VM::Export).once.returns(@export)
-        @action.prepare
-        assert @export.equal?(@action.export_action)
-      end
-
-      should "raise an exception if the export action couldn't be found" do
-        @runner.expects(:find_action).with(Vagrant::Actions::VM::Export).once.returns(nil)
-        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
-      end
-    end
-  end
-end