vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/retryable_test.rb

@@ -1,106 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/retryable"
-
-describe Vagrant::Util::Retryable do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::Retryable
-    end
-  end
-
-  it "doesn't retry by default" do
-    tries = 0
-
-    block = lambda do
-      tries += 1
-      raise RuntimeError, "Try"
-    end
-
-    # It should re-raise the error
-    expect { klass.retryable(&block) }.
-      to raise_error(RuntimeError)
-
-    # It should've tried once
-    expect(tries).to eq(1)
-  end
-
-  it "retries the set number of times" do
-    tries = 0
-
-    block = lambda do
-      tries += 1
-      raise RuntimeError, "Try"
-    end
-
-    # It should re-raise the error
-    expect { klass.retryable(tries: 5, &block) }.
-      to raise_error(RuntimeError)
-
-    # It should've tried all specified times
-    expect(tries).to eq(5)
-  end
-
-  it "only retries on the given exception" do
-    tries = 0
-
-    block = lambda do
-      tries += 1
-      raise StandardError, "Try"
-    end
-
-    # It should re-raise the error
-    expect { klass.retryable(tries: 5, on: RuntimeError, &block) }.
-      to raise_error(StandardError)
-
-    # It should've never tried since it was a different kind of error
-    expect(tries).to eq(1)
-  end
-
-  it "can retry on multiple types of errors" do
-    tries = 0
-
-    foo_error = Class.new(StandardError)
-    bar_error = Class.new(StandardError)
-
-    block = lambda do
-      tries += 1
-      raise foo_error, "Try" if tries == 1
-      raise bar_error, "Try" if tries == 2
-      raise RuntimeError, "YAY"
-    end
-
-    # It should re-raise the error
-    expect { klass.retryable(tries: 5, on: [foo_error, bar_error], &block) }.
-      to raise_error(RuntimeError)
-
-    # It should've never tried since it was a different kind of error
-    expect(tries).to eq(3)
-  end
-
-  it "doesn't sleep between tries by default" do
-    block = lambda do
-      raise RuntimeError, "Try"
-    end
-
-    # Sleep should never be called
-    expect(klass).not_to receive(:sleep)
-
-    # Run it.
-    expect { klass.retryable(tries: 5, &block) }.
-      to raise_error(RuntimeError)
-  end
-
-  it "sleeps specified amount between retries" do
-    block = lambda do
-      raise RuntimeError, "Try"
-    end
-
-    # Sleep should be called between each retry
-    expect(klass).to receive(:sleep).with(10).exactly(4).times
-
-    # Run it.
-    expect { klass.retryable(tries: 5, sleep: 10, &block) }.
-      to raise_error(RuntimeError)
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/safe_chdir_test.rb

@@ -1,49 +0,0 @@
-require 'tmpdir'
-
-require File.expand_path("../../../base", __FILE__)
-
-require 'vagrant/util/safe_chdir'
-
-describe Vagrant::Util::SafeChdir do
-  let(:temp_dir) { Dir.mktmpdir("vagrant-test-util-safe-chdir") }
-  let(:temp_dir2) { Dir.mktmpdir("vagrant-test-util-safe-chdir-2") }
-
-  after do
-    FileUtils.rm_rf(temp_dir)
-    FileUtils.rm_rf(temp_dir2)
-  end
-
-  it "should change directories" do
-    expected = nil
-    result   = nil
-
-    Dir.chdir(temp_dir) do
-      expected = Dir.pwd
-    end
-
-    described_class.safe_chdir(temp_dir) do
-      result = Dir.pwd
-    end
-
-    expect(result).to eq(expected)
-  end
-
-  it "should allow recursive chdir" do
-    expected  = nil
-    result    = nil
-
-    Dir.chdir(temp_dir) do
-      expected = Dir.pwd
-    end
-
-    expect do
-      described_class.safe_chdir(temp_dir2) do
-        described_class.safe_chdir(temp_dir) do
-          result = Dir.pwd
-        end
-      end
-    end.to_not raise_error
-
-    expect(result).to eq(expected)
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/scoped_hash_override_test.rb

