vagrant-aws-mkubenka 0.7.2.pre.14 → 0.7.2.pre.16

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/test/unit/vagrant/ui_test.rb

@@ -1,395 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-
-describe Vagrant::UI::Basic do
-  context "in general" do
-    it "outputs within the a new thread" do
-      current = Thread.current.object_id
-
-      expect(subject).to receive(:safe_puts).with { |*args|
-        expect(Thread.current.object_id).to_not eq(current)
-        true
-      }
-
-      subject.output("foo")
-    end
-
-    it "outputs using `puts` by default" do
-      expect(subject).to receive(:safe_puts).with { |message, **opts|
-        expect(opts[:printer]).to eq(:puts)
-        true
-      }
-
-      subject.output("foo")
-    end
-
-    it "outputs using `print` if new_line is false" do
-      expect(subject).to receive(:safe_puts).with { |message, **opts|
-        expect(opts[:printer]).to eq(:print)
-        true
-      }
-
-      subject.output("foo", new_line: false)
-    end
-
-    it "outputs using `print` if new_line is false" do
-      expect(subject).to receive(:safe_puts).with { |message, **opts|
-        expect(opts[:printer]).to eq(:print)
-        true
-      }
-
-      subject.output("foo", new_line: false)
-    end
-
-    it "outputs to the assigned stdout" do
-      stdout = StringIO.new
-      subject.stdout = stdout
-
-      expect(subject).to receive(:safe_puts).with { |message, **opts|
-        expect(opts[:io]).to be(stdout)
-        true
-      }
-
-      subject.output("foo")
-    end
-
-    it "outputs to stdout by default" do
-      expect(subject.stdout).to be($stdout)
-    end
-
-    it "outputs to the assigned stderr for errors" do
-      stderr = StringIO.new
-      subject.stderr = stderr
-
-      expect(subject).to receive(:safe_puts).with { |message, **opts|
-        expect(opts[:io]).to be(stderr)
-        true
-      }
-
-      subject.error("foo")
-    end
-
-    it "outputs to stderr for errors by default" do
-      expect(subject.stderr).to be($stderr)
-    end
-  end
-
-  context "#color?" do
-    it "returns false" do
-      expect(subject.color?).to be(false)
-    end
-  end
-
-  context "#detail" do
-    it "outputs details" do
-      expect(subject).to receive(:safe_puts).with { |message, **opts|
-        expect(message).to eq("foo")
-        true
-      }
-
-      subject.detail("foo")
-    end
-
-    it "doesn't output details if disabled" do
-      expect(subject).to receive(:safe_puts).never
-
-      subject.opts[:hide_detail] = true
-      subject.detail("foo")
-    end
-  end
-end
-
-describe Vagrant::UI::Colored do
-  include_context "unit"
-
-  describe "#color?" do
-    it "returns true" do
-      expect(subject.color?).to be(true)
-    end
-  end
-
-  describe "#detail" do
-    it "colors output nothing by default" do
-      expect(subject).to receive(:safe_puts).with("\033[0mfoo\033[0m", anything)
-      subject.detail("foo")
-    end
-
-    it "does not bold by default with a color" do
-      expect(subject).to receive(:safe_puts).with { |message, *args|
-        expect(message).to start_with("\033[0;31m")
-        expect(message).to end_with("\033[0m")
-      }
-
-      subject.detail("foo", color: :red)
-    end
-  end
-
-  describe "#error" do
-    it "colors red" do
-      expect(subject).to receive(:safe_puts).with { |message, *args|
-        expect(message).to start_with("\033[0;31m")
-        expect(message).to end_with("\033[0m")
-      }
-
-      subject.error("foo")
-    end
-  end
-
-  describe "#output" do
-    it "colors output nothing by default, no bold" do
-      expect(subject).to receive(:safe_puts).with("\033[0mfoo\033[0m", anything)
-      subject.output("foo")
-    end
-
-    it "doesn't use a color if default color" do
-      expect(subject).to receive(:safe_puts).with("\033[0mfoo\033[0m", anything)
-      subject.output("foo", color: :default)
-    end
-
-    it "bolds output without color if specified" do
-      expect(subject).to receive(:safe_puts).with("\033[1mfoo\033[0m", anything)
-      subject.output("foo", bold: true)
-    end
-
-    it "colors output to color specified in global opts" do
-      subject.opts[:color] = :red
-
-      expect(subject).to receive(:safe_puts).with { |message, *args|
-        expect(message).to start_with("\033[0;31m")
-        expect(message).to end_with("\033[0m")
-      }
-
-      subject.output("foo")
-    end
-
-    it "colors output to specified color over global opts" do
-      subject.opts[:color] = :red
-
-      expect(subject).to receive(:safe_puts).with { |message, *args|
-        expect(message).to start_with("\033[0;32m")
-        expect(message).to end_with("\033[0m")
-      }
-
-      subject.output("foo", color: :green)
-    end
-
-    it "bolds the output if specified" do
-      subject.opts[:color] = :red
-
-      expect(subject).to receive(:safe_puts).with { |message, *args|
-        expect(message).to start_with("\033[1;31m")
-        expect(message).to end_with("\033[0m")
-      }
-
-      subject.output("foo", bold: true)
-    end
-  end
-
-  describe "#success" do
-    it "colors green" do
-      expect(subject).to receive(:safe_puts).with { |message, *args|
-        expect(message).to start_with("\033[0;32m")
-        expect(message).to end_with("\033[0m")
-      }
-
-      subject.success("foo")
-    end
-  end
-
-  describe "#warn" do
-    it "colors yellow" do
-      expect(subject).to receive(:safe_puts).with { |message, *args|
-        expect(message).to start_with("\033[0;33m")
-        expect(message).to end_with("\033[0m")
-      }
-
-      subject.warn("foo")
-    end
-  end
-end
-
-describe Vagrant::UI::MachineReadable do
-  describe "#ask" do
-    it "raises an exception" do
-      expect { subject.ask("foo") }.
-        to raise_error(Vagrant::Errors::UIExpectsTTY)
-    end
-  end
-
-  [:detail, :warn, :error, :info, :output, :success].each do |method|
-    describe "##{method}" do
-      it "outputs UI type to the machine-readable output" do
-        expect(subject).to receive(:safe_puts).with { |message|
-          parts = message.split(",")
-          expect(parts.length).to eq(5)
-          expect(parts[1]).to eq("")
-          expect(parts[2]).to eq("ui")
-          expect(parts[3]).to eq(method.to_s)
-          expect(parts[4]).to eq("foo")
-          true
-        }
-
-        subject.send(method, "foo")
-      end
-    end
-  end
-
-  describe "#machine" do
-    it "is formatted properly" do
-      expect(subject).to receive(:safe_puts).with { |message|
-        parts = message.split(",")
-        expect(parts.length).to eq(5)
-        expect(parts[1]).to eq("")
-        expect(parts[2]).to eq("type")
-        expect(parts[3]).to eq("data")
-        expect(parts[4]).to eq("another")
-        true
-      }
-
-      subject.machine(:type, "data", "another")
-    end
-
-    it "includes a target if given" do
-      expect(subject).to receive(:safe_puts).with { |message|
-        parts = message.split(",")
-        expect(parts.length).to eq(4)
-        expect(parts[1]).to eq("boom")
-        expect(parts[2]).to eq("type")
-        expect(parts[3]).to eq("data")
-        true
-      }
-
-      subject.machine(:type, "data", target: "boom")
-    end
-
-    it "replaces commas" do
-      expect(subject).to receive(:safe_puts).with { |message|
-        parts = message.split(",")
-        expect(parts.length).to eq(4)
-        expect(parts[3]).to eq("foo%!(VAGRANT_COMMA)bar")
-        true
-      }
-
-      subject.machine(:type, "foo,bar")
-    end
-
-    it "replaces newlines" do
-      expect(subject).to receive(:safe_puts).with { |message|
-        parts = message.split(",")
-        expect(parts.length).to eq(4)
-        expect(parts[3]).to eq("foo\\nbar\\r")
-        true
-      }
-
-      subject.machine(:type, "foo\nbar\r")
-    end
-
-    # This is for a bug where JSON parses are frozen and an
-    # exception was being raised.
-    it "works properly with frozen string arguments" do
-      expect(subject).to receive(:safe_puts).with { |message|
-        parts = message.split(",")
-        expect(parts.length).to eq(4)
-        expect(parts[3]).to eq("foo\\nbar\\r")
-        true
-      }
-
-      subject.machine(:type, "foo\nbar\r".freeze)
-    end
-  end
-end
-
-describe Vagrant::UI::Prefixed do
-  let(:prefix) { "foo" }
-  let(:ui)     { Vagrant::UI::Basic.new }
-
-  subject { described_class.new(ui, prefix) }
-
-  describe "#initialize_copy" do
-    it "duplicates the underlying ui too" do
-      another = subject.dup
-      expect(another.opts).to_not equal(subject.opts)
-    end
-  end
-
-  describe "#ask" do
-    it "does not request bolding" do
-      expect(ui).to receive(:ask).with("    #{prefix}: foo", bold: false, target: prefix)
-      subject.ask("foo")
-    end
-  end
-
-  describe "#detail" do
-    it "prefixes with spaces and the message" do
-      expect(ui).to receive(:safe_puts).with("    #{prefix}: foo", anything)
-      subject.detail("foo")
-    end
-
-    it "prefixes every line" do
-      expect(ui).to receive(:detail).with(
-        "    #{prefix}: foo\n    #{prefix}: bar", bold: false, target: prefix)
-      subject.detail("foo\nbar")
-    end
-
-    it "doesn't prefix if requested" do
-      expect(ui).to receive(:detail).with("foo", prefix: false, bold: false, target: prefix)
-      subject.detail("foo", prefix: false)
-    end
-  end
-
-  describe "#machine" do
-    it "sets the target option" do
-      expect(ui).to receive(:machine).with(:foo, target: prefix)
-      subject.machine(:foo)
-    end
-
-    it "preserves existing options" do
-      expect(ui).to receive(:machine).with(:foo, :bar, foo: :bar, target: prefix)
-      subject.machine(:foo, :bar, foo: :bar)
-    end
-  end
-
-  describe "#opts" do
-    it "is the parent's opts" do
-      ui.stub(opts: Object.new)
-      expect(subject.opts).to be(ui.opts)
-    end
-  end
-
-  describe "#output" do
-    it "prefixes with an arrow and the message" do
-      expect(ui).to receive(:output).with("==> #{prefix}: foo", anything)
-      subject.output("foo")
-    end
-
-    it "prefixes with spaces if requested" do
-      expect(ui).to receive(:output).with("    #{prefix}: foo", anything)
-      subject.output("foo", prefix_spaces: true)
-    end
-
-    it "prefixes every line" do
-      expect(ui).to receive(:output).with("==> #{prefix}: foo\n==> #{prefix}: bar", anything)
-      subject.output("foo\nbar")
-    end
-
-    it "doesn't prefix if requestsed" do
-      expect(ui).to receive(:output).with("foo", prefix: false, bold: true, target: prefix)
-      subject.output("foo", prefix: false)
-    end
-
-    it "requests bolding" do
-      expect(ui).to receive(:output).with("==> #{prefix}: foo", bold: true, target: prefix)
-      subject.output("foo")
-    end
-
-    it "does not request bolding if class-level disabled" do
-      ui.opts[:bold] = false
-      expect(ui).to receive(:output).with("==> #{prefix}: foo", target: prefix)
-      subject.output("foo")
-    end
-
-    it "prefixes with another prefix if requested" do
-      expect(ui).to receive(:output).with("==> bar: foo", anything)
-      subject.output("foo", target: "bar")
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/test/unit/vagrant/util/downloader_test.rb

