vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,50 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require 'vagrant/util/platform'
-require 'vagrant/util/which'
-
-describe Vagrant::Util::Which do
-  def tester (file_extension, test_extension, mode, &block)
-    # create file in temp directory
-    filename = '__vagrant_unit_test__'
-    dir = Dir.tmpdir
-    file = Pathname(dir) + (filename + file_extension)
-    file.open("w") { |f| f.write("#") }
-    file.chmod(mode)
-
-    # set the path to the directory where the file is located
-    allow(ENV).to receive(:[]).with("PATH").and_return(dir.to_s)
-    block.call filename + test_extension
-
-    file.unlink
-  end
-
-  it "should return a path for an executable file" do
-    tester '.bat', '.bat', 0755 do |name|
-      expect(described_class.which(name)).not_to be_nil
-    end
-  end
-
-  if Vagrant::Util::Platform.windows?
-    it "should return a path for a Windows executable file" do
-      tester '.bat', '', 0755 do |name|
-        expect(described_class.which(name)).not_to be_nil
-      end
-    end
-  end
-
-  it "should return nil for a non-executable file" do
-    tester '.txt', '.txt', 0644 do |name|
-      expect(described_class.which(name)).to be_nil
-    end
-  end
-
-  context "original_path option" do
-    before{ allow(ENV).to receive(:[]).with("PATH").and_return("") }
-
-    it "should use the original path when instructed" do
-      expect(ENV).to receive(:fetch).with("VAGRANT_OLD_ENV_PATH", any_args).and_return("")
-      described_class.which("file", original_path: true)
-    end
-  end
-end

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

