vagrant 1.0.7 → 2.4.4

data/test/unit_legacy/vagrant/provisioners/puppet_server_test.rb

@@ -1,68 +0,0 @@
-require "test_helper"
-
-class PuppetServerProvisionerTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Provisioners::PuppetServer
-
-    @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
-
-    @config = @klass::Config.new
-    @action = @klass.new(@action_env, @config)
-    @env = @action.env
-    @vm = @action.vm
-  end
-
-  context "provisioning" do
-    should "run the proper sequence of methods in order" do
-      prov_seq = sequence("prov_seq")
-      @action.expects(:verify_binary).with("puppetd").once.in_sequence(prov_seq)
-      @action.expects(:run_puppetd_client).once.in_sequence(prov_seq)
-      @action.provision!
-    end
-  end
-
-  context "verifying binary" do
-    setup do
-      @ssh = mock("ssh")
-      @shell = mock("shell")
-      @vm.ssh.stubs(:execute).yields(@ssh)
-    end
-
-    should "verify binary exists" do
-      binary = "foo"
-      @ssh.expects(:sudo!).with("which #{binary}", anything)
-      @action.verify_binary(binary)
-    end
-  end
-
-  context "running puppetd client" do
-    setup do
-      @cn = "puppet_node"
-      @ssh = mock("ssh")
-      @vm.ssh.stubs(:execute).yields(@ssh)
-    end
-
-    should "run the puppetd client" do
-      @ssh.expects(:sudo!).with("puppetd  --server #{@config.puppet_server} --certname #{@cn}").once
-      @action.run_puppetd_client
-    end
-
-    should "run puppetd with given options when given as an array" do
-      @config.options = ["--modulepath", "modules", "--verbose"]
-      @ssh.expects(:sudo!).with("puppetd --modulepath modules --verbose --server #{@config.puppet_server} --certname #{@cn}").once
-      @action.run_puppetd_client
-    end
-
-    should "run puppetd with the options when given as a string" do
-      @config.options = "--modulepath modules --verbose"
-      @ssh.expects(:sudo!).with("puppetd --modulepath modules --verbose --server #{@config.puppet_server} --certname #{@cn}").once
-      @action.run_puppetd_client
-    end
-
-    should "check the exit status if that is given" do
-      @ssh.stubs(:sudo!).yields(nil, :exit_status, :foo)
-      @ssh.expects(:check_exit_status).with(:foo, anything).once
-      @action.run_puppetd_client
-    end
-  end
-end

data/test/unit_legacy/vagrant/provisioners/puppet_test.rb