@@ -1,50 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/scoped_hash_override"
-
-describe Vagrant::Util::ScopedHashOverride do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::ScopedHashOverride
-    end
-  end
-
-  it "should not mess with non-overrides" do
-    original = {
-      key: "value",
-      another_value: "foo"
-    }
-
-    expect(klass.scoped_hash_override(original, "foo")).to eq(original)
-  end
-
-  it "should override if the scope matches" do
-    original = {
-      key: "value",
-      scope__key: "replaced"
-    }
-
-    expected = {
-      key: "replaced",
-      scope__key: "replaced"
-    }
-
-    expect(klass.scoped_hash_override(original, "scope")).to eq(expected)
-  end
-
-  it "should ignore non-matching scopes" do
-    original = {
-      key: "value",
-      scope__key: "replaced",
-      another__key: "value"
-    }
-
-    expected = {
-      key: "replaced",
-      scope__key: "replaced",
-      another__key: "value"
-    }
-
-    expect(klass.scoped_hash_override(original, "scope")).to eq(expected)
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/shell_quote_test.rb

@@ -1,12 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/shell_quote"
-
-describe Vagrant::Util::ShellQuote do
-  subject { described_class }
-
-  it "quotes properly" do
-    expected = "foo '\\''bar'\\''"
-    expect(subject.escape("foo 'bar'", "'")).to eql(expected)
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/ssh_test.rb