@@ -1,213 +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|
-      result.stub(exit_code: exit_code)
-      result.stub(stderr: "")
-    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",
-       "--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 }
-
-      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", "--user-agent", described_class::USER_AGENT, source, {}]
-    }
-
-    it "returns the output" do
-      subprocess_result.stub(stdout: "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
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/test/unit/vagrant/util/platform_test.rb

@@ -1,67 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/platform"
-
-describe Vagrant::Util::Platform do
-  include_context "unit"
-
-  subject { described_class }
-
-  describe "#cygwin?" do
-    before do
-      allow(subject).to receive(:platform).and_return("test")
-      described_class.reset!
-    end
-
-    after do
-      described_class.reset!
-    end
-
-    around do |example|
-      with_temp_env(VAGRANT_DETECTED_OS: "nope", PATH: "") do
-        example.run
-      end
-    end
-
-    it "returns true if VAGRANT_DETECTED_OS includes cygwin" do
-      with_temp_env(VAGRANT_DETECTED_OS: "cygwin") do
-        expect(subject).to be_cygwin
-      end
-    end
-
-    it "returns true if platform has cygwin" do
-      allow(subject).to receive(:platform).and_return("cygwin")
-      expect(subject).to be_cygwin
-    end
-
-    it "returns true if the PATH contains cygwin" do
-      with_temp_env(PATH: "C:/cygwin") do
-        expect(subject).to be_cygwin
-      end
-    end
-
-    it "returns false if nothing is available" do
-      expect(subject).to_not be_cygwin
-    end
-  end
-
-  describe "#fs_real_path" do
-    it "fixes drive letters on Windows", :windows do
-      expect(described_class.fs_real_path("c:/foo").to_s).to eql("C:/foo")
-    end
-  end
-
-  describe "#windows_unc_path" do
-    it "correctly converts a path" do
-      expect(described_class.windows_unc_path("c:/foo").to_s).to eql("\\\\?\\c:\\foo")
-    end
-
-    context "when given a UNC path" do
-      let(:unc_path){ "\\\\srvname\\path" }
-
-      it "should not modify the path" do
-        expect(described_class.windows_unc_path(unc_path).to_s).to eql(unc_path)
-      end
-    end
-  end
-end