@@ -1,182 +0,0 @@
-require "test_helper"
-
-class PuppetProvisionerTest < Test::Unit::TestCase
-  setup do
-    clean_paths
-
-    @klass = Vagrant::Provisioners::Puppet
-
-    @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
-
-    @config = @klass::Config.new
-    @config.top = Vagrant::Config::Top.new(@action_env.env)
-    @config.top.vm.box = "foo"
-    @action = @klass.new(@action_env, @config)
-    @env = @action.env
-    @vm = @action.vm
-  end
-
-  context "config" do
-    setup do
-      @errors = Vagrant::Config::ErrorRecorder.new
-
-      # Set a box
-      @config.top.vm.box = "foo"
-
-      # Start in a valid state (verified by the first test)
-      @config.expanded_manifests_path.mkdir
-      File.open(@config.expanded_manifests_path.join(@config.computed_manifest_file), "w") { |f| f.puts "HELLO" }
-    end
-
-    should "expand the manifest path relative to the root path" do
-      assert_equal File.expand_path(@config.manifests_path, @env.root_path), @config.expanded_manifests_path.to_s
-    end
-
-    should "default the manifest file to the box name" do
-      assert_equal "#{@config.top.vm.box}.pp", @config.computed_manifest_file
-    end
-
-    should "use the custom manifest file if set" do
-      @config.manifest_file = "woot.pp"
-      assert_equal "woot.pp", @config.computed_manifest_file
-    end
-
-    should "return an empty array if no module path is set" do
-      @config.module_path = nil
-      assert_equal [], @config.expanded_module_paths
-    end
-
-    should "return array of module paths expanded relative to root path" do
-      @config.module_path = "foo"
-
-      result = @config.expanded_module_paths
-      assert result.is_a?(Array)
-      assert_equal 1, result.length
-      assert_equal File.expand_path(@config.module_path, @env.root_path), result[0].to_s
-    end
-
-    should "be valid" do
-      @config.validate(@errors)
-      assert @errors.errors.empty?
-    end
-
-    should "be invalid if the manifests path doesn't exist" do
-      @config.expanded_manifests_path.rmtree
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid if a custom manifests path doesn't exist" do
-      @config.manifests_path = "dont_exist"
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid if the manifest file doesn't exist" do
-      @config.expanded_manifests_path.join(@config.computed_manifest_file).unlink
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid if a specified module path doesn't exist" do
-      @config.module_path = "foo"
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be valid if all module paths exist" do
-      @config.module_path = "foo"
-      @config.expanded_module_paths.first.mkdir
-      @config.validate(@errors)
-      assert @errors.errors.empty?
-    end
-  end
-
-  context "preparing" do
-    should "share manifests" do
-      pre_seq = sequence("prepare")
-      @action.expects(:set_module_paths).once.in_sequence(pre_seq)
-      @action.expects(:share_manifests).once.in_sequence(pre_seq)
-      @action.expects(:share_module_paths).once.in_sequence(pre_seq)
-      @action.prepare
-    end
-  end
-
-  context "provisioning" do
-    should "run the proper sequence of methods in order" do
-      prov_seq = sequence("prov_seq")
-      @action.expects(:verify_binary).with("puppet").once.in_sequence(prov_seq)
-      @action.expects(:run_puppet_client).once.in_sequence(prov_seq)
-      @action.provision!
-    end
-  end
-
-  context "share manifests folder" do
-    should "share manifest folder" do
-      @env.config.vm.expects(:share_folder).with("manifests", @action.manifests_guest_path, @config.expanded_manifests_path)
-      @action.share_manifests
-    end
-  end
-
-  context "sharing module paths" do
-    should "share all the module paths" do
-      @config.module_path = ["foo", "bar"]
-      @config.expanded_module_paths.each_with_index do |path, i|
-        @env.config.vm.expects(:share_folder).with("v-pp-m#{i}", File.join(@config.pp_path, "modules-#{i}"), path)
-      end
-
-      @action.set_module_paths
-      @action.share_module_paths
-    end
-  end
-
-  context "verifying binary" do
-    setup do
-      @ssh = mock("ssh")
-      @vm.ssh.stubs(:execute).yields(@ssh)
-    end
-
-    should "verify binary exists" do
-      binary = "foo"
-      @ssh.expects(:sudo!).with("which #{binary}", anything)
-      @action.verify_binary(binary)
-    end
-  end
-
-  context "running puppet client" do
-    setup do
-      @ssh = mock("ssh")
-      @vm.ssh.stubs(:execute).yields(@ssh)
-      @action.set_module_paths
-    end
-
-    def expect_puppet_command(command)
-      @ssh.expects(:sudo!).with(["cd #{@action.manifests_guest_path}", command])
-    end
-
-    should "cd into the pp_path directory and run puppet" do
-      expect_puppet_command("puppet apply #{@config.computed_manifest_file}")
-      @action.run_puppet_client
-    end
-
-    should "cd into the pp_path directory and run puppet with given options when given as an array" do
-      @config.options = ["--modulepath", "modules", "--verbose"]
-      expect_puppet_command("puppet apply --modulepath modules --verbose #{@config.computed_manifest_file}")
-      @action.run_puppet_client
-    end
-
-    should "cd into the pp_path directory and run puppet with the options when given as a string" do
-      @config.options = "--modulepath modules --verbose"
-      expect_puppet_command("puppet apply --modulepath modules --verbose #{@config.computed_manifest_file}")
-      @action.run_puppet_client
-    end
-
-    should "cd into the pp_path and run puppet with module paths if set" do
-      @config.module_path = "foo"
-      expect_puppet_command("puppet apply --modulepath '#{File.join(@config.pp_path, 'modules-0')}' #{@config.computed_manifest_file}")
-
-      @action.set_module_paths
-      @action.run_puppet_client
-    end
-  end
-end