@@ -1,239 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/platform"
-require "vagrant/util/ssh"
-
-describe Vagrant::Util::SSH do
-  include_context "unit"
-
-  describe "checking key permissions" do
-    let(:key_path) { temporary_file }
-
-    it "should do nothing on Windows" do
-      allow(Vagrant::Util::Platform).to receive(:windows?).and_return(true)
-
-      key_path.chmod(0700)
-
-      # Get the mode now and verify that it is untouched afterwards
-      mode = key_path.stat.mode
-      described_class.check_key_permissions(key_path)
-      expect(key_path.stat.mode).to eq(mode)
-    end
-
-    it "should fix the permissions", :skip_windows do
-      key_path.chmod(0644)
-
-      described_class.check_key_permissions(key_path)
-      expect(key_path.stat.mode).to eq(0100600)
-    end
-  end
-
-  describe "#exec" do
-    let(:ssh_info) {{
-      host: "localhost",
-      port: 2222,
-      username: "vagrant",
-      private_key_path: [temporary_file],
-      compression: true,
-      dsa_authentication: true
-    }}
-
-    let(:ssh_path) { "/usr/bin/ssh" }
-
-    it "searches original PATH for executable" do
-      expect(Vagrant::Util::Which).to receive(:which).with("ssh", original_path: true).and_return("valid-return")
-      allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-      described_class.exec(ssh_info)
-    end
-
-    it "searches current PATH if original PATH did not result in valid executable" do
-      expect(Vagrant::Util::Which).to receive(:which).with("ssh", original_path: true).and_return(nil)
-      expect(Vagrant::Util::Which).to receive(:which).with("ssh").and_return("valid-return")
-      allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-      described_class.exec(ssh_info)
-    end
-
-    it "raises an exception if there is no ssh" do
-      allow(Vagrant::Util::Which).to receive(:which).and_return(nil)
-
-      expect { described_class.exec(ssh_info) }.
-        to raise_error Vagrant::Errors::SSHUnavailable
-    end
-
-    it "raises an exception if there is no ssh and platform is windows" do
-      allow(Vagrant::Util::Which).to receive(:which).and_return(nil)
-      allow(Vagrant::Util::Platform).to receive(:windows?).and_return(true)
-
-      expect { described_class.exec(ssh_info) }.
-        to raise_error Vagrant::Errors::SSHUnavailableWindows
-    end
-
-    it "raises an exception if the platform is windows and uses PuTTY Link" do
-      allow(Vagrant::Util::Platform).to receive(:windows?).and_return(true)
-      allow(Vagrant::Util::Subprocess).to receive(:execute).
-        and_return(double("output", stdout: 'PuTTY Link'))
-
-      expect { described_class.exec(ssh_info) }.
-        to raise_error Vagrant::Errors::SSHIsPuttyLink
-    end
-
-    it "invokes SSH with options if subprocess is not allowed" do
-      allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-
-      expect(described_class.exec(ssh_info)).to eq(nil)
-      expect(Vagrant::Util::SafeExec).to have_received(:exec)
-        .with(ssh_path, "vagrant@localhost", "-p", "2222", "-o", "LogLevel=FATAL","-o", "Compression=yes", "-o", "DSAAuthentication=yes", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "IdentityFile=\"#{ssh_info[:private_key_path][0]}\"")
-    end
-
-    context "when disabling compression or dsa_authentication flags" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-        compression: false,
-        dsa_authentication: false
-      }}
-
-      it "does not include compression or dsa_authentication flags if disabled" do
-        allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-
-        expect(described_class.exec(ssh_info)).to eq(nil)
-        expect(Vagrant::Util::SafeExec).to have_received(:exec)
-          .with(ssh_path, "vagrant@localhost", "-p", "2222", "-o", "LogLevel=FATAL", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "IdentityFile=\"#{ssh_info[:private_key_path][0]}\"")
-      end
-    end
-
-    context "when verify_host_key is true" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-        verify_host_key: true
-      }}
-
-      it "does not disable StrictHostKeyChecking or set UserKnownHostsFile" do
-        allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-
-        expect(described_class.exec(ssh_info)).to eq(nil)
-        expect(Vagrant::Util::SafeExec).to have_received(:exec)
-          .with(ssh_path, "vagrant@localhost", "-p", "2222", "-o", "LogLevel=FATAL", "-o", "IdentityFile=\"#{ssh_info[:private_key_path][0]}\"")
-      end
-    end
-
-    context "when not on solaris not using plain mode or with keys_only enabled" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-        keys_only: true
-      }}
-
-      it "adds IdentitiesOnly as an option for ssh" do
-        allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-        allow(Vagrant::Util::Platform).to receive(:solaris?).and_return(false)
-
-        expect(described_class.exec(ssh_info, {plain_mode: true})).to eq(nil)
-        expect(Vagrant::Util::SafeExec).to have_received(:exec)
-          .with(ssh_path, "localhost", "-p", "2222", "-o", "LogLevel=FATAL", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null")
-      end
-    end
-
-    context "when forward_x11 is enabled" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-        forward_x11: true
-      }}
-
-      it "enables ForwardX11 options" do
-        allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-
-        expect(described_class.exec(ssh_info)).to eq(nil)
-        expect(Vagrant::Util::SafeExec).to have_received(:exec)
-          .with(ssh_path, "vagrant@localhost", "-p", "2222", "-o", "LogLevel=FATAL", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "IdentityFile=\"#{ssh_info[:private_key_path][0]}\"","-o", "ForwardX11=yes", "-o", "ForwardX11Trusted=yes")
-      end
-    end
-
-    context "when forward_agent is enabled" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-        forward_agent: true
-      }}
-
-      it "enables agent forwarding options" do
-        allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-
-        expect(described_class.exec(ssh_info)).to eq(nil)
-        expect(Vagrant::Util::SafeExec).to have_received(:exec)
-          .with(ssh_path, "vagrant@localhost", "-p", "2222", "-o", "LogLevel=FATAL", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "IdentityFile=\"#{ssh_info[:private_key_path][0]}\"","-o", "ForwardAgent=yes")
-      end
-    end
-
-    context "when extra_args is provided as an array" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-        extra_args: ["-L", "8008:localhost:80"]
-      }}
-
-      it "enables agent forwarding options" do
-        allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-
-        expect(described_class.exec(ssh_info)).to eq(nil)
-        expect(Vagrant::Util::SafeExec).to have_received(:exec)
-          .with(ssh_path, "vagrant@localhost", "-p", "2222", "-o", "LogLevel=FATAL", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "IdentityFile=\"#{ssh_info[:private_key_path][0]}\"", "-L", "8008:localhost:80")
-      end
-    end
-
-    context "when extra_args is provided as a string" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-        extra_args: "-6"
-      }}
-
-      it "enables agent forwarding options" do
-        allow(Vagrant::Util::SafeExec).to receive(:exec).and_return(nil)
-
-        expect(described_class.exec(ssh_info)).to eq(nil)
-        expect(Vagrant::Util::SafeExec).to have_received(:exec)
-          .with(ssh_path, "vagrant@localhost", "-p", "2222", "-o", "LogLevel=FATAL", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "IdentityFile=\"#{ssh_info[:private_key_path][0]}\"", "-6")
-      end
-    end
-
-    context "with subprocess enabled" do
-      let(:ssh_info) {{
-        host: "localhost",
-        port: 2222,
-        username: "vagrant",
-        private_key_path: [temporary_file],
-      }}
-
-      it "executes SSH in a subprocess with options and returns an exit code Fixnum" do
-        # mock out ChildProcess
-        process = double()
-        allow(ChildProcess).to receive(:build).and_return(process)
-        allow(process).to receive(:io).and_return(true)
-        allow(process.io).to receive(:inherit!).and_return(true)
-        allow(process).to receive(:start).and_return(true)
-        allow(process).to receive(:wait).and_return(true)
-
-        allow(process).to receive(:exit_code).and_return(0)
-
-        expect(described_class.exec(ssh_info, {subprocess: true})).to eq(0)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/string_block_editor_test.rb

