vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,409 +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(any_args) { |*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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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
-
-  context "with sensitive data" do
-    let(:password){ "my-birthday" }
-    let(:output){ "You're password is: #{password}" }
-
-    before{ Vagrant::Util::CredentialScrubber.sensitive(password) }
-
-    it "should remove sensitive information from the output" do
-      expect(subject).to receive(:safe_puts).with(any_args) do |message, **opts|
-        expect(message).not_to include(password)
-      end
-      subject.detail(output)
-    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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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(any_args) { |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
-      allow(ui).to receive(:opts).and_return(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 requested" 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.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/util/ansi_escape_code_remover_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/ansi_escape_code_remover"
-
-describe Vagrant::Util::ANSIEscapeCodeRemover do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::ANSIEscapeCodeRemover
-    end
-  end
-
-  it "should remove ANSI escape codes" do
-    expect(klass.remove_ansi_escape_codes("\e[Hyo")).to eq("yo")
-  end
-end
-

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

@@ -1,183 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/checkpoint_client"
-
-describe Vagrant::Util::CheckpointClient do
-  include_context "unit"
-
-  let(:iso_env) { isolated_environment }
-  let(:env)     { iso_env.create_vagrant_env }
-  let(:result) { {} }
-  let(:prefixed_ui) { double("prefixed_ui") }
-
-  subject{ Vagrant::Util::CheckpointClient.instance }
-
-  after{ subject.reset! }
-  before do
-    allow(subject).to receive(:result).and_return(result)
-    allow(Vagrant::UI::Prefixed).to receive(:new).and_return(prefixed_ui)
-  end
-
-  it "should not be enabled by default" do
-    expect(subject.enabled).to be(false)
-  end
-
-  describe "#setup" do
-    let(:environment){ {} }
-    before{ with_temp_env(environment){ subject.setup(env) } }
-
-    it "should enable after setup" do
-      expect(subject.enabled).to be(true)
-    end
-
-    it "should generate required paths" do
-      expect(subject.files).not_to be_empty
-    end
-
-    context "with VAGRANT_CHECKPOINT_DISABLE set" do
-      let(:environment){ {"VAGRANT_CHECKPOINT_DISABLE" => "1"} }
-
-      it "should not be enabled after setup" do
-        expect(subject.enabled).to be(false)
-      end
-    end
-  end
-
-  describe "#check" do
-    context "without #setup" do
-      it "should not start the check" do
-        expect(Thread).not_to receive(:new)
-        subject.check
-      end
-    end
-
-    context "with setup" do
-      before{ subject.setup(env) }
-
-      it "should start the check" do
-        expect(Thread).to receive(:new)
-        subject.check
-      end
-
-      it "should call checkpoint" do
-        expect(Thread).to receive(:new).and_yield
-        expect(Checkpoint).to receive(:check)
-        subject.check
-      end
-    end
-  end
-
-  describe "#display" do
-    it "should only display once" do
-      expect(subject).to receive(:version_check).once
-      expect(subject).to receive(:alerts_check).once
-
-      2.times{ subject.display }
-    end
-
-    it "should not display cached information" do
-      expect(subject).to receive(:result).and_return("cached" => true).at_least(:once)
-      expect(subject).not_to receive(:version_check)
-      expect(subject).not_to receive(:alerts_check)
-
-      subject.display
-    end
-  end
-
-  describe "#alerts_check" do
-    let(:critical){
-      [{"level" => "critical", "message" => "critical message",
-        "url" => "http://example.com", "date" => Time.now.to_i}]
-    }
-    let(:warn){
-      [{"level" => "warn", "message" => "warn message",
-        "url" => "http://example.com", "date" => Time.now.to_i}]
-    }
-    let(:info){
-      [{"level" => "info", "message" => "info message",
-        "url" => "http://example.com", "date" => Time.now.to_i}]
-    }
-
-    before{ subject.setup(env) }
-
-    context "with no alerts" do
-      it "should not display alerts" do
-        expect(prefixed_ui).not_to receive(:info)
-        subject.alerts_check
-      end
-    end
-
-    context "with critical alerts" do
-      let(:result) { {"alerts" => critical} }
-
-      it "should display critical alert" do
-        expect(prefixed_ui).to receive(:error)
-        subject.alerts_check
-      end
-    end
-
-    context "with warn alerts" do
-      let(:result) { {"alerts" => warn} }
-
-      it "should display warn alerts" do
-        expect(prefixed_ui).to receive(:warn)
-        subject.alerts_check
-      end
-    end
-
-    context "with info alerts" do
-      let(:result) { {"alerts" => info} }
-
-      it "should display info alerts" do
-        expect(prefixed_ui).to receive(:info)
-        subject.alerts_check
-      end
-    end
-
-    context "with mixed alerts" do
-      let(:result) { {"alerts" => info + warn + critical} }
-
-      it "should display all alert types" do
-        expect(prefixed_ui).to receive(:info)
-        expect(prefixed_ui).to receive(:warn)
-        expect(prefixed_ui).to receive(:error)
-
-        subject.alerts_check
-      end
-    end
-  end
-
-  describe "#version_check" do
-    before{ subject.setup(env) }
-
-    let(:new_version){ Gem::Version.new(Vagrant::VERSION).bump.to_s }
-    let(:old_version){ Gem::Version.new("1.0.0") }
-
-    context "latest version is same as current version" do
-      let(:result) { {"current_version" => Vagrant::VERSION } }
-
-      it "should not display upgrade information" do
-        expect(prefixed_ui).not_to receive(:info)
-        subject.version_check
-      end
-    end
-
-    context "latest version is older than current version" do
-      let(:result) { {"current_version" => old_version} }
-
-      it "should not display upgrade information" do
-        expect(prefixed_ui).not_to receive(:info)
-        subject.version_check
-      end
-    end
-
-    context "latest version is newer than current version" do
-      let(:result) { {"current_version" => new_version} }
-
-      it "should not display upgrade information" do
-        expect(prefixed_ui).not_to receive(:info).at_least(:once)
-        subject.version_check
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/command_deprecation"
-
-describe Vagrant::Util do
-  include_context "unit"
-
-  let(:app){ lambda{|env|} }
-  let(:argv){[]}
-  let(:env){ {ui: Vagrant::UI::Silent.new} }
-
-  let(:command_class) do
-    Class.new(Vagrant.plugin("2", :command)) do
-      def self.synopsis
-        "base synopsis"
-      end
-      def self.name
-        "VagrantPlugins::CommandTest::Command"
-      end
-      def execute
-        @env[:ui].info("COMMAND CONTENT")
-        0
-      end
-    end
-  end
-
-  let(:command){ command_class.new(app, env) }
-
-  describe Vagrant::Util::CommandDeprecation do
-    before{ command_class.include(Vagrant::Util::CommandDeprecation) }
-
-    it "should add deprecation warning to synopsis" do
-      expect(command_class.synopsis).to include('[DEPRECATED]')
-      command.class.synopsis
-    end
-
-    it "should add deprecation warning to #execute" do
-      expect(env[:ui]).to receive(:warn).with(/DEPRECATION WARNING/)
-      command.execute
-    end
-
-    it "should execute original command" do
-      expect(env[:ui]).to receive(:info).with("COMMAND CONTENT")
-      command.execute
-    end
-
-    it "should return with a 0 value" do
-      expect(command.execute).to eq(0)
-    end
-
-    context "with custom name defined" do
-      before do
-        command_class.class_eval do
-          def deprecation_command_name
-            "custom-name"
-          end
-        end
-      end
-
-      it "should use custom name within warning message" do
-        expect(env[:ui]).to receive(:warn).with(/custom-name/)
-        command.execute
-      end
-    end
-
-    context "with deprecated subcommand" do
-      let(:command_class) do
-        Class.new(Vagrant.plugin("2", :command)) do
-          def self.name
-            "VagrantPlugins::CommandTest::Command::Action"
-          end
-          def execute
-            @env[:ui].info("COMMAND CONTENT")
-            0
-          end
-        end
-      end
-
-      it "should not modify empty synopsis" do
-        expect(command_class.synopsis.to_s).to be_empty
-      end
-
-      it "should extract command name and subname" do
-        expect(command.deprecation_command_name).to eq("test action")
-      end
-    end
-  end
-
-  describe Vagrant::Util::CommandDeprecation::Complete do
-    before{ command_class.include(Vagrant::Util::CommandDeprecation::Complete) }
-
-    it "should add deprecation warning to synopsis" do
-      expect(command_class.synopsis).to include('[DEPRECATED]')
-      command.class.synopsis
-    end
-
-    it "should raise a deprecation error when executed" do
-      expect{ command.execute }.to raise_error(Vagrant::Errors::CommandDeprecated)
-    end
-
-    it "should not run original command" do
-      expect(env[:ui]).not_to receive(:info).with("COMMAND CONTENT")
-      expect{ command.execute }.to raise_error(Vagrant::Errors::CommandDeprecated)
-    end
-  end
-end