data/test/unit_legacy/vagrant/provisioners/shell_test.rb

@@ -1,79 +0,0 @@
-require "test_helper"
-
-class ShellProvisionerTest < Test::Unit::TestCase
-  setup do
-    clean_paths
-
-    @klass = Vagrant::Provisioners::Shell
-    @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
-    @config = @klass::Config.new
-    @config.top = Vagrant::Config::Top.new(@action_env.env)
-    @action = @klass.new(@action_env, @config)
-
-    @config.path = "foo"
-  end
-
-  context "config" do
-    setup do
-      @errors = Vagrant::Config::ErrorRecorder.new
-
-      # Start in a valid state (verified by a test below)
-      @config.path = "foo"
-      File.open(@config.expanded_path, "w") { |f| f.puts "HELLO" }
-    end
-
-    should "be valid" do
-      @config.validate(@errors)
-      assert @errors.errors.empty?
-    end
-
-    should "be invalid if the path is not set" do
-      @config.path = nil
-
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid if the path does not exist" do
-      @config.path = "bar"
-
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid if the upload path is not set" do
-      @config.upload_path = nil
-
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-  end
-
-  context "provisioning" do
-    setup do
-      @ssh = mock("ssh")
-      @action.vm.ssh.stubs(:execute).yields(@ssh)
-    end
-
-    should "upload the file, chmod, then execute it" do
-      commands = ["chmod +x #{@config.upload_path}", @config.upload_path]
-
-      p_seq = sequence("provisioning")
-      @action.vm.ssh.expects(:upload!).with(@config.expanded_path.to_s, @config.upload_path).in_sequence(p_seq)
-      @ssh.expects(:sudo!).with(commands).in_sequence(p_seq)
-
-      @action.provision!
-    end
-
-    should "append arguments if provided" do
-      @config.args = "foo bar baz"
-      commands = ["chmod +x #{@config.upload_path}", "#{@config.upload_path} #{@config.args}"]
-
-      p_seq = sequence("provisioning")
-      @action.vm.ssh.expects(:upload!).with(@config.expanded_path.to_s, @config.upload_path).in_sequence(p_seq)
-      @ssh.expects(:sudo!).with(commands).in_sequence(p_seq)
-
-      @action.provision!
-    end
-  end
-end

data/test/unit_legacy/vagrant/ssh/session_test.rb

@@ -1,40 +0,0 @@
-require "test_helper"
-
-class SshSessionTest < Test::Unit::TestCase
-  setup do
-    @session = mock("session")
-    @env = vagrant_env
-
-    @klass = Vagrant::SSH::Session
-    @instance = @klass.new(@session, @env)
-  end
-
-  context "exec!" do
-    should "retry max_tries times" do
-      @session.expects(:open_channel).times(@env.config.ssh.max_tries).raises(IOError)
-      assert_raises(IOError) {
-        @instance.exec!("foo")
-      }
-    end
-  end
-
-  context "checking exit status" do
-    should "raise an ActionException if its non-zero" do
-      assert_raises(Vagrant::Errors::VagrantError) {
-        @instance.check_exit_status(1, "foo")
-      }
-    end
-
-    should "raise the given exception if specified" do
-      assert_raises(Vagrant::Errors::BaseVMNotFound) {
-        @instance.check_exit_status(1, "foo", :_error_class => Vagrant::Errors::BaseVMNotFound)
-      }
-    end
-
-    should "raise nothing if its zero" do
-      assert_nothing_raised {
-        @instance.check_exit_status(0, "foo")
-      }
-    end
-  end
-end