@@ -1,106 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/string_block_editor"
-
-describe Vagrant::Util::StringBlockEditor do
-  describe "#keys" do
-    it "should return all the keys" do
-      data = <<DATA
-# VAGRANT-BEGIN: foo
-value
-# VAGRANT-END: foo
-another
-# VAGRANT-BEGIN: bar
-content
-# VAGRANT-END: bar
-DATA
-
-      expect(described_class.new(data).keys).to eq(["foo", "bar"])
-    end
-  end
-
-  describe "#delete" do
-    it "should delete nothing if the key doesn't exist" do
-      data = "foo"
-
-      instance = described_class.new(data)
-      instance.delete("key")
-      expect(instance.value).to eq(data)
-    end
-
-    it "should delete the matching blocks if they exist" do
-      data = <<DATA
-# VAGRANT-BEGIN: foo
-value
-# VAGRANT-END: foo
-# VAGRANT-BEGIN: foo
-another
-# VAGRANT-END: foo
-another
-# VAGRANT-BEGIN: bar
-content
-# VAGRANT-END: bar
-DATA
-
-      new_data = <<DATA
-another
-# VAGRANT-BEGIN: bar
-content
-# VAGRANT-END: bar
-DATA
-
-      instance = described_class.new(data)
-      instance.delete("foo")
-      expect(instance.value).to eq(new_data)
-    end
-  end
-
-  describe "#get" do
-    let(:data) do
-      <<DATA
-# VAGRANT-BEGIN: bar
-content
-# VAGRANT-END: bar
-# VAGRANT-BEGIN: /Users/studio/Projects (studio)/tubes/.vagrant/machines/web/vmware_fusion/vm.vmwarevm
-complex
-# VAGRANT-END: /Users/studio/Projects (studio)/tubes/.vagrant/machines/web/vmware_fusion/vm.vmwarevm
-DATA
-    end
-
-    subject { described_class.new(data) }
-
-    it "should get the value" do
-      expect(subject.get("bar")).to eq("content")
-    end
-
-    it "should get nil for nonexistent values" do
-      expect(subject.get("baz")).to be_nil
-    end
-
-    it "should get complicated keys" do
-      result = subject.get("/Users/studio/Projects (studio)/tubes/.vagrant/machines/web/vmware_fusion/vm.vmwarevm")
-      expect(result).to eq("complex")
-    end
-  end
-
-  describe "#insert" do
-    it "should insert the given key and value" do
-      data = <<DATA
-# VAGRANT-BEGIN: bar
-content
-# VAGRANT-END: bar
-DATA
-
-      new_data = <<DATA
-#{data.chomp}
-# VAGRANT-BEGIN: foo
-value
-# VAGRANT-END: foo
-DATA
-
-      instance = described_class.new(data)
-      instance.insert("foo", "value")
-      expect(instance.value).to eq(new_data)
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/subprocess_test.rb