@@ -1,415 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-
-require "pathname"
-require "tmpdir"
-
-require "vagrant/vagrantfile"
-
-describe Vagrant::Vagrantfile do
-  include_context "unit"
-
-  let(:keys) { [] }
-  let(:loader) {
-    Vagrant::Config::Loader.new(
-      Vagrant::Config::VERSIONS, Vagrant::Config::VERSIONS_ORDER)
-  }
-
-  subject { described_class.new(loader, keys) }
-
-  before do
-    keys << :test
-  end
-
-  def configure(&block)
-    loader.set(:test, [["2", block]])
-  end
-
-  # A helper to register a provider for use in tests.
-  def register_provider(name, config_class=nil, options=nil)
-    provider_cls = Class.new(VagrantTests::DummyProvider) do
-      if options && options[:unusable]
-        def self.usable?(raise_error=false)
-          raise Vagrant::Errors::VagrantError if raise_error
-          false
-        end
-      end
-    end
-
-    register_plugin("2") do |p|
-      p.provider(name, options) { provider_cls }
-
-      if config_class
-        p.config(name, :provider) { config_class }
-      end
-    end
-
-    provider_cls
-  end
-
-  describe "#config" do
-    it "exposes the global configuration" do
-      configure do |config|
-        config.vm.box = "what"
-      end
-
-      expect(subject.config.vm.box).to eq("what")
-    end
-  end
-
-  describe "#machine" do
-    let(:boxes) { Vagrant::BoxCollection.new(iso_env.boxes_dir) }
-    let(:data_path) { Pathname.new(Dir.mktmpdir("vagrant-machine-data-path")) }
-    let(:env)   { iso_env.create_vagrant_env }
-    let(:iso_env) { isolated_environment }
-    let(:vagrantfile) { described_class.new(loader, keys) }
-
-    subject { vagrantfile.machine(:default, :foo, boxes, data_path, env) }
-
-    before do
-      @foo_config_cls = Class.new(Vagrant.plugin("2", "config")) do
-        attr_accessor :value
-      end
-
-      @provider_cls = register_provider("foo", @foo_config_cls)
-
-      configure do |config|
-        config.vm.box = "foo"
-        config.vm.provider "foo" do |p|
-          p.value = "rawr"
-        end
-      end
-
-      iso_env.box3("foo", "1.0", :foo, vagrantfile: <<-VF)
-      Vagrant.configure("2") do |config|
-        config.ssh.port = 123
-      end
-      VF
-    end
-
-    after do
-      FileUtils.rm_rf(data_path.to_s)
-    end
-
-    describe '#data_dir' do
-      subject { super().data_dir }
-      it { should eq(data_path) }
-    end
-
-    describe '#env' do
-      subject { super().env }
-      it      { should equal(env)    }
-    end
-
-    describe '#name' do
-      subject { super().name }
-      it     { should eq(:default)  }
-    end
-
-    describe '#provider' do
-      subject { super().provider }
-      it { should be_kind_of(@provider_cls) }
-    end
-
-    describe '#provider_name' do
-      subject { super().provider_name }
-      it { should eq(:foo) }
-    end
-
-    describe '#vagrantfile' do
-      subject { super().vagrantfile }
-      it { should equal(vagrantfile) }
-    end
-
-    it "has the proper box" do
-      expect(subject.box.name).to eq("foo")
-    end
-
-    it "has the valid configuration" do
-      expect(subject.config.vm.box).to eq("foo")
-    end
-
-    it "loads the provider-specific configuration" do
-      expect(subject.provider_config).to be_kind_of(@foo_config_cls)
-      expect(subject.provider_config.value).to eq("rawr")
-    end
-  end
-
-  describe "#machine_config" do
-    let(:iso_env) { isolated_environment }
-    let(:boxes) { Vagrant::BoxCollection.new(iso_env.boxes_dir) }
-
-    it "should return a basic configured machine" do
-      provider_cls = register_provider("foo")
-
-      configure do |config|
-        config.vm.box = "foo"
-      end
-
-      results = subject.machine_config(:default, :foo, boxes)
-      box     = results[:box]
-      config  = results[:config]
-      expect(config.vm.box).to eq("foo")
-      expect(box).to be_nil
-      expect(results[:provider_cls]).to equal(provider_cls)
-    end
-
-    it "configures without a provider or boxes" do
-      register_provider("foo")
-
-      configure do |config|
-        config.vm.box = "foo"
-      end
-
-      results = subject.machine_config(:default, nil, nil)
-      box     = results[:box]
-      config  = results[:config]
-      expect(config.vm.box).to eq("foo")
-      expect(box).to be_nil
-      expect(results[:provider_cls]).to be_nil
-    end
-
-    it "configures with sub-machine config" do
-      register_provider("foo")
-
-      configure do |config|
-        config.ssh.port = "1"
-        config.vm.box = "base"
-
-        config.vm.define "foo" do |f|
-          f.ssh.port = 100
-        end
-      end
-
-      results = subject.machine_config(:foo, :foo, boxes)
-      config  = results[:config]
-      expect(config.vm.box).to eq("base")
-      expect(config.ssh.port).to eq(100)
-    end
-
-    it "configures with box configuration if it exists" do
-      register_provider("foo")
-
-      configure do |config|
-        config.vm.box = "base"
-      end
-
-      iso_env.box3("base", "1.0", :foo, vagrantfile: <<-VF)
-      Vagrant.configure("2") do |config|
-        config.ssh.port = 123
-      end
-      VF
-
-      results = subject.machine_config(:default, :foo, boxes)
-      box     = results[:box]
-      config  = results[:config]
-      expect(config.vm.box).to eq("base")
-      expect(config.ssh.port).to eq(123)
-      expect(box).to_not be_nil
-      expect(box.name).to eq("base")
-    end
-
-    it "configures with the proper box version" do
-      register_provider("foo")
-
-      configure do |config|
-        config.vm.box = "base"
-        config.vm.box_version = "~> 1.2"
-      end
-
-      iso_env.box3("base", "1.0", :foo, vagrantfile: <<-VF)
-      Vagrant.configure("2") do |config|
-        config.ssh.port = 123
-      end
-      VF
-
-      iso_env.box3("base", "1.3", :foo, vagrantfile: <<-VF)
-      Vagrant.configure("2") do |config|
-        config.ssh.port = 245
-      end
-      VF
-
-      results = subject.machine_config(:default, :foo, boxes)
-      box     = results[:box]
-      config  = results[:config]
-      expect(config.vm.box).to eq("base")
-      expect(config.ssh.port).to eq(245)
-      expect(box).to_not be_nil
-      expect(box.name).to eq("base")
-      expect(box.version).to eq("1.3")
-    end
-
-    it "configures with box config of other supported formats" do
-      register_provider("foo", nil, box_format: "bar")
-
-      configure do |config|
-        config.vm.box = "base"
-      end
-
-      iso_env.box3("base", "1.0", :bar, vagrantfile: <<-VF)
-      Vagrant.configure("2") do |config|
-        config.ssh.port = 123
-      end
-      VF
-
-      results = subject.machine_config(:default, :foo, boxes)
-      config  = results[:config]
-      expect(config.vm.box).to eq("base")
-      expect(config.ssh.port).to eq(123)
-    end
-
-    it "loads provider overrides if set" do
-      register_provider("foo")
-      register_provider("bar")
-
-      configure do |config|
-        config.ssh.port = 1
-        config.vm.box = "base"
-
-        config.vm.provider "foo" do |_, c|
-          c.ssh.port = 100
-        end
-      end
-
-      # Test with the override
-      results = subject.machine_config(:default, :foo, boxes)
-      config  = results[:config]
-      expect(config.vm.box).to eq("base")
-      expect(config.ssh.port).to eq(100)
-
-      # Test without the override
-      results = subject.machine_config(:default, :bar, boxes)
-      config  = results[:config]
-      expect(config.vm.box).to eq("base")
-      expect(config.ssh.port).to eq(1)
-    end
-
-    it "loads the proper box if in a provider override" do
-      register_provider("foo")
-
-      configure do |config|
-        config.vm.box = "base"
-        config.vm.box_version = "1.0"
-
-        config.vm.provider "foo" do |_, c|
-          c.vm.box = "foobox"
-          c.vm.box_version = "2.0"
-        end
-      end
-
-      iso_env.box3("base", "1.0", :foo, vagrantfile: <<-VF)
-      Vagrant.configure("2") do |config|
-        config.ssh.port = 123
-      end
-      VF
-
-      iso_env.box3("foobox", "2.0", :foo, vagrantfile: <<-VF)
-      Vagrant.configure("2") do |config|
-        config.ssh.port = 234
-      end
-      VF
-
-      results = subject.machine_config(:default, :foo, boxes)
-      config  = results[:config]
-      box     = results[:box]
-      expect(config.vm.box).to eq("foobox")
-      expect(config.ssh.port).to eq(234)
-      expect(config.vm.box_version).to eq("2.0")
-      expect(box).to_not be_nil
-      expect(box.name).to eq("foobox")
-      expect(box.version).to eq("2.0")
-    end
-
-    it "raises an error if the machine is not found" do
-      expect { subject.machine_config(:foo, :foo, boxes) }.
-        to raise_error(Vagrant::Errors::MachineNotFound)
-    end
-
-    it "raises an error if the provider is not found" do
-      expect { subject.machine_config(:default, :foo, boxes) }.
-        to raise_error(Vagrant::Errors::ProviderNotFound)
-    end
-
-    it "raises an error if the provider is not found but gives suggestion" do
-      register_provider("foo")
-
-      expect { subject.machine_config(:default, :Foo, boxes) }.
-        to raise_error(Vagrant::Errors::ProviderNotFoundSuggestion)
-    end
-
-    it "raises an error if the provider is not usable" do
-      register_provider("foo", nil, unusable: true)
-
-      expect { subject.machine_config(:default, :foo, boxes) }.
-        to raise_error(Vagrant::Errors::ProviderNotUsable)
-    end
-  end
-
-  describe "#machine_names" do
-    it "returns the default name when single-VM" do
-      configure { |config| }
-
-      expect(subject.machine_names).to eq([:default])
-    end
-
-    it "returns all of the names in a multi-VM" do
-      configure do |config|
-        config.vm.define "foo"
-        config.vm.define "bar"
-      end
-
-      expect(subject.machine_names).to eq(
-        [:foo, :bar])
-    end
-  end
-
-  describe "#machine_names_and_options" do
-    it "returns the default name" do
-      configure { |config| }
-
-      expect(subject.machine_names_and_options).to eq({
-        default: { config_version: "2" },
-      })
-    end
-
-    it "returns all the machines" do
-      configure do |config|
-        config.vm.define "foo"
-        config.vm.define "bar", autostart: false
-        config.vm.define "baz", autostart: true
-      end
-
-      expect(subject.machine_names_and_options).to eq({
-        foo: { config_version: "2" },
-        bar: { config_version: "2", autostart: false },
-        baz: { config_version: "2", autostart: true },
-      })
-    end
-  end
-
-  describe "#primary_machine_name" do
-    it "returns the default name when single-VM" do
-      configure { |config| }
-
-      expect(subject.primary_machine_name).to eq(:default)
-    end
-
-    it "returns the designated machine in multi-VM" do
-      configure do |config|
-        config.vm.define "foo"
-        config.vm.define "bar", primary: true
-        config.vm.define "baz"
-      end
-
-      expect(subject.primary_machine_name).to eq(:bar)
-    end
-
-    it "returns nil if no designation in multi-VM" do
-      configure do |config|
-        config.vm.define "foo"
-        config.vm.define "baz"
-      end
-
-      expect(subject.primary_machine_name).to be_nil
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-require File.expand_path("../base", __FILE__)
-
-describe Vagrant do
-  include_context "unit"
-
-  it "has the path to the source root" do
-    expect(described_class.source_root).to eq(Pathname.new(File.expand_path("../../../", __FILE__)))
-  end
-
-  describe "plugin superclass" do
-    describe "v1" do
-      it "returns the proper class for version 1" do
-        expect(described_class.plugin("1")).to eq(Vagrant::Plugin::V1::Plugin)
-      end
-
-      it "returns the proper components for version 1" do
-        expect(described_class.plugin("1", :command)).to eq(Vagrant::Plugin::V1::Command)
-        expect(described_class.plugin("1", :communicator)).to eq(Vagrant::Plugin::V1::Communicator)
-        expect(described_class.plugin("1", :config)).to eq(Vagrant::Plugin::V1::Config)
-        expect(described_class.plugin("1", :guest)).to eq(Vagrant::Plugin::V1::Guest)
-        expect(described_class.plugin("1", :host)).to eq(Vagrant::Plugin::V1::Host)
-        expect(described_class.plugin("1", :provider)).to eq(Vagrant::Plugin::V1::Provider)
-        expect(described_class.plugin("1", :provisioner)).to eq(Vagrant::Plugin::V1::Provisioner)
-      end
-    end
-
-    describe "v2" do
-      it "returns the proper class for version 2" do
-        expect(described_class.plugin("2")).to eq(Vagrant::Plugin::V2::Plugin)
-      end
-
-      it "returns the proper components for version 2" do
-        expect(described_class.plugin("2", :command)).to eq(Vagrant::Plugin::V2::Command)
-        expect(described_class.plugin("2", :communicator)).to eq(Vagrant::Plugin::V2::Communicator)
-        expect(described_class.plugin("2", :config)).to eq(Vagrant::Plugin::V2::Config)
-        expect(described_class.plugin("2", :guest)).to eq(Vagrant::Plugin::V2::Guest)
-        expect(described_class.plugin("2", :host)).to eq(Vagrant::Plugin::V2::Host)
-        expect(described_class.plugin("2", :provider)).to eq(Vagrant::Plugin::V2::Provider)
-        expect(described_class.plugin("2", :provisioner)).to eq(Vagrant::Plugin::V2::Provisioner)
-        expect(described_class.plugin("2", :synced_folder)).to eq(Vagrant::Plugin::V2::SyncedFolder)
-      end
-    end
-
-    it "raises an exception if an unsupported version is given" do
-      expect { described_class.plugin("88") }.
-        to raise_error(ArgumentError)
-    end
-  end
-
-  describe "has_plugin?" do
-    after(:each) do
-      manager.reset!
-    end
-
-    let(:manager) { described_class.plugin("2").manager }
-
-    it "should find the installed plugin by the registered name" do
-      Class.new(described_class.plugin(Vagrant::Config::CURRENT_VERSION)) do
-        name "i_am_installed"
-      end
-
-      expect(described_class.has_plugin?("i_am_installed")).to be(true)
-    end
-
-    it "should return false if the plugin is not installed" do
-      expect(described_class.has_plugin?("i_dont_exist")).to be(false)
-    end
-
-    it "finds plugins by gem name" do
-      specs = [Gem::Specification.new]
-      specs[0].name = "foo"
-      allow(Vagrant::Plugin::Manager.instance).to receive(:installed_specs).and_return(specs)
-
-      expect(described_class.has_plugin?("foo")).to be(true)
-      expect(described_class.has_plugin?("bar")).to be(false)
-    end
-
-    it "finds plugins by gem name and version" do
-      specs = [Gem::Specification.new]
-      specs[0].name = "foo"
-      specs[0].version = "1.2.3"
-      allow(Vagrant::Plugin::Manager.instance).to receive(:installed_specs).and_return(specs)
-
-      expect(described_class.has_plugin?("foo", "~> 1.2.0")).to be(true)
-      expect(described_class.has_plugin?("foo", "~> 1.0.0")).to be(false)
-      expect(described_class.has_plugin?("bar", "~> 1.2.0")).to be(false)
-    end
-  end
-
-  describe "require_version" do
-    it "should succeed if valid range" do
-      expect { described_class.require_version(Vagrant::VERSION) }.
-        to_not raise_error
-    end
-
-    it "should not succeed if bad range" do
-      expect { described_class.require_version("> #{Vagrant::VERSION}") }.
-        to raise_error(Vagrant::Errors::VagrantVersionBad)
-    end
-  end
-
-  describe "original_env" do
-    before do
-      ENV["VAGRANT_OLD_ENV_foo"] = "test"
-      ENV["VAGRANT_OLD_ENV_bar"] = "test"
-    end
-
-    after do
-      ENV["VAGRANT_OLD_ENV_foo"] = "test"
-      ENV["VAGRANT_OLD_ENV_bar"] = "test"
-    end
-
-    it "should return the original environment" do
-      expect(Vagrant.original_env).to eq(
-        "foo" => "test",
-        "bar" => "test",
-      )
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/vagrant-spec/.runner-vmware.sh

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-function cleanup {
-    vagrant destroy --force
-}
-
-trap cleanup EXIT
-
-GEM_PATH=$(ls vagrant-spec*.gem)
-
-set -ex
-
-if [ -f "${GEM_PATH}" ]
-then
-    mv "${GEM_PATH}" vagrant-spec.gem
-fi
-
-vagrant box update
-vagrant box prune
-
-guests=$(vagrant status | grep vmware | awk '{print $1}')
-
-vagrant up --no-provision
-
-declare -A pids
-
-for guest in ${guests}
-do
-    vagrant provision ${guest} &
-    pids[guest]=$!
-    sleep 60
-done
-
-result=0
-set +e
-
-for guest in ${guests}
-do
-    wait ${pids[guest]}
-    if [ $? -ne 0 ]
-    then
-        echo "Provision failure for: ${guest}"
-        result=1
-    fi
-done
-
-exit $result