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/plugin/manager_test.rb

@@ -1,253 +0,0 @@
-require "json"
-require "pathname"
-
-require "vagrant/plugin"
-require "vagrant/plugin/manager"
-require "vagrant/plugin/state_file"
-
-require File.expand_path("../../../base", __FILE__)
-
-describe Vagrant::Plugin::Manager do
-  include_context "unit"
-
-  let(:path) do
-    Pathname.new(Dir::Tmpname.create("vagrant-test-plugin-manager") {})
-  end
-
-  let(:bundler) { double("bundler") }
-
-  after do
-    path.unlink if path.file?
-  end
-
-  before do
-    Vagrant::Bundler.stub(instance: bundler)
-  end
-
-  subject { described_class.new(path) }
-
-  describe "#install_plugin" do
-    it "installs the plugin and adds it to the state file" do
-      specs = Array.new(5) { Gem::Specification.new }
-      specs[3].name = "foo"
-      expect(bundler).to receive(:install).once.with { |plugins, local|
-        expect(plugins).to have_key("foo")
-        expect(local).to be_false
-      }.and_return(specs)
-      expect(bundler).to receive(:clean)
-
-      result = subject.install_plugin("foo")
-
-      # It should return the spec of the installed plugin
-      expect(result).to eql(specs[3])
-
-      # It should've added the plugin to the state
-      expect(subject.installed_plugins).to have_key("foo")
-    end
-
-    it "masks GemNotFound with our error" do
-      expect(bundler).to receive(:install).and_raise(Gem::GemNotFoundException)
-
-      expect { subject.install_plugin("foo") }.
-        to raise_error(Vagrant::Errors::PluginGemNotFound)
-    end
-
-    it "masks bundler errors with our own error" do
-      expect(bundler).to receive(:install).and_raise(Gem::InstallError)
-
-      expect { subject.install_plugin("foo") }.
-        to raise_error(Vagrant::Errors::BundlerError)
-    end
-
-    it "can install a local gem" do
-      name    = "foo.gem"
-      version = "1.0"
-
-      local_spec = Gem::Specification.new
-      local_spec.name = "bar"
-      local_spec.version = version
-
-      expect(bundler).to receive(:install_local).with(name, {}).
-        ordered.and_return(local_spec)
-
-      expect(bundler).not_to receive(:install)
-      expect(bundler).to receive(:clean)
-
-      subject.install_plugin(name)
-
-      plugins = subject.installed_plugins
-      expect(plugins).to have_key("bar")
-      expect(plugins["bar"]["gem_version"]).to eql("1.0")
-    end
-
-    describe "installation options" do
-      let(:specs) do
-        specs = Array.new(5) { Gem::Specification.new }
-        specs[3].name = "foo"
-        specs
-      end
-
-      before do
-        allow(bundler).to receive(:install).and_return(specs)
-      end
-
-      it "installs a version with constraints" do
-        expect(bundler).to receive(:install).once.with { |plugins, local|
-          expect(plugins).to have_key("foo")
-          expect(plugins["foo"]["gem_version"]).to eql(">= 0.1.0")
-          expect(local).to be_false
-        }.and_return(specs)
-        expect(bundler).to receive(:clean)
-
-        subject.install_plugin("foo", version: ">= 0.1.0")
-
-        plugins = subject.installed_plugins
-        expect(plugins).to have_key("foo")
-        expect(plugins["foo"]["gem_version"]).to eql(">= 0.1.0")
-      end
-
-      it "installs with an exact version but doesn't constrain" do
-        expect(bundler).to receive(:install).once.with { |plugins, local|
-          expect(plugins).to have_key("foo")
-          expect(plugins["foo"]["gem_version"]).to eql("0.1.0")
-          expect(local).to be_false
-        }.and_return(specs)
-        expect(bundler).to receive(:clean)
-
-        subject.install_plugin("foo", version: "0.1.0")
-
-        plugins = subject.installed_plugins
-        expect(plugins).to have_key("foo")
-        expect(plugins["foo"]["gem_version"]).to eql("0.1.0")
-      end
-    end
-  end
-
-  describe "#uninstall_plugin" do
-    it "removes the plugin from the state" do
-      sf = Vagrant::Plugin::StateFile.new(path)
-      sf.add_plugin("foo")
-
-      # Sanity
-      expect(subject.installed_plugins).to have_key("foo")
-
-      # Test
-      expect(bundler).to receive(:clean).once.with({})
-
-      # Remove it
-      subject.uninstall_plugin("foo")
-      expect(subject.installed_plugins).to_not have_key("foo")
-    end
-
-    it "masks bundler errors with our own error" do
-      expect(bundler).to receive(:clean).and_raise(Gem::InstallError)
-
-      expect { subject.uninstall_plugin("foo") }.
-        to raise_error(Vagrant::Errors::BundlerError)
-    end
-
-    context "with a system file" do
-      let(:systems_path) { temporary_file }
-
-      before do
-        systems_path.unlink
-
-        described_class.stub(system_plugins_file: systems_path)
-
-        sf = Vagrant::Plugin::StateFile.new(systems_path)
-        sf.add_plugin("foo", version: "0.2.0")
-        sf.add_plugin("bar")
-      end
-
-      it "uninstalls the user plugin if it exists" do
-        sf = Vagrant::Plugin::StateFile.new(path)
-        sf.add_plugin("bar")
-
-        # Test
-        expect(bundler).to receive(:clean).once.with(anything)
-
-        # Remove it
-        subject.uninstall_plugin("bar")
-
-        plugins = subject.installed_plugins
-        expect(plugins["foo"]["system"]).to be_true
-      end
-
-      it "raises an error if uninstalling a system gem" do
-        expect { subject.uninstall_plugin("bar") }.
-          to raise_error(Vagrant::Errors::PluginUninstallSystem)
-      end
-    end
-  end
-
-  describe "#update_plugins" do
-    it "masks bundler errors with our own error" do
-      expect(bundler).to receive(:update).and_raise(Gem::InstallError)
-
-      expect { subject.update_plugins([]) }.
-        to raise_error(Vagrant::Errors::BundlerError)
-    end
-  end
-
-  context "without state" do
-    describe "#installed_plugins" do
-      it "is empty initially" do
-        expect(subject.installed_plugins).to be_empty
-      end
-    end
-  end
-
-  context "with state" do
-    before do
-      sf = Vagrant::Plugin::StateFile.new(path)
-      sf.add_plugin("foo", version: "0.1.0")
-    end
-
-    describe "#installed_plugins" do
-      it "has the plugins" do
-        plugins = subject.installed_plugins
-        expect(plugins.length).to eql(1)
-        expect(plugins).to have_key("foo")
-      end
-    end
-
-    describe "#installed_specs" do
-      it "has the plugins" do
-        # We just add "i18n" because it is a dependency of Vagrant and
-        # we know it will be there.
-        sf = Vagrant::Plugin::StateFile.new(path)
-        sf.add_plugin("i18n")
-
-        specs = subject.installed_specs
-        expect(specs.length).to eql(1)
-        expect(specs.first.name).to eql("i18n")
-      end
-    end
-
-    context "with system plugins" do
-      let(:systems_path) { temporary_file }
-
-      before do
-        systems_path.unlink
-
-        described_class.stub(system_plugins_file: systems_path)
-
-        sf = Vagrant::Plugin::StateFile.new(systems_path)
-        sf.add_plugin("foo", version: "0.2.0")
-        sf.add_plugin("bar")
-      end
-
-      describe "#installed_plugins" do
-        it "has the plugins" do
-          plugins = subject.installed_plugins
-          expect(plugins.length).to eql(2)
-          expect(plugins).to have_key("foo")
-          expect(plugins["foo"]["gem_version"]).to eq("0.1.0")
-          expect(plugins["foo"]["system"]).to be_false
-          expect(plugins).to have_key("bar")
-          expect(plugins["bar"]["system"]).to be_true
-        end
-      end
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-require "json"
-require "pathname"
-
-require File.expand_path("../../../base", __FILE__)
-
-describe Vagrant::Plugin::StateFile do
-  let(:path) do
-    Pathname.new(Dir::Tmpname.create("vagrant-test-statefile") {})
-  end
-
-  after do
-    path.unlink if path.file?
-  end
-
-  subject { described_class.new(path) }
-
-  context "new usage" do
-    it "should have no plugins without saving some" do
-      expect(subject.installed_plugins).to be_empty
-    end
-
-    it "should have plugins when saving" do
-      subject.add_plugin("foo")
-
-      instance = described_class.new(path)
-      plugins = instance.installed_plugins
-      expect(plugins.length).to eql(1)
-      expect(plugins["foo"]).to eql({
-        "ruby_version"          => RUBY_VERSION,
-        "vagrant_version"       => Vagrant::VERSION,
-        "gem_version"           => "",
-        "require"               => "",
-        "sources"               => [],
-        "installed_gem_version" => nil,
-      })
-    end
-
-    it "should check for plugins" do
-      expect(subject.has_plugin?("foo")).to be_false
-      subject.add_plugin("foo")
-      expect(subject.has_plugin?("foo")).to be_true
-    end
-
-    it "should remove plugins" do
-      subject.add_plugin("foo")
-      subject.remove_plugin("foo")
-
-      instance = described_class.new(path)
-      expect(instance.installed_plugins).to be_empty
-    end
-
-    it "should store plugins uniquely" do
-      subject.add_plugin("foo")
-      subject.add_plugin("foo")
-
-      instance = described_class.new(path)
-      expect(instance.installed_plugins.keys).to eql(["foo"])
-    end
-
-    it "should store metadata" do
-      subject.add_plugin("foo", version: "1.2.3")
-      expect(subject.installed_plugins["foo"]["gem_version"]).to eql("1.2.3")
-    end
-
-    describe "sources" do
-      it "should have no sources" do
-        expect(subject.sources).to be_empty
-      end
-
-      it "should add sources" do
-        subject.add_source("foo")
-        expect(subject.sources).to eql(["foo"])
-      end
-
-      it "should de-dup sources" do
-        subject.add_source("foo")
-        subject.add_source("foo")
-        expect(subject.sources).to eql(["foo"])
-      end
-
-      it "can remove sources" do
-        subject.add_source("foo")
-        subject.remove_source("foo")
-        expect(subject.sources).to be_empty
-      end
-    end
-  end
-
-  context "with an old-style file" do
-    before do
-      data = {
-        "installed" => ["foo"],
-      }
-
-      path.open("w+") do |f|
-        f.write(JSON.dump(data))
-      end
-    end
-
-    it "should have the right installed plugins" do
-      plugins = subject.installed_plugins
-      expect(plugins.keys).to eql(["foo"])
-      expect(plugins["foo"]["ruby_version"]).to eql("0")
-      expect(plugins["foo"]["vagrant_version"]).to eql("0")
-    end
-  end
-
-  context "with parse errors" do
-    before do
-      path.open("w+") do |f|
-        f.write("I'm not json")
-      end
-    end
-
-    it "should raise a VagrantError" do
-      expect { subject }.
-        to raise_error(Vagrant::Errors::PluginStateFileParseError)
-    end
-  end
-end

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