@@ -1,111 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-require "vagrant/util/subprocess"
-
-describe Vagrant::Util::Subprocess do
-  describe '#execute' do
-    before do
-      # ensure we have `cat` and `echo` in our PATH so that we can run these
-      # tests successfully.
-      ['cat', 'echo'].each do |cmd|
-        if !Vagrant::Util::Which.which(cmd)
-          pending("cannot run subprocess tests without command #{cmd.inspect}")
-        end
-      end
-    end
-
-    let (:cat) { described_class.new('cat', :notify => [:stdin]) }
-
-    it 'yields the STDIN stream for the process if we set :notify => :stdin' do
-      echo = described_class.new('echo', 'hello world', :notify => [:stdin])
-      echo.execute do |type, data|
-        expect(type).to eq(:stdin)
-        expect(data).to be_a(::IO)
-      end
-    end
-
-    it 'can close STDIN' do
-      result = cat.execute do |type, stdin|
-        # We should be able to close STDIN without raising an exception
-        stdin.close
-      end
-
-      # we should exit successfully.
-      expect(result.exit_code).to eq(0)
-    end
-
-    it 'can write to STDIN correctly' do
-      data = "hello world\n"
-      result = cat.execute do |type, stdin|
-        stdin.write(data)
-        stdin.close
-      end
-
-      # we should exit successfully.
-      expect(result.exit_code).to eq(0)
-
-      # we should see our data as the output from `cat`
-      expect(result.stdout).to eq(data)
-    end
-  end
-
-  describe "#running?" do
-    context "when subprocess has not been started" do
-      it "should return false" do
-        sp = described_class.new("ls")
-        expect(sp.running?).to be(false)
-      end
-    end
-    context "when subprocess has completed" do
-      it "should return false" do
-        sp = described_class.new("ls")
-        sp.execute
-        expect(sp.running?).to be(false)
-      end
-    end
-    context "when subprocess is running" do
-      it "should return true" do
-        sp = described_class.new("sleep", "5")
-        thread = Thread.new{ sp.execute }
-        sleep(0.3)
-        expect(sp.running?).to be(true)
-        sp.stop
-        thread.join
-      end
-    end
-  end
-
-  describe "#stop" do
-    context "when subprocess has not been started" do
-      it "should return false" do
-        sp = described_class.new("ls")
-        expect(sp.stop).to be(false)
-      end
-    end
-
-    context "when subprocess has already completed" do
-      it "should return false" do
-        sp = described_class.new("ls")
-        sp.execute
-        expect(sp.stop).to be(false)
-      end
-    end
-
-    context "when subprocess is running" do
-      let(:sp){ described_class.new("sleep", "1") }
-      it "should return true" do
-        thread = Thread.new{ sp.execute }
-        sleep(0.1)
-        expect(sp.stop).to be(true)
-        thread.join
-      end
-
-      it "should stop the process" do
-        thread = Thread.new{ sp.execute }
-        sleep(0.1)
-        sp.stop
-        expect(sp.running?).to be(false)
-        thread.join
-      end
-    end
-  end
-end