vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/action/builtin/ssh_run_test.rb

@@ -1,83 +0,0 @@
-require File.expand_path("../../../../base", __FILE__)
-
-describe Vagrant::Action::Builtin::SSHRun do
-  let(:app) { lambda { |env| } }
-  let(:env) { { machine: machine, tty: true } }
-
-  # SSH configuration information mock
-  let(:ssh) do
-    double("ssh",
-      timeout: 1,
-      host: nil,
-      port: 5986,
-      guest_port: 5986,
-      pty: false,
-      keep_alive: false,
-      insert_key: false,
-      shell: 'bash -l'
-    )
-  end
-
-  # Configuration mock
-  let(:config) { double("config", ssh: ssh) }
-
-  let(:machine) do
-    double("machine",
-      config: config,)
-  end
-
-  let(:machine_ssh_info) { {} }
-  let(:ssh_klass) { Vagrant::Util::SSH }
-
-  before(:each) do
-    # Stub the methods so that even if we test incorrectly, no side
-    # effects actually happen.
-    allow(ssh_klass).to receive(:exec)
-    allow(machine).to receive(:ssh_info).and_return(machine_ssh_info)
-  end
-
-  it "should raise an exception if SSH is not ready" do
-    not_ready_machine = double("machine")
-    allow(not_ready_machine).to receive(:ssh_info).and_return(nil)
-
-    env[:machine] = not_ready_machine
-    expect { described_class.new(app, env).call(env) }.
-      to raise_error(Vagrant::Errors::SSHNotReady)
-  end
-
-  it "should exec with the SSH info in the env if given" do
-    ssh_info = { foo: :bar }
-    opts = {:extra_args=>["-t", "bash -l -c 'echo test'"], :subprocess=>true}
-
-    expect(ssh_klass).to receive(:exec).
-      with(ssh_info, opts)
-
-    env[:ssh_info] = ssh_info
-    env[:ssh_run_command] = "echo test"
-    described_class.new(app, env).call(env)
-  end
-
-  it "should exec with the SSH info in the env if given and disable tty" do
-    ssh_info = { foo: :bar }
-    opts = {:extra_args=>["bash -l -c 'echo test'"], :subprocess=>true}
-    env[:tty] = false
-
-    expect(ssh_klass).to receive(:exec).
-      with(ssh_info, opts)
-
-    env[:ssh_info] = ssh_info
-    env[:ssh_run_command] = "echo test"
-    described_class.new(app, env).call(env)
-  end
-
-  it "should exec with the options given in `ssh_opts`" do
-    ssh_opts = { foo: :bar }
-
-    expect(ssh_klass).to receive(:exec).
-      with(machine_ssh_info, ssh_opts)
-
-    env[:ssh_opts] = ssh_opts
-    env[:ssh_run_command] = "echo test"
-    described_class.new(app, env).call(env)
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/action/builtin/synced_folder_cleanup_test.rb