@@ -1,143 +0,0 @@
-require File.expand_path("../../../../base", __FILE__)
-require 'optparse'
-
-describe Vagrant::Plugin::V1::Command do
-  describe "parsing options" do
-    let(:klass) do
-      Class.new(described_class) do
-        # Make the method public since it is normally protected
-        public :parse_options
-      end
-    end
-
-    it "returns the remaining arguments" do
-      options = {}
-      opts = OptionParser.new do |opts|
-        opts.on("-f") do |f|
-          options[:f] = f
-        end
-      end
-
-      result = klass.new(["-f", "foo"], nil).parse_options(opts)
-
-      # Check the results
-      expect(options[:f]).to be
-      expect(result).to eq(["foo"])
-    end
-
-    it "creates an option parser if none is given" do
-      result = klass.new(["foo"], nil).parse_options(nil)
-      expect(result).to eq(["foo"])
-    end
-
-    ["-h", "--help"].each do |help_string|
-      it "returns nil and prints the help if '#{help_string}' is given" do
-        instance = klass.new([help_string], nil)
-        expect(instance).to receive(:safe_puts)
-        expect(instance.parse_options(OptionParser.new)).to be_nil
-      end
-    end
-
-    it "raises an error if invalid options are given" do
-      instance = klass.new(["-f"], nil)
-      expect { instance.parse_options(OptionParser.new) }.
-        to raise_error(Vagrant::Errors::CLIInvalidOptions)
-    end
-  end
-
-  describe "target VMs" do
-    let(:klass) do
-      Class.new(described_class) do
-        # Make the method public since it is normally protected
-        public :with_target_vms
-      end
-    end
-
-    let(:environment) do
-      env = double("environment")
-      env.stub(root_path: "foo")
-      env
-    end
-
-    let(:instance)    { klass.new([], environment) }
-
-    it "should raise an exception if a root_path is not available" do
-      environment.stub(root_path: nil)
-
-      expect { instance.with_target_vms }.
-        to raise_error(Vagrant::Errors::NoEnvironmentError)
-    end
-
-    it "should yield every VM in order is no name is given" do
-      foo_vm = double("foo")
-      allow(foo_vm).to receive(:name).and_return("foo")
-
-      bar_vm = double("bar")
-      allow(bar_vm).to receive(:name).and_return("bar")
-
-      environment.stub(multivm?: true,
-                       vms: { "foo" => foo_vm, "bar" => bar_vm },
-                       vms_ordered: [foo_vm, bar_vm])
-
-      vms = []
-      instance.with_target_vms do |vm|
-        vms << vm
-      end
-
-      expect(vms).to eq([foo_vm, bar_vm])
-    end
-
-    it "raises an exception if the named VM doesn't exist" do
-      environment.stub(multivm?: true, vms: {})
-
-      expect { instance.with_target_vms("foo") }.
-        to raise_error(Vagrant::Errors::VMNotFoundError)
-    end
-
-    it "yields the given VM if a name is given" do
-      foo_vm = double("foo")
-      allow(foo_vm).to receive(:name).and_return(:foo)
-
-      environment.stub(multivm?: true,
-                       vms: { foo: foo_vm, bar: nil })
-
-      vms = []
-      instance.with_target_vms("foo") { |vm| vms << vm }
-      expect(vms).to eq([foo_vm])
-    end
-  end
-
-  describe "splitting the main and subcommand args" do
-    let(:instance) do
-      Class.new(described_class) do
-        # Make the method public since it is normally protected
-        public :split_main_and_subcommand
-      end.new(nil, nil)
-    end
-
-    it "should work when given all 3 parts" do
-      result = instance.split_main_and_subcommand(["-v", "status", "-h", "-v"])
-      expect(result).to eq([["-v"], "status", ["-h", "-v"]])
-    end
-
-    it "should work when given only a subcommand and args" do
-      result = instance.split_main_and_subcommand(["status", "-h"])
-      expect(result).to eq([[], "status", ["-h"]])
-    end
-
-    it "should work when given only main flags" do
-      result = instance.split_main_and_subcommand(["-v", "-h"])
-      expect(result).to eq([["-v", "-h"], nil, []])
-    end
-
-    it "should work when given only a subcommand" do
-      result = instance.split_main_and_subcommand(["status"])
-      expect(result).to eq([[], "status", []])
-    end
-
-    it "works when there are other non-flag args after the subcommand" do
-      result = instance.split_main_and_subcommand(["-v", "box", "add", "-h"])
-      expect(result).to eq([["-v"], "box", ["add", "-h"]])
-    end
-  end
-end