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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/test/unit/vagrant/plugin/v2/plugin_test.rb

@@ -0,0 +1,422 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V2::Plugin do
+  before do
+    allow(described_class).to receive(:manager)
+      .and_return(Vagrant::Plugin::V2::Manager.new)
+  end
+
+  it "should be able to set and get the name" do
+    plugin = Class.new(described_class) do
+      name "foo"
+    end
+
+    expect(plugin.name).to eq("foo")
+  end
+
+  it "should be able to set and get the description" do
+    plugin = Class.new(described_class) do
+      description "bar"
+    end
+
+    expect(plugin.description).to eq("bar")
+  end
+
+  describe "action hooks" do
+    it "should register on all actions by default" do
+      plugin = Class.new(described_class) do
+        action_hook("foo") { "bar" }
+      end
+
+      hooks_registry = plugin.components.action_hooks
+      hooks = hooks_registry[described_class.const_get("ALL_ACTIONS")]
+      expect(hooks.length).to eq(1)
+      expect(hooks[0].call).to eq("bar")
+    end
+
+    it "should register for a specific action by default" do
+      plugin = Class.new(described_class) do
+        action_hook("foo", :bar) { "bar" }
+      end
+
+      hooks_registry = plugin.components.action_hooks
+      hooks = hooks_registry[:bar]
+      expect(hooks.length).to eq(1)
+      expect(hooks[0].call).to eq("bar")
+    end
+  end
+
+  describe "commands" do
+    it "should register command classes" do
+      plugin = Class.new(described_class) do
+        command("foo") { "bar" }
+      end
+
+      expect(plugin.components.commands.keys).to be_include(:foo)
+      expect(plugin.components.commands[:foo][0].call).to eql("bar")
+    end
+
+    it "should register command classes with options" do
+      plugin = Class.new(described_class) do
+        command("foo", opt: :bar) { "bar" }
+      end
+
+      expect(plugin.components.commands.keys).to be_include(:foo)
+      expect(plugin.components.commands[:foo][0].call).to eql("bar")
+      expect(plugin.components.commands[:foo][1][:opt]).to eql(:bar)
+    end
+
+    it "should register commands as primary by default" do
+      plugin = Class.new(described_class) do
+        command("foo") { "bar" }
+        command("bar", primary: false) { "bar" }
+      end
+
+      expect(plugin.components.commands[:foo][1][:primary]).to be(true)
+      expect(plugin.components.commands[:bar][1][:primary]).to be(false)
+    end
+
+    ["spaces bad", "sym^bols"].each do |bad|
+      it "should not allow bad command name: #{bad}" do
+        plugin = Class.new(described_class)
+
+        expect { plugin.command(bad) {} }.
+          to raise_error(Vagrant::Plugin::V2::InvalidCommandName)
+      end
+    end
+
+    it "should lazily register command classes" do
+      # Below would raise an error if the value of the command class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+        command("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the command key that
+      # a proper error is raised.
+      expect {
+        plugin.components.commands[:foo][0].call
+      }.to raise_error(StandardError, "FAIL!")
+    end
+  end
+
+  describe "communicators" do
+    it "should register communicator classes" do
+      plugin = Class.new(described_class) do
+        communicator("foo") { "bar" }
+      end
+
+      expect(plugin.communicator[:foo]).to eq("bar")
+    end
+
+    it "should lazily register communicator classes" do
+      # Below would raise an error if the value of the class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+        communicator("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.communicator[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "configuration" do
+    it "should register configuration classes" do
+      plugin = Class.new(described_class) do
+        config("foo") { "bar" }
+      end
+
+      expect(plugin.components.configs[:top][:foo]).to eq("bar")
+    end
+
+    it "should lazily register configuration classes" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+        config("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.components.configs[:top][:foo]
+      }.to raise_error(StandardError)
+    end
+
+    it "should register configuration classes for providers" do
+      plugin = Class.new(described_class) do
+        config("foo", :provider) { "bar" }
+      end
+
+      expect(plugin.components.configs[:provider][:foo]).to eq("bar")
+    end
+  end
+
+  describe "guests" do
+    it "should register guest classes" do
+      plugin = Class.new(described_class) do
+        guest("foo") { "bar" }
+      end
+
+      expect(plugin.components.guests[:foo]).to eq(["bar", nil])
+    end
+
+    it "should lazily register guest classes" do
+      # Below would raise an error if the value of the guest class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          guest("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the guest key that
+      # a proper error is raised.
+      expect {
+        plugin.guest[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "guest capabilities" do
+    it "should register guest capabilities" do
+      plugin = Class.new(described_class) do
+        guest_capability("foo", "bar") { "baz" }
+      end
+
+      expect(plugin.components.guest_capabilities[:foo][:bar]).to eq("baz")
+    end
+  end
+
+  describe "hosts" do
+    it "should register host classes" do
+      plugin = Class.new(described_class) do
+        host("foo") { "bar" }
+      end
+
+      expect(plugin.components.hosts[:foo]).to eq(["bar", nil])
+    end
+
+    it "should lazily register host classes" do
+      # Below would raise an error if the value of the host class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          host("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the host key that
+      # a proper error is raised.
+      expect {
+        plugin.host[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "host capabilities" do
+    it "should register host capabilities" do
+      plugin = Class.new(described_class) do
+        host_capability("foo", "bar") { "baz" }
+      end
+
+      expect(plugin.components.host_capabilities[:foo][:bar]).to eq("baz")
+    end
+  end
+
+  describe "providers" do
+    it "should register provider classes" do
+      plugin = Class.new(described_class) do
+        provider("foo") { "bar" }
+      end
+
+      result = plugin.components.providers[:foo]
+      expect(result[0]).to eq("bar")
+      expect(result[1][:priority]).to eq(5)
+    end
+
+    it "should register provider classes with options" do
+      plugin = Class.new(described_class) do
+        provider("foo", foo: "yep") { "bar" }
+      end
+
+      result = plugin.components.providers[:foo]
+      expect(result[0]).to eq("bar")
+      expect(result[1][:priority]).to eq(5)
+      expect(result[1][:foo]).to eq("yep")
+    end
+
+    it "should lazily register provider classes" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          provider("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.components.providers[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "provider capabilities" do
+    it "should register host capabilities" do
+      plugin = Class.new(described_class) do
+        provider_capability("foo", "bar") { "baz" }
+      end
+
+      expect(plugin.components.provider_capabilities[:foo][:bar]).to eq("baz")
+    end
+  end
+
+  describe "provisioners" do
+    it "should register provisioner classes" do
+      plugin = Class.new(described_class) do
+        provisioner("foo") { "bar" }
+      end
+
+      expect(plugin.provisioner[:foo]).to eq("bar")
+    end
+
+    it "should lazily register provisioner classes" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          provisioner("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.provisioner[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "pushes" do
+    it "should register implementations" do
+      plugin = Class.new(described_class) do
+        push("foo") { "bar" }
+      end
+
+      expect(plugin.components.pushes[:foo]).to eq(["bar", nil])
+    end
+
+    it "should be able to specify priorities" do
+      plugin = Class.new(described_class) do
+        push("foo", bar: 1) { "bar" }
+      end
+
+      expect(plugin.components.pushes[:foo]).to eq(["bar", bar: 1])
+    end
+
+    it "should lazily register implementations" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          push("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.components.pushes[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "synced folders" do
+    it "should register implementations" do
+      plugin = Class.new(described_class) do
+        synced_folder("foo") { "bar" }
+      end
+
+      expect(plugin.components.synced_folders[:foo]).to eq(["bar", 10])
+    end
+
+    it "should be able to specify priorities" do
+      plugin = Class.new(described_class) do
+        synced_folder("foo", 50) { "bar" }
+      end
+
+      expect(plugin.components.synced_folders[:foo]).to eq(["bar", 50])
+    end
+
+    it "should lazily register implementations" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          synced_folder("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.components.synced_folders[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "plugin registration" do
+    let(:manager) { described_class.manager }
+
+    it "should have no registered plugins" do
+      expect(manager.registered).to be_empty
+    end
+
+    it "should register a plugin when a name is set" do
+      plugin = Class.new(described_class) do
+        name "foo"
+      end
+
+      expect(manager.registered).to eq([plugin])
+    end
+
+    it "should register a plugin only once" do
+      plugin = Class.new(described_class) do
+        name "foo"
+        name "bar"
+      end
+
+      expect(manager.registered).to eq([plugin])
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/test/unit/vagrant/plugin/v2/provider_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V2::Provider do
+  include_context "unit"
+
+  let(:machine)  { Object.new }
+  let(:instance) { described_class.new(machine) }
+
+  subject { instance }
+
+  it "should be usable by default" do
+    expect(described_class).to be_usable
+  end
+
+  it "should be installed by default" do
+    expect(described_class).to be_installed
+  end
+
+  it "should return nil by default for actions" do
+    expect(instance.action(:whatever)).to be_nil
+  end
+
+  it "should return nil by default for ssh info" do
+    expect(instance.ssh_info).to be_nil
+  end
+
+  it "should return nil by default for state" do
+    expect(instance.state).to be_nil
+  end
+
+  context "capabilities" do
+    before do
+      register_plugin("2") do |p|
+        p.provider_capability("bar", "foo") {}
+
+        p.provider_capability("foo", "bar") do
+          Class.new do
+            def self.bar(machine)
+              raise "bar #{machine.id}"
+            end
+          end
+        end
+      end
+
+      allow(machine).to receive(:id).and_return("YEAH")
+
+      instance._initialize("foo", machine)
+    end
+
+    it "can execute capabilities" do
+      expect(subject.capability?(:foo)).to be(false)
+      expect(subject.capability?(:bar)).to be(true)
+
+      expect { subject.capability(:bar) }.
+        to raise_error("bar YEAH")
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/test/unit/vagrant/shared_helpers_test.rb

@@ -0,0 +1,146 @@
+require File.expand_path("../../base", __FILE__)
+
+require "vagrant/shared_helpers"
+require "vagrant/util/platform"
+
+describe Vagrant do
+  include_context "unit"
+
+  subject { described_class }
+
+  describe "#global_lock" do
+    it "yields to the block" do
+      result = subject.global_lock { 42 }
+      expect(result).to eq(42)
+    end
+  end
+
+  describe "#in_installer?" do
+    it "is not if env is not set" do
+      with_temp_env("VAGRANT_INSTALLER_ENV" => nil) do
+        expect(subject.in_installer?).to be(false)
+      end
+    end
+
+    it "is if env is set" do
+      with_temp_env("VAGRANT_INSTALLER_ENV" => "/foo") do
+        expect(subject.in_installer?).to be(true)
+      end
+    end
+  end
+
+  describe "#installer_embedded_dir" do
+    it "returns nil if not in an installer" do
+      allow(Vagrant).to receive(:in_installer?).and_return(false)
+      expect(subject.installer_embedded_dir).to be_nil
+    end
+
+    it "returns the set directory" do
+      allow(Vagrant).to receive(:in_installer?).and_return(true)
+
+      with_temp_env("VAGRANT_INSTALLER_EMBEDDED_DIR" => "/foo") do
+        expect(subject.installer_embedded_dir).to eq("/foo")
+      end
+    end
+  end
+
+  describe "#plugins_enabled?" do
+    it "returns true if the env is not set" do
+      with_temp_env("VAGRANT_NO_PLUGINS" => nil) do
+        expect(subject.plugins_enabled?).to be(true)
+      end
+    end
+
+    it "returns false if the env is set" do
+      with_temp_env("VAGRANT_NO_PLUGINS" => "1") do
+        expect(subject.plugins_enabled?).to be(false)
+      end
+    end
+  end
+
+  describe "#server_url" do
+    it "defaults to the default value" do
+      with_temp_env("VAGRANT_SERVER_URL" => nil) do
+        expect(subject.server_url).to eq(
+          Vagrant::DEFAULT_SERVER_URL)
+      end
+    end
+
+    it "defaults if the string is empty" do
+      with_temp_env("VAGRANT_SERVER_URL" => "") do
+        expect(subject.server_url).to eq(
+          Vagrant::DEFAULT_SERVER_URL)
+      end
+    end
+
+    it "is the VAGRANT_SERVER_URL value" do
+      with_temp_env("VAGRANT_SERVER_URL" => "foo") do
+        expect(subject.server_url).to eq("foo")
+      end
+    end
+
+    it "is the VAGRANT_SERVER_URL value if the server url is configured" do
+      with_temp_env("VAGRANT_SERVER_URL" => "foo") do
+        expect(subject.server_url('bar')).to eq("foo")
+      end
+    end
+
+    it "is the configured server url if VAGRANT_SERVER_URL is not set" do
+      with_temp_env("VAGRANT_SERVER_URL" => nil) do
+        expect(subject.server_url("bar")).to eq("bar")
+      end
+    end
+  end
+
+  describe "#user_data_path" do
+    around do |example|
+      env = {
+        "USERPROFILE" => nil,
+        "VAGRANT_HOME" => nil,
+      }
+      with_temp_env(env) { example.run }
+    end
+
+    it "defaults to ~/.vagrant.d" do
+      expect(subject.user_data_path).to eql(Pathname.new("~/.vagrant.d").expand_path)
+    end
+
+    it "is VAGRANT_HOME if set" do
+      with_temp_env("VAGRANT_HOME" => "/foo") do
+        expected = Pathname.new("/foo").expand_path
+        expect(subject.user_data_path).to eql(expected)
+      end
+    end
+
+    it "is USERPROFILE/.vagrant.d if set" do
+      with_temp_env("USERPROFILE" => "/bar") do
+        expected = Pathname.new("/bar/.vagrant.d").expand_path
+        expect(subject.user_data_path).to eql(expected)
+      end
+    end
+
+    it "prefers VAGRANT_HOME over USERPOFILE if both are set" do
+      env = {
+        "USERPROFILE" => "/bar",
+        "VAGRANT_HOME" => "/foo",
+      }
+
+      with_temp_env(env) do
+        expected = Pathname.new("/foo").expand_path
+        expect(subject.user_data_path).to eql(expected)
+      end
+    end
+  end
+
+  describe "#prerelease?" do
+    it "should return true when Vagrant version is development" do
+      stub_const("Vagrant::VERSION", "1.0.0.dev")
+      expect(subject.prerelease?).to be(true)
+    end
+
+    it "should return false when Vagrant version is release" do
+      stub_const("Vagrant::VERSION", "1.0.0")
+      expect(subject.prerelease?).to be(false)
+    end
+  end
+end