data/test/unit_legacy/vagrant/ssh_test.rb

@@ -1,304 +0,0 @@
-require "test_helper"
-
-class SshTest < Test::Unit::TestCase
-  def mock_ssh
-    @env = vagrant_env.vms[:default].env
-    @network_adapters = []
-    @vm = mock("vm")
-    @vm.stubs(:network_adapters).returns(@network_adapters)
-    @env.vm.stubs(:vm).returns(@vm)
-
-    @ssh = Vagrant::SSH.new(@env)
-    @session = mock("session")
-  end
-
-  setup do
-    VirtualBox.stubs(:version).returns("4.1.0")
-  end
-
-  context "connecting to external SSH" do
-    setup do
-      mock_ssh
-      @ssh.stubs(:check_key_permissions)
-      @ssh.stubs(:port).returns(2222)
-      @ssh.stubs(:safe_exec)
-      Kernel.stubs(:system).returns(true)
-    end
-
-    should "raise an exception if SSH is not found" do
-      Kernel.stubs(:system).returns(false)
-      Kernel.expects(:system).returns(false).with() do |command|
-        assert command =~ /^which ssh/
-        true
-      end
-
-      assert_raises(Vagrant::Errors::SSHUnavailable) {
-        @ssh.connect
-      }
-    end
-
-    should "check key permissions prior to exec" do
-      exec_seq = sequence("exec_seq")
-      @ssh.expects(:check_key_permissions).with(@env.config.ssh.private_key_path).once.in_sequence(exec_seq)
-      @ssh.expects(:safe_exec).in_sequence(exec_seq)
-      @ssh.connect
-    end
-
-    should "call exec with defaults when no options are supplied" do
-      ssh_exec_expect(@ssh.port,
-                      @env.config.ssh.private_key_path,
-                      @env.config.ssh.username,
-                      @env.config.ssh.host)
-      @ssh.connect
-    end
-
-    should "call exec with supplied params" do
-      args = {:username => 'bar', :private_key_path => 'baz', :host => 'bak'}
-      ssh_exec_expect(@ssh.port, args[:private_key_path], args[:username], args[:host])
-      @ssh.connect(args)
-    end
-
-    should "add forward agent option if enabled" do
-      @env.config.ssh.forward_agent = true
-      ssh_exec_expect(@ssh.port,
-                      @env.config.ssh.private_key_path,
-                      @env.config.ssh.username,
-                      @env.config.ssh.host) do |args|
-        assert args =~ /-o ForwardAgent=yes/
-      end
-      @ssh.connect
-    end
-
-    should "add forward X11 option if enabled" do
-      @env.config.ssh.forward_x11 = true
-      ssh_exec_expect(@ssh.port,
-                      @env.config.ssh.private_key_path,
-                      @env.config.ssh.username,
-                      @env.config.ssh.host) do |args|
-        assert args =~ /-o ForwardX11=yes/
-      end
-      @ssh.connect
-    end
-
-    context "checking windows" do
-      should "error and exit if the platform is windows" do
-        Vagrant::Util::Platform.stubs(:windows?).returns(true)
-        assert_raises(Vagrant::Errors::SSHUnavailableWindows) { @ssh.connect }
-      end
-
-      should "not error and exit if the platform is anything other that windows" do
-        Vagrant::Util::Platform.stubs(:windows?).returns(false)
-        assert_nothing_raised { @ssh.connect }
-      end
-    end
-
-    def ssh_exec_expect(port, key_path, uname, host)
-      @ssh.expects(:safe_exec).with() do |arg|
-        assert arg =~ /^ssh/, "ssh command expected"
-        assert arg =~ /-p #{port}/, "-p #{port} expected"
-        assert arg =~ /-i #{key_path}/, "-i #{key_path} expected"
-        assert arg =~ /#{uname}@#{host}/, "#{uname}@{host} expected"
-        yield arg if block_given?
-        true
-      end
-    end
-  end
-
-  context "executing ssh commands" do
-    setup do
-      mock_ssh
-      @ssh.stubs(:check_key_permissions)
-      @ssh.stubs(:port).returns(80)
-    end
-
-    should "check key permissions then attempt to start connection" do
-      seq = sequence("seq")
-      @ssh.expects(:check_key_permissions).with(@env.config.ssh.private_key_path).once.in_sequence(seq)
-      Net::SSH.expects(:start).once.in_sequence(seq)
-      @ssh.execute
-    end
-
-    should "call net::ssh.start with the proper names" do
-      Net::SSH.expects(:start).once.with() do |host, username, opts|
-        assert_equal @env.config.ssh.host, host
-        assert_equal @env.config.ssh.username, username
-        assert_equal @ssh.port, opts[:port]
-        assert_equal [@env.config.ssh.private_key_path], opts[:keys]
-        assert opts[:keys_only]
-        true
-      end
-      @ssh.execute
-    end
-
-    should "forward agent if configured" do
-      @env.config.ssh.forward_agent = true
-      Net::SSH.expects(:start).once.with() do |host, username, opts|
-        assert opts[:forward_agent]
-        true
-      end
-
-      @ssh.execute
-    end
-
-    should "use custom host if set" do
-      @env.config.ssh.host = "foo"
-      Net::SSH.expects(:start).with(@env.config.ssh.host, @env.config.ssh.username, anything).once
-      @ssh.execute
-    end
-
-    should "yield an SSH session object" do
-      raw = mock("raw")
-      Net::SSH.expects(:start).returns(raw)
-      @ssh.execute do |ssh|
-        assert ssh.is_a?(Vagrant::SSH::Session)
-        assert_equal raw, ssh.session
-      end
-    end
-  end
-
-  context "SCPing files to the remote host" do
-    setup do
-      mock_ssh
-    end
-
-    should "use Vagrant::SSH execute to setup an SCP connection and upload" do
-      scp = mock("scp")
-      ssh = mock("ssh")
-      sess = mock("session")
-      ssh.stubs(:session).returns(sess)
-      scp.expects(:upload!).with("foo", "bar").once
-      Net::SCP.expects(:new).with(ssh.session).returns(scp).once
-      @ssh.expects(:execute).yields(ssh).once
-      @ssh.upload!("foo", "bar")
-    end
-  end
-
-  context "checking if host is up" do
-    setup do
-      mock_ssh
-      @ssh.stubs(:check_key_permissions)
-      @ssh.stubs(:port).returns(2222)
-      @session.stubs(:exec!).returns("hello\n")
-    end
-
-    should "return false if SSH connection times out" do
-      @env.config.ssh.timeout = 0.5
-
-      Net::SSH.stubs(:start).with() do
-        # Sleep here to artificially fake timeout
-        sleep 1
-        true
-      end
-
-      assert !@ssh.up?
-    end
-
-    should "return false if the connection is refused" do
-      Net::SSH.expects(:start).times(@env.config.ssh.max_tries).raises(Errno::ECONNREFUSED)
-      assert_nothing_raised {
-        assert !@ssh.up?
-      }
-    end
-
-    should "specify the timeout as an option to execute" do
-      @ssh.expects(:execute).yields(@session).with() do |opts|
-        assert_equal @env.config.ssh.timeout, opts[:timeout]
-        true
-      end
-
-      assert @ssh.up?
-    end
-
-    should "error and exit if a Net::SSH::AuthenticationFailed is raised" do
-      @ssh.expects(:execute).raises(Net::SSH::AuthenticationFailed)
-      assert_raises(Vagrant::Errors::SSHAuthenticationFailed) { @ssh.up? }
-    end
-
-    should "only get the port once (in the main thread)" do
-      @ssh.expects(:port).once.returns(2222)
-      @ssh.up?
-    end
-  end
-
-  context "getting the ssh port" do
-    setup do
-      mock_ssh
-    end
-
-    should "return the port given in options if it exists" do
-      assert_equal "47", @ssh.port({ :port => "47" })
-    end
-  end
-
-  context "checking key permissions" do
-    setup do
-      mock_ssh
-      @ssh.stubs(:file_perms)
-
-      @key_path = "foo"
-
-
-      @stat = mock("stat")
-      @stat.stubs(:owned?).returns(true)
-      File.stubs(:stat).returns(@stat)
-
-      Vagrant::Util::Platform.stubs(:windows?).returns(false)
-    end
-
-    should "do nothing if on windows" do
-      Vagrant::Util::Platform.stubs(:windows?).returns(true)
-      File.expects(:stat).never
-      @ssh.check_key_permissions(@key_path)
-    end
-
-    should "do nothing if the user is not the owner" do
-      @stat.expects(:owned?).returns(false)
-      File.expects(:chmod).never
-      @ssh.check_key_permissions(@key_path)
-    end
-
-    should "do nothing if the file perms equal 600" do
-      @ssh.expects(:file_perms).with(@key_path).returns("600")
-      File.expects(:chmod).never
-      @ssh.check_key_permissions(@key_path)
-    end
-
-    should "chmod the file if the file perms aren't 600" do
-      perm_sequence = sequence("perm_seq")
-      @ssh.expects(:file_perms).returns("900").in_sequence(perm_sequence)
-      File.expects(:chmod).with(0600, @key_path).once.in_sequence(perm_sequence)
-      @ssh.expects(:file_perms).returns("600").in_sequence(perm_sequence)
-      assert_nothing_raised { @ssh.check_key_permissions(@key_path) }
-    end
-
-    should "error and exit if the resulting chmod doesn't work" do
-      perm_sequence = sequence("perm_seq")
-      @ssh.expects(:file_perms).returns("900").in_sequence(perm_sequence)
-      File.expects(:chmod).with(0600, @key_path).once.in_sequence(perm_sequence)
-      @ssh.expects(:file_perms).returns("900").in_sequence(perm_sequence)
-      assert_raises(Vagrant::Errors::SSHKeyBadPermissions) { @ssh.check_key_permissions(@key_path) }
-    end
-
-    should "error and exit if a bad file perm is raised" do
-      @ssh.expects(:file_perms).with(@key_path).returns("900")
-      File.expects(:chmod).raises(Errno::EPERM)
-      assert_raises(Vagrant::Errors::SSHKeyBadPermissions) { @ssh.check_key_permissions(@key_path) }
-    end
-  end
-
-  context "getting file permissions" do
-    setup do
-      mock_ssh
-    end
-
-    should "return the last 3 characters of the file mode" do
-      path = "foo"
-      mode = "10000foo"
-      stat = mock("stat")
-      File.expects(:stat).with(path).returns(stat)
-      stat.expects(:mode).returns(mode)
-      @ssh.expects(:sprintf).with("%o", mode).returns(mode)
-      assert_equal path, @ssh.file_perms(path)
-    end
-  end
-end

data/test/unit_legacy/vagrant/systems/base_test.rb

@@ -1,18 +0,0 @@
-require "test_helper"
-
-class BaseSystemTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Systems::Base
-
-    @vm = mock("vm")
-    @instance = @klass.new(@vm)
-  end
-
-  should "provide access to the VM" do
-    assert_equal @vm, @instance.vm
-  end
-
-  should "error on preparing host only network" do
-    assert_raises(@klass::BaseError) { @instance.prepare_host_only_network }
-  end
-end