@@ -1,139 +0,0 @@
-require "pathname"
-require "tmpdir"
-
-require File.expand_path("../../../../base", __FILE__)
-
-describe Vagrant::Action::Builtin::SyncedFolderCleanup do
-  include_context "synced folder actions"
-
-  let(:app) { lambda { |env| } }
-  let(:env) { { machine: machine, ui: ui } }
-  let(:machine) do
-    double("machine").tap do |machine|
-      allow(machine).to receive(:config).and_return(machine_config)
-    end
-  end
-
-  let(:machine_config) do
-    double("machine_config").tap do |top_config|
-      allow(top_config).to receive(:vm).and_return(vm_config)
-    end
-  end
-
-  let(:vm_config) { double("machine_vm_config") }
-
-  let(:ui) do
-    double("ui").tap do |result|
-      allow(result).to receive(:info)
-    end
-  end
-
-  subject { described_class.new(app, env) }
-
-  def create_cleanup_tracker
-    Class.new(impl(true, "good")) do
-      class_variable_set(:@@clean, false)
-
-      def self.clean
-        class_variable_get(:@@clean)
-      end
-
-      def cleanup(machine, opts)
-        self.class.class_variable_set(:@@clean, true)
-      end
-    end
-  end
-
-  describe "call" do
-    let(:synced_folders) { {} }
-    let(:plugins) { {} }
-
-    before do
-      plugins[:default] = [impl(true, "default"), 10]
-      plugins[:nfs] = [impl(true, "nfs"), 5]
-
-      env[:machine] = Object.new
-      env[:root_path] = Pathname.new(Dir.mktmpdir("vagrant-test-synced-folder-cleanup-call"))
-
-      allow(subject).to receive(:plugins).and_return(plugins)
-      allow(subject).to receive(:synced_folders).and_return(synced_folders)
-    end
-
-    after do
-      FileUtils.rm_rf(env[:root_path])
-    end
-
-    it "should invoke cleanup" do
-      tracker = create_cleanup_tracker
-      plugins[:tracker] = [tracker, 15]
-
-      synced_folders["tracker"] = {
-        "root" => {
-          hostpath: "foo",
-        },
-
-        "other" => {
-          hostpath: "bar",
-          create: true,
-        }
-      }
-
-      expect_any_instance_of(tracker).to receive(:cleanup).
-        with(env[:machine], { tracker_foo: :bar })
-
-      # Test that the impl-specific opts are passed through
-      env[:tracker_foo] = :bar
-
-      subject.call(env)
-    end
-
-    it "should invoke cleanup once per implementation" do
-      trackers = []
-      (0..2).each do |tracker|
-        trackers << create_cleanup_tracker
-      end
-
-      plugins[:tracker_0] = [trackers[0], 15]
-      plugins[:tracker_1] = [trackers[1], 15]
-      plugins[:tracker_2] = [trackers[2], 15]
-
-      synced_folders["tracker_0"] = {
-        "root" => {
-          hostpath: "foo"
-        },
-
-        "other" => {
-          hostpath: "bar",
-          create: true
-        }
-      }
-
-      synced_folders["tracker_1"] = {
-        "root" => {
-          hostpath: "foo"
-        }
-      }
-
-      synced_folders["tracker_2"] = {
-        "root" => {
-          hostpath: "foo"
-        },
-
-        "other" => {
-          hostpath: "bar",
-          create: true
-        },
-
-        "another" => {
-          hostpath: "baz"
-        }
-      }
-
-      subject.call(env)
-
-      expect(trackers[0].clean).to be(true)
-      expect(trackers[1].clean).to be(true)
-      expect(trackers[2].clean).to be(true)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/action/builtin/synced_folders_test.rb

@@ -1,232 +0,0 @@
-require "pathname"
-require "tmpdir"
-
-require File.expand_path("../../../../base", __FILE__)
-
-require Vagrant.source_root.join("plugins/kernel_v2/config/vm")
-
-describe Vagrant::Action::Builtin::SyncedFolders do
-  include_context "unit"
-  include_context "synced folder actions"
-
-  let(:app) { lambda { |env| } }
-  let(:env) { { machine: machine, ui: ui } }
-  let(:machine) do
-    double("machine").tap do |machine|
-      allow(machine).to receive(:config).and_return(machine_config)
-    end
-  end
-
-  let(:machine_config) do
-    double("machine_config").tap do |top_config|
-      allow(top_config).to receive(:vm).and_return(vm_config)
-    end
-  end
-
-  let(:vm_config) { double("machine_vm_config") }
-
-  let(:ui) do
-    double("ui").tap do |result|
-      allow(result).to receive(:info)
-    end
-  end
-
-  subject { described_class.new(app, env) }
-
-  describe "call" do
-    let(:synced_folders) { {} }
-    let(:plugins) { {} }
-
-    before do
-      plugins[:default] = [impl(true, "default"), 10]
-      plugins[:nfs] = [impl(true, "nfs"), 5]
-
-      env[:root_path] = Pathname.new(Dir.mktmpdir("vagrant-test-synced-folders-call"))
-      allow(subject).to receive(:plugins).and_return(plugins)
-      allow(subject).to receive(:synced_folders).and_return(synced_folders)
-      allow(subject).to receive(:save_synced_folders)
-    end
-
-    after do
-      FileUtils.rm_rf(env[:root_path])
-    end
-
-    it "should create on the host if specified" do
-      synced_folders["default"] = {
-        "root" => {
-          hostpath: "foo",
-        },
-
-        "other" => {
-          hostpath: "bar",
-          create: true,
-        }
-      }
-
-      subject.call(env)
-
-      expect(env[:root_path].join("foo")).not_to be_directory
-      expect(env[:root_path].join("bar")).to be_directory
-    end
-
-    it "doesn't expand the host path if told not to" do
-      called_folders = nil
-      tracker = Class.new(impl(true, "good")) do
-        define_method(:prepare) do |machine, folders, opts|
-          called_folders = folders
-        end
-      end
-
-      plugins[:tracker] = [tracker, 15]
-
-      synced_folders["tracker"] = {
-        "root" => {
-          hostpath: "foo",
-          hostpath_exact: true,
-        },
-
-        "other" => {
-          hostpath: "/bar",
-        }
-      }
-
-      subject.call(env)
-
-      expect(called_folders).to_not be_nil
-      expect(called_folders["root"][:hostpath]).to eq("foo")
-    end
-
-    it "expands the host path relative to the root path" do
-      called_folders = nil
-      tracker = Class.new(impl(true, "good")) do
-        define_method(:prepare) do |machine, folders, opts|
-          called_folders = folders
-        end
-      end
-
-      plugins[:tracker] = [tracker, 15]
-
-      synced_folders["tracker"] = {
-        "root" => {
-          hostpath: "foo",
-        },
-
-        "other" => {
-          hostpath: "/bar",
-        }
-      }
-
-      subject.call(env)
-
-      expect(called_folders).to_not be_nil
-      expect(called_folders["root"][:hostpath]).to eq(
-        Pathname.new(File.expand_path(
-          called_folders["root"][:hostpath],
-          env[:root_path])).to_s)
-    end
-
-    it "should invoke prepare then enable" do
-      ids   = []
-      order = []
-      tracker = Class.new(impl(true, "good")) do
-        define_method(:prepare) do |machine, folders, opts|
-          ids   << self.object_id
-          order << :prepare
-        end
-
-        define_method(:enable) do |machine, folders, opts|
-          ids   << self.object_id
-          order << :enable
-        end
-      end
-
-      plugins[:tracker] = [tracker, 15]
-
-      synced_folders["tracker"] = {
-        "root" => {
-          hostpath: "foo",
-        },
-
-        "other" => {
-          hostpath: "bar",
-          create: true,
-        }
-      }
-
-      subject.call(env)
-
-      expect(order).to eq([:prepare, :enable])
-      expect(ids.length).to eq(2)
-      expect(ids[0]).to eq(ids[1])
-    end
-
-    it "syncs custom folders" do
-      ids   = []
-      order = []
-      tracker = Class.new(impl(true, "good")) do
-        define_method(:prepare) do |machine, folders, opts|
-          ids   << self.object_id
-          order << :prepare
-        end
-
-        define_method(:enable) do |machine, folders, opts|
-          ids   << self.object_id
-          order << :enable
-        end
-      end
-
-      plugins[:tracker] = [tracker, 15]
-
-      synced_folders["tracker"] = {
-        "root" => {
-          hostpath: "foo",
-        },
-
-        "other" => {
-          hostpath: "bar",
-          create: true,
-        }
-      }
-
-      new_config = double("config")
-      env[:synced_folders_config] = new_config
-
-      expect(subject).to receive(:synced_folders).
-        with(machine, config: new_config, cached: false).
-        and_return(synced_folders)
-
-      subject.call(env)
-
-      expect(order).to eq([:prepare, :enable])
-      expect(ids.length).to eq(2)
-      expect(ids[0]).to eq(ids[1])
-    end
-
-    context "with folders from the machine" do
-      it "removes outdated folders not present in config" do
-        expect(subject).to receive(:save_synced_folders).with(
-          machine, anything, merge: true, vagrantfile: true)
-
-        subject.call(env)
-      end
-    end
-
-    context "with custom folders" do
-      before do
-        new_config = double("config")
-        env[:synced_folders_config] = new_config
-
-        allow(subject).to receive(:synced_folders).
-          with(machine, config: new_config, cached: false).
-          and_return({})
-      end
-
-      it "doesn't remove outdated folders not present in config" do
-        expect(subject).to receive(:save_synced_folders).with(
-          machine, anything, merge: true)
-
-        subject.call(env)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/action/hook_test.rb

@@ -1,135 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/action/builder"
-require "vagrant/action/hook"
-
-describe Vagrant::Action::Hook do
-  describe "defaults" do
-    describe '#after_hooks' do
-      subject { super().after_hooks }
-      it   { should be_empty }
-    end
-
-    describe '#before_hooks' do
-      subject { super().before_hooks }
-      it  { should be_empty }
-    end
-
-    describe '#append_hooks' do
-      subject { super().append_hooks }
-      it  { should be_empty }
-    end
-
-    describe '#prepend_hooks' do
-      subject { super().prepend_hooks }
-      it { should be_empty }
-    end
-  end
-
-  describe "before hooks" do
-    let(:existing) { "foo" }
-
-    it "should append them" do
-      block = Proc.new {}
-
-      subject.before(existing, 1)
-      subject.before(existing, 2)
-      subject.before(existing, 3, :arg, &block)
-
-      expect(subject.before_hooks[existing]).to eq([
-        [1, [], nil],
-        [2, [], nil],
-        [3, [:arg], block]
-      ])
-    end
-  end
-
-  describe "after hooks" do
-    let(:existing) { "foo" }
-
-    it "should append them" do
-      block = Proc.new {}
-
-      subject.after(existing, 1)
-      subject.after(existing, 2)
-      subject.after(existing, 3, :arg, &block)
-
-      expect(subject.after_hooks[existing]).to eq([
-        [1, [], nil],
-        [2, [], nil],
-        [3, [:arg], block]
-      ])
-    end
-  end
-
-  describe "append" do
-    it "should make a list" do
-      block = Proc.new {}
-
-      subject.append(1)
-      subject.append(2)
-      subject.append(3, :arg, &block)
-
-      expect(subject.append_hooks).to eq([
-        [1, [], nil],
-        [2, [], nil],
-        [3, [:arg], block]
-      ])
-    end
-  end
-
-  describe "prepend" do
-    it "should make a list" do
-      block = Proc.new {}
-
-      subject.prepend(1)
-      subject.prepend(2)
-      subject.prepend(3, :arg, &block)
-
-      expect(subject.prepend_hooks).to eq([
-        [1, [], nil],
-        [2, [], nil],
-        [3, [:arg], block]
-      ])
-    end
-  end
-
-  describe "applying" do
-    let(:builder) { Vagrant::Action::Builder.new }
-
-    it "should build the proper stack" do
-      subject.prepend("1", 2)
-      subject.append("9")
-      subject.after("1", "2")
-      subject.before("9", "8")
-
-      subject.apply(builder)
-
-      expect(builder.stack).to eq([
-        ["1", [2], nil],
-        ["2", [], nil],
-        ["8", [], nil],
-        ["9", [], nil]
-      ])
-    end
-
-    it "should not prepend or append if disabled" do
-      builder.use("3")
-      builder.use("8")
-
-      subject.prepend("1", 2)
-      subject.append("9")
-      subject.after("3", "4")
-      subject.before("8", "7")
-
-      subject.apply(builder, no_prepend_or_append: true)
-
-      expect(builder.stack).to eq([
-        ["3", [], nil],
-        ["4", [], nil],
-        ["7", [], nil],
-        ["8", [], nil]
-      ])
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/vagrant/action/runner_test.rb

@@ -1,81 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-describe Vagrant::Action::Runner do
-  let(:instance) { described_class.new }
-
-  it "should raise an error if an invalid callable is given" do
-    expect { instance.run(7) }.to raise_error(ArgumentError, /must be a callable/)
-  end
-
-  it "should be able to use a Proc as a callable" do
-    callable = Proc.new { raise Exception, "BOOM" }
-    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
-  end
-
-  it "should be able to use a Method instance as a callable" do
-    klass = Class.new do
-      def action(env)
-        raise Exception, "BANG"
-      end
-    end
-    callable = klass.new.method(:action)
-    expect { instance.run(callable) }.to raise_error(Exception, "BANG")
-  end
-
-  it "should be able to use a Class as a callable" do
-    callable = Class.new do
-      def initialize(app, env)
-      end
-
-      def call(env)
-        raise Exception, "BOOM"
-      end
-    end
-
-    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
-  end
-
-  it "should return the resulting environment" do
-    callable = lambda do |env|
-      env[:data] = "value"
-
-      # Return nil so we can make sure it isn't using this return value
-      nil
-    end
-
-    result = instance.run(callable)
-    expect(result[:data]).to eq("value")
-  end
-
-  it "should pass options into hash given to callable" do
-    result = nil
-    callable = lambda do |env|
-      result = env["data"]
-    end
-
-    instance.run(callable, "data" => "foo")
-    expect(result).to eq("foo")
-  end
-
-  it "should pass global options into the hash" do
-    result = nil
-    callable = lambda do |env|
-      result = env["data"]
-    end
-
-    instance = described_class.new("data" => "bar")
-    instance.run(callable)
-    expect(result).to eq("bar")
-  end
-
-  it "should yield the block passed to the init method to get lazy loaded globals" do
-    result = nil
-    callable = lambda do |env|
-      result = env["data"]
-    end
-
-    instance = described_class.new { { "data" => "bar" } }
-    instance.run(callable)
-    expect(result).to eq("bar")
-  end
-end