vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,98 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/credential_scrubber"
-
-describe Vagrant::Util::CredentialScrubber do
-  subject{ Vagrant::Util::CredentialScrubber }
-
-  after{ subject.reset! }
-
-  describe ".url_scrubber" do
-    let(:user){ "vagrant-user" }
-    let(:password){ "vagrant-pass" }
-    let(:url){ "http://#{user}:#{password}@example.com" }
-
-    it "should remove user credentials from URL" do
-      result = subject.url_scrubber(url)
-      expect(result).not_to include(user)
-      expect(result).not_to include(password)
-    end
-  end
-
-  describe ".sensitive" do
-    it "should return a nil value" do
-      expect(subject.sensitive("value")).to be_nil
-    end
-
-    it "should add value to list of strings" do
-      subject.sensitive("value")
-      expect(subject.sensitive_strings).to include("value")
-    end
-
-    it "should remove duplicates" do
-      subject.sensitive("value")
-      subject.sensitive("value")
-      expect(subject.sensitive_strings.count("value")).to eq(1)
-    end
-
-    it "should not add an empty string" do
-      subject.sensitive("")
-      expect(subject.sensitive_strings).to be_empty
-    end
-
-    it "should type cast input to string" do
-      subject.sensitive(2)
-      expect(subject.sensitive_strings.first).to eq("2")
-    end
-  end
-
-  describe ".unsensitive" do
-    it "should return a nil value" do
-      expect(subject.unsensitive("value")).to be_nil
-    end
-
-    it "should remove value from list" do
-      subject.sensitive("value")
-      expect(subject.sensitive_strings).to include("value")
-      subject.unsensitive("value")
-      expect(subject.sensitive_strings).not_to include("value")
-    end
-  end
-
-  describe ".sensitive_strings" do
-    it "should always return the same array" do
-      expect(subject.sensitive_strings).to be(subject.sensitive_strings)
-    end
-  end
-
-  describe ".desensitize" do
-    let(:to_scrub){ [] }
-    let(:string){ "a line of text with my-birthday and my-cats-birthday embedded" }
-    before{ to_scrub.each{|s| subject.sensitive(s) }}
-
-    context "with no sensitive strings registered" do
-      it "should not modify the string" do
-        expect(subject.desensitize(string)).to eq(string)
-      end
-    end
-
-    context "with single value registered" do
-      let(:to_scrub){ ["my-birthday"] }
-
-      it "should remove the registered value" do
-        expect(subject.desensitize(string)).not_to include(to_scrub.first)
-      end
-    end
-
-    context "with multiple values registered" do
-      let(:to_scrub){ ["my-birthday", "my-cats-birthday"] }
-
-      it "should remove all registered values" do
-        result = subject.desensitize(string)
-        to_scrub.each do |registered_value|
-          expect(result).not_to include(registered_value)
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require 'vagrant/util/deep_merge'
-
-describe Vagrant::Util::DeepMerge do
-  it "should deep merge hashes" do
-    original = {
-      "foo" => {
-        "bar" => "baz",
-      },
-      "bar" => "blah",
-    }
-
-    other = {
-      "foo" => {
-        "bar" => "new",
-      },
-    }
-
-    result = described_class.deep_merge(original, other)
-    expect(result).to_not equal(original)
-    expect(result).to eq({
-      "foo" => {
-        "bar" => "new",
-      },
-      "bar" => "blah",
-    })
-  end
-end

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

@@ -1,255 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/downloader"
-
-describe Vagrant::Util::Downloader do
-  let(:source) { "foo" }
-  let(:destination) { "bar" }
-  let(:exit_code) { 0 }
-
-  let(:subprocess_result) do
-    double("subprocess_result").tap do |result|
-      allow(result).to receive(:exit_code).and_return(exit_code)
-      allow(result).to receive(:stderr).and_return("")
-    end
-  end
-
-  subject { described_class.new(source, destination) }
-
-  before :each do
-    allow(Vagrant::Util::Subprocess).to receive(:execute).and_return(subprocess_result)
-  end
-
-  describe "#download!" do
-    let(:curl_options) {
-      ["-q", "--fail", "--location", "--max-redirs", "10",
-       "--verbose", "--user-agent", described_class::USER_AGENT,
-       "--output", destination, source, {}]
-    }
-
-    context "with a good exit status" do
-      let(:exit_code) { 0 }
-
-      it "downloads the file and returns true" do
-        expect(Vagrant::Util::Subprocess).to receive(:execute).
-          with("curl", *curl_options).
-          and_return(subprocess_result)
-
-        expect(subject.download!).to be
-      end
-    end
-
-    context "with a bad exit status" do
-      let(:exit_code) { 1 }
-      let(:subprocess_result_416) do
-        double("subprocess_result").tap do |result|
-          allow(result).to receive(:exit_code).and_return(exit_code)
-          allow(result).to receive(:stderr).and_return("curl: (416) The download is fine")
-        end
-      end
-
-      it "continues on if a 416 was received" do
-        expect(Vagrant::Util::Subprocess).to receive(:execute).
-          with("curl", *curl_options).
-          and_return(subprocess_result_416)
-
-        expect(subject.download!).to be(true)
-      end
-
-      it "raises an exception" do
-        expect(Vagrant::Util::Subprocess).to receive(:execute).
-          with("curl", *curl_options).
-          and_return(subprocess_result)
-
-        expect { subject.download! }.
-          to raise_error(Vagrant::Errors::DownloaderError)
-      end
-    end
-
-    context "with a username and password" do
-      it "downloads the file with the proper flags" do
-        original_source = source
-        source  = "http://foo:bar@baz.com/box.box"
-        subject = described_class.new(source, destination)
-
-        i = curl_options.index(original_source)
-        curl_options[i] = "http://baz.com/box.box"
-
-        i = curl_options.index("--output")
-        curl_options.insert(i, "foo:bar")
-        curl_options.insert(i, "-u")
-
-        expect(Vagrant::Util::Subprocess).to receive(:execute).
-          with("curl", *curl_options).
-          and_return(subprocess_result)
-
-        expect(subject.download!).to be(true)
-      end
-    end
-
-    context "with an urlescaped username and password" do
-      it "downloads the file with unescaped credentials" do
-        original_source = source
-        source  = "http://fo%5Eo:b%40r@baz.com/box.box"
-        subject = described_class.new(source, destination)
-
-        i = curl_options.index(original_source)
-        curl_options[i] = "http://baz.com/box.box"
-
-        i = curl_options.index("--output")
-        curl_options.insert(i, "fo^o:b@r")
-        curl_options.insert(i, "-u")
-
-        expect(Vagrant::Util::Subprocess).to receive(:execute).
-          with("curl", *curl_options).
-          and_return(subprocess_result)
-
-        expect(subject.download!).to be(true)
-      end
-    end
-
-    context "with checksum" do
-      let(:checksum_expected_value){ 'MD5_CHECKSUM_VALUE' }
-      let(:checksum_invalid_value){ 'INVALID_VALUE' }
-      let(:digest){ double("digest") }
-
-      before do
-        allow(digest).to receive(:file).and_return(digest)
-      end
-
-      [Digest::MD5, Digest::SHA1].each do |klass|
-        short_name = klass.to_s.split("::").last.downcase
-
-        context "using #{short_name} digest" do
-          subject { described_class.new(source, destination, short_name.to_sym => checksum_expected_value) }
-
-          context "that matches expected value" do
-            before do
-              expect(klass).to receive(:new).and_return(digest)
-              expect(digest).to receive(:hexdigest).and_return(checksum_expected_value)
-            end
-
-            it "should not raise an exception" do
-              expect(subject.download!).to be(true)
-            end
-          end
-
-          context "that does not match expected value" do
-            before do
-              expect(klass).to receive(:new).and_return(digest)
-              expect(digest).to receive(:hexdigest).and_return(checksum_invalid_value)
-            end
-
-            it "should raise an exception" do
-              expect{ subject.download! }.to raise_error(Vagrant::Errors::DownloaderChecksumError)
-            end
-          end
-        end
-      end
-
-      context "using both md5 and sha1 digests" do
-        context "that both match expected values" do
-          subject { described_class.new(source, destination, md5: checksum_expected_value, sha1: checksum_expected_value) }
-
-          before do
-            expect(Digest::MD5).to receive(:new).and_return(digest)
-            expect(Digest::SHA1).to receive(:new).and_return(digest)
-            expect(digest).to receive(:hexdigest).and_return(checksum_expected_value).exactly(2).times
-          end
-
-          it "should not raise an exception" do
-            expect(subject.download!).to be(true)
-          end
-        end
-
-        context "that only sha1 matches expected value" do
-          subject { described_class.new(source, destination, md5: checksum_invalid_value, sha1: checksum_expected_value) }
-
-          before do
-            allow(Digest::MD5).to receive(:new).and_return(digest)
-            allow(Digest::SHA1).to receive(:new).and_return(digest)
-            expect(digest).to receive(:hexdigest).and_return(checksum_expected_value).at_least(:once)
-          end
-
-          it "should raise an exception" do
-            expect{ subject.download! }.to raise_error(Vagrant::Errors::DownloaderChecksumError)
-          end
-        end
-
-        context "that only md5 matches expected value" do
-          subject { described_class.new(source, destination, md5: checksum_expected_value, sha1: checksum_invalid_value) }
-
-          before do
-            allow(Digest::MD5).to receive(:new).and_return(digest)
-            allow(Digest::SHA1).to receive(:new).and_return(digest)
-            expect(digest).to receive(:hexdigest).and_return(checksum_expected_value).at_least(:once)
-          end
-
-          it "should raise an exception" do
-            expect{ subject.download! }.to raise_error(Vagrant::Errors::DownloaderChecksumError)
-          end
-        end
-
-        context "that none match expected value" do
-          subject { described_class.new(source, destination, md5: checksum_invalid_value, sha1: checksum_invalid_value) }
-
-          before do
-            allow(Digest::MD5).to receive(:new).and_return(digest)
-            allow(Digest::SHA1).to receive(:new).and_return(digest)
-            expect(digest).to receive(:hexdigest).and_return(checksum_expected_value).at_least(:once)
-          end
-
-          it "should raise an exception" do
-            expect{ subject.download! }.to raise_error(Vagrant::Errors::DownloaderChecksumError)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#head" do
-    let(:curl_options) {
-      ["-q", "--fail", "--location", "--max-redirs", "10", "--verbose", "--user-agent", described_class::USER_AGENT, source, {}]
-    }
-
-    it "returns the output" do
-      allow(subprocess_result).to receive(:stdout).and_return("foo")
-
-      options = curl_options.dup
-      options.unshift("-I")
-
-      expect(Vagrant::Util::Subprocess).to receive(:execute).
-        with("curl", *options).and_return(subprocess_result)
-
-      expect(subject.head).to eq("foo")
-    end
-  end
-
-  describe "#options" do
-    describe "CURL_CA_BUNDLE" do
-      let(:ca_bundle){ "CUSTOM_CA_BUNDLE" }
-
-      context "when running within the installer" do
-        before do
-          allow(Vagrant).to receive(:in_installer?).and_return(true)
-          allow(ENV).to receive(:[]).with("CURL_CA_BUNDLE").and_return(ca_bundle)
-        end
-
-        it "should set custom CURL_CA_BUNDLE in subprocess ENV" do
-          _, subprocess_opts = subject.send(:options)
-          expect(subprocess_opts[:env]).not_to be_nil
-          expect(subprocess_opts[:env]["CURL_CA_BUNDLE"]).to eql(ca_bundle)
-        end
-      end
-
-      context "when not running within the installer" do
-        before{ allow(Vagrant).to receive(:installer?).and_return(false) }
-
-        it "should not set custom CURL_CA_BUNDLE in subprocess ENV" do
-          _, subprocess_opts = subject.send(:options)
-          expect(subprocess_opts[:env]).to be_nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require 'vagrant/util/env'
-
-describe Vagrant::Util::Env do
-  context "with valid environment variables" do
-    before do
-      ENV["VAGRANT_TEST"] = "1"
-    end
-
-    after do
-      ENV.delete("VAGRANT_TEST")
-    end
-
-    it "should execute block with original environment variables" do
-      Vagrant::Util::Env.with_original_env do
-        expect(ENV["VAGRANT_TEST"]).to be_nil
-      end
-    end
-
-    it "should replace environment variables after executing block" do
-      Vagrant::Util::Env.with_original_env do
-        expect(ENV["VAGRANT_TEST"]).to be_nil
-      end
-      expect(ENV["VAGRANT_TEST"]).to eq("1")
-    end
-  end
-
-  context "with invalid environment variables" do
-    it "should not attempt to restore invalid environment variable" do
-      invalid_vars = ENV.to_hash.merge("VAGRANT_OLD_ENV_" => "INVALID")
-      mock = expect(ENV).to receive(:each)
-      invalid_vars.each do |k,v|
-        mock.and_yield(k, v)
-      end
-      expect do
-        Vagrant::Util::Env.with_original_env do
-          expect(ENV["VAGRANT_TEST"]).to be_nil
-        end
-      end.not_to raise_error
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-require 'digest/md5'
-require 'digest/sha1'
-
-require 'vagrant/util/file_checksum'
-
-describe FileChecksum do
-  include_context "unit"
-
-  let(:environment) { isolated_environment }
-
-  it "should return a valid checksum for a file" do
-    file = environment.workdir.join("file")
-    file.open("w+") { |f| f.write("HELLO!") }
-
-    # Check multiple digests
-    instance = described_class.new(file, Digest::MD5)
-    expect(instance.checksum).to eq("9ac96c64417b5976a58839eceaa77956")
-
-    instance = described_class.new(file, Digest::SHA1)
-    expect(instance.checksum).to eq("264b207c7913e461c43d0f63d2512f4017af4755")
-  end
-end

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

@@ -1,38 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/hash_with_indifferent_access"
-
-describe Vagrant::Util::HashWithIndifferentAccess do
-  let(:instance) { described_class.new }
-
-  it "is a Hash" do
-    expect(instance).to be_kind_of(Hash)
-  end
-
-  it "allows indifferent access when setting with a string" do
-    instance["foo"] = "bar"
-    expect(instance[:foo]).to eq("bar")
-  end
-
-  it "allows indifferent access when setting with a symbol" do
-    instance[:foo] = "bar"
-    expect(instance["foo"]).to eq("bar")
-  end
-
-  it "allows indifferent key lookup" do
-    instance["foo"] = "bar"
-    expect(instance.key?(:foo)).to be
-    expect(instance.key?(:foo)).to be
-    expect(instance.include?(:foo)).to be
-    expect(instance.member?(:foo)).to be
-  end
-
-  it "allows for defaults to be passed in via an initializer block" do
-    instance = described_class.new do |h,k|
-      h[k] = "foo"
-    end
-
-    expect(instance[:foo]).to eq("foo")
-    expect(instance["bar"]).to eq("foo")
-  end
-end

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

@@ -1,53 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "socket"
-
-require "vagrant/util/is_port_open"
-
-describe Vagrant::Util::IsPortOpen do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::IsPortOpen
-    end
-  end
-
-  let(:open_port)   { 52811 }
-  let(:closed_port) { 52811 }
-
-  it "should report open ports" do
-    # Start a thread which listens on a port
-    thr = Thread.new do
-      server = TCPServer.new(open_port)
-      Thread.current[:running] = true
-
-      # Wait until we're told to die
-      Thread.current[:die]     = false
-      while !Thread.current[:die]
-        Thread.pass
-      end
-
-      # Die!
-      server.close
-    end
-
-    # Wait until the server is running
-    while !thr[:running]
-      Thread.pass
-    end
-
-    # Verify that we report the port is open
-    expect(klass.is_port_open?("127.0.0.1", open_port)).to be
-
-    # Kill the thread
-    thr[:die] = true
-    thr.join
-  end
-
-  it "should report closed ports" do
-    # This CAN fail, since port 52811 might actually be in use, but I'm
-    # not sure what to do except choose some random port and hope for the
-    # best, really.
-    expect(klass.is_port_open?("127.0.0.1", closed_port)).not_to be
-  end
-end
-

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

@@ -1,34 +0,0 @@
-require "openssl"
-
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/keypair"
-
-describe Vagrant::Util::Keypair do
-  describe ".create" do
-    it "generates a usable keypair with no password" do
-      # I don't know how to validate the final return value yet...
-      pubkey, privkey, _ = described_class.create
-
-      pubkey  = OpenSSL::PKey::RSA.new(pubkey)
-      privkey = OpenSSL::PKey::RSA.new(privkey)
-
-      encrypted = pubkey.public_encrypt("foo")
-      decrypted = privkey.private_decrypt(encrypted)
-
-      expect(decrypted).to eq("foo")
-    end
-
-    it "generates a keypair that requires a password" do
-      pubkey, privkey, _ = described_class.create("password")
-
-      pubkey  = OpenSSL::PKey::RSA.new(pubkey)
-      privkey = OpenSSL::PKey::RSA.new(privkey, "password")
-
-      encrypted = pubkey.public_encrypt("foo")
-      decrypted = privkey.private_decrypt(encrypted)
-
-      expect(decrypted).to eq("foo")
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/line_ending_helpers"
-
-describe Vagrant::Util::LineEndingHelpers do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::LineEndingHelpers
-    end
-  end
-
-  it "should convert DOS to unix-style line endings" do
-    expect(klass.dos_to_unix("foo\r\nbar\r\n")).to eq("foo\nbar\n")
-  end
-end
-

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

@@ -1,29 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/network_ip"
-
-describe Vagrant::Util::NetworkIP do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::NetworkIP
-    end
-  end
-
-  describe "network address" do
-    it "calculates it properly" do
-      expect(klass.network_address("192.168.2.234", "255.255.255.0")).to eq("192.168.2.0")
-    end
-
-    it "calculates it properly with integer submask" do
-      expect(klass.network_address("192.168.2.234", "24")).to eq("192.168.2.0")
-    end
-
-    it "calculates it properly for IPv6" do
-      expect(klass.network_address("fde4:8dba:82e1::c4", "64")).to eq("fde4:8dba:82e1::")
-    end
-
-    it "calculates it properly for IPv6" do
-      expect(klass.network_address("fde4:8dba:82e1::c4", 64)).to eq("fde4:8dba:82e1::")
-    end
-  end
-end