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/plugins/guests/windows/guest_network_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require Vagrant.source_root.join("plugins/guests/windows/guest_network")
+
+describe "VagrantPlugins::GuestWindows::GuestNetwork" do
+
+  let(:communicator) { double("communicator") }
+  let(:subject) { VagrantPlugins::GuestWindows::GuestNetwork.new(communicator) }
+
+  describe ".is_dhcp_enabled" do
+    it "should query the NIC by ordinal index" do
+      expect(communicator).to receive(:test).with(
+        /.+Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter "Index=7 and DHCPEnabled=True"/).
+        and_return(true)
+      expect(subject.is_dhcp_enabled(7)).to be(true)
+    end
+
+    it "should return false for non-DHCP NICs" do
+      expect(communicator).to receive(:test).with(
+        /.+Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter "Index=8 and DHCPEnabled=True"/).
+        and_return(false)
+      expect(subject.is_dhcp_enabled(8)).to be(false)
+    end
+  end
+
+  describe ".configure_static_interface" do
+    it "should configure IP using netsh" do
+      expect(communicator).to receive(:execute).with(
+        "netsh interface ip set address \"Local Area Connection 2\" static 192.168.33.10 255.255.255.0").
+        and_return(0)
+      subject.configure_static_interface(7, "Local Area Connection 2", "192.168.33.10", "255.255.255.0")
+    end
+  end
+
+  describe ".configure_dhcp_interface" do
+    it "should configure DHCP when DHCP is disabled" do
+      allow(communicator).to receive(:test).and_return(false) # is DHCP enabled?
+      expect(communicator).to receive(:execute).with(
+        "netsh interface ip set address \"Local Area Connection 2\" dhcp").
+        and_return(0)
+      subject.configure_dhcp_interface(7, "Local Area Connection 2")
+    end
+
+    it "should not configure DHCP when DHCP is enabled" do
+      allow(communicator).to receive(:test).and_return(true) # is DHCP enabled?
+      expect(communicator).to_not receive(:execute)
+      subject.configure_dhcp_interface(7, "Local Area Connection 2")
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/test/unit/plugins/hosts/linux/cap/nfs_test.rb

@@ -0,0 +1,233 @@
+require_relative "../../../../base"
+require_relative "../../../../../../plugins/hosts/linux/cap/nfs"
+require_relative "../../../../../../lib/vagrant/util"
+
+describe VagrantPlugins::HostLinux::Cap::NFS do
+
+  include_context "unit"
+
+  let(:caps) do
+    VagrantPlugins::HostLinux::Plugin
+      .components
+      .host_capabilities[:linux]
+  end
+
+  let(:tmp_exports_path) do
+    @tmp_exports ||= temporary_file
+  end
+  let(:exports_path){ VagrantPlugins::HostLinux::Cap::NFS::NFS_EXPORTS_PATH }
+  let(:env){ double(:env) }
+  let(:ui){ double(:ui) }
+  let(:host){ double(:host) }
+
+  before do
+    @original_exports_path = VagrantPlugins::HostLinux::Cap::NFS::NFS_EXPORTS_PATH
+    VagrantPlugins::HostLinux::Cap::NFS.send(:remove_const, :NFS_EXPORTS_PATH)
+    VagrantPlugins::HostLinux::Cap::NFS.const_set(:NFS_EXPORTS_PATH, tmp_exports_path.to_s)
+  end
+
+  after do
+    VagrantPlugins::HostLinux::Cap::NFS.send(:remove_const, :NFS_EXPORTS_PATH)
+    VagrantPlugins::HostLinux::Cap::NFS.const_set(:NFS_EXPORTS_PATH, @original_exports_path)
+    File.unlink(tmp_exports_path.to_s) if File.exist?(tmp_exports_path.to_s)
+    @tmp_exports = nil
+  end
+
+  describe ".nfs_check_command" do
+    let(:cap){ caps.get(:nfs_check_command) }
+
+    context "without systemd" do
+      before{ expect(Vagrant::Util::Platform).to receive(:systemd?).and_return(false) }
+
+      it "should use init.d script" do
+        expect(cap.nfs_check_command(env)).to include("init.d")
+      end
+    end
+    context "with systemd" do
+      before{ expect(Vagrant::Util::Platform).to receive(:systemd?).and_return(true) }
+
+      it "should use systemctl" do
+        expect(cap.nfs_check_command(env)).to include("systemctl")
+      end
+    end
+  end
+
+  describe ".nfs_start_command" do
+    let(:cap){ caps.get(:nfs_start_command) }
+
+    context "without systemd" do
+      before{ expect(Vagrant::Util::Platform).to receive(:systemd?).and_return(false) }
+
+      it "should use init.d script" do
+        expect(cap.nfs_start_command(env)).to include("init.d")
+      end
+    end
+    context "with systemd" do
+      before{ expect(Vagrant::Util::Platform).to receive(:systemd?).and_return(true) }
+
+      it "should use systemctl" do
+        expect(cap.nfs_start_command(env)).to include("systemctl")
+      end
+    end
+  end
+
+  describe ".nfs_export" do
+
+    let(:cap){ caps.get(:nfs_export) }
+
+    before do
+      allow(env).to receive(:host).and_return(host)
+      allow(host).to receive(:capability).with(:nfs_apply_command).and_return("/bin/true")
+      allow(host).to receive(:capability).with(:nfs_check_command).and_return("/bin/true")
+      allow(host).to receive(:capability).with(:nfs_start_command).and_return("/bin/true")
+      allow(ui).to receive(:info)
+      allow(Vagrant::Util::Subprocess).to receive(:execute).and_call_original
+      allow(Vagrant::Util::Subprocess).to receive(:execute).with("sudo", "/bin/true").and_return(double(:result, exit_code: 0))
+      allow(Vagrant::Util::Subprocess).to receive(:execute).with("/bin/true").and_return(double(:result, exit_code: 0))
+    end
+
+    it "should export new entries" do
+      cap.nfs_export(env, ui, SecureRandom.uuid, ["127.0.0.1"], "tmp" => {:hostpath => "/tmp"})
+      exports_content = File.read(exports_path)
+      expect(exports_content).to match(/\/tmp.*127\.0\.0\.1/)
+    end
+
+    it "should not remove existing entries" do
+      File.write(exports_path, "/custom/directory hostname1(rw,sync,no_subtree_check)")
+      cap.nfs_export(env, ui, SecureRandom.uuid, ["127.0.0.1"], "tmp" => {:hostpath => "/tmp"})
+      exports_content = File.read(exports_path)
+      expect(exports_content).to match(/\/tmp.*127\.0\.0\.1/)
+      expect(exports_content).to match(/\/custom\/directory.*hostname1/)
+    end
+
+    it "should remove entries no longer valid" do
+      valid_id = SecureRandom.uuid
+      other_id = SecureRandom.uuid
+      content =<<-EOH
+# VAGRANT-BEGIN: #{Process.uid} #{other_id}
+"/tmp" 127.0.0.1(rw,no_subtree_check,all_squash,anonuid=,anongid=,fsid=)
+# VAGRANT-END: #{Process.uid} #{other_id}
+# VAGRANT-BEGIN: #{Process.uid} #{valid_id}
+"/var" 127.0.0.1(rw,no_subtree_check,all_squash,anonuid=,anongid=,fsid=)
+# VAGRANT-END: #{Process.uid} #{valid_id}
+EOH
+      File.write(exports_path, content)
+      cap.nfs_export(env, ui, valid_id, ["127.0.0.1"], "home" => {:hostpath => "/home"})
+      exports_content = File.read(exports_path)
+      expect(exports_content).to include("/home")
+      expect(exports_content).to include("/tmp")
+      expect(exports_content).not_to include("/var")
+    end
+
+    it "throws an exception with at least 2 different nfs options" do
+      folders = {"/vagrant"=>
+                 {:hostpath=>"/home/vagrant",
+                  :linux__nfs_options=>["rw","all_squash"]},
+                 "/var/www/project"=>
+                 {:hostpath=>"/home/vagrant",
+                  :linux__nfs_options=>["rw","sync"]}}
+
+      expect { cap.nfs_export(env, ui, SecureRandom.uuid, ["127.0.0.1"], folders) }.
+        to raise_error Vagrant::Errors::NFSDupePerms
+    end
+
+    it "writes only 1 hostpath for multiple exports" do
+      folders = {"/vagrant"=>
+                 {:hostpath=>"/home/vagrant",
+                  :linux__nfs_options=>["rw","all_squash"]},
+                 "/var/www/otherproject"=>
+                 {:hostpath=>"/newhome/otherproject",
+                  :linux__nfs_options=>["rw","all_squash"]},
+                 "/var/www/project"=>
+                 {:hostpath=>"/home/vagrant",
+                  :linux__nfs_options=>["rw","all_squash"]}}
+      valid_id = SecureRandom.uuid
+      content =<<-EOH
+\n# VAGRANT-BEGIN: #{Process.uid} #{valid_id}
+"/home/vagrant" 127.0.0.1(rw,all_squash,anonuid=,anongid=,fsid=)
+"/newhome/otherproject" 127.0.0.1(rw,all_squash,anonuid=,anongid=,fsid=)
+# VAGRANT-END: #{Process.uid} #{valid_id}
+EOH
+
+      cap.nfs_export(env, ui, valid_id, ["127.0.0.1"], folders)
+      exports_content = File.read(exports_path)
+      expect(exports_content).to eq(content)
+    end
+
+  end
+
+  describe ".nfs_prune" do
+
+    let(:cap){ caps.get(:nfs_prune) }
+
+    before do
+      allow(ui).to receive(:info)
+    end
+
+    it "should remove entries no longer valid" do
+      invalid_id = SecureRandom.uuid
+      valid_id = SecureRandom.uuid
+      content =<<-EOH
+# VAGRANT-BEGIN: #{Process.uid} #{invalid_id}
+"/tmp" 127.0.0.1(rw,no_subtree_check,all_squash,anonuid=,anongid=,fsid=)
+# VAGRANT-END: #{Process.uid} #{invalid_id}
+# VAGRANT-BEGIN: #{Process.uid} #{valid_id}
+"/var" 127.0.0.1(rw,no_subtree_check,all_squash,anonuid=,anongid=,fsid=)
+# VAGRANT-END: #{Process.uid} #{valid_id}
+EOH
+      File.write(exports_path, content)
+      cap.nfs_prune(env, ui, [valid_id])
+      exports_content = File.read(exports_path)
+      expect(exports_content).to include(valid_id)
+      expect(exports_content).not_to include(invalid_id)
+      expect(exports_content).to include("/var")
+      expect(exports_content).not_to include("/tmp")
+    end
+  end
+
+  describe ".nfs_write_exports" do
+
+    before do
+      File.write(tmp_exports_path, "original content")
+    end
+
+    it "should write updated contents to file" do
+      described_class.nfs_write_exports("new content")
+      exports_content = File.read(exports_path)
+      expect(exports_content).to include("new content")
+      expect(exports_content).not_to include("original content")
+    end
+
+    it "should only update contents if different" do
+      original_stat = File.stat(exports_path)
+      described_class.nfs_write_exports("original content")
+      updated_stat = File.stat(exports_path)
+      expect(original_stat).to eq(updated_stat)
+    end
+
+    it "should retain existing file permissions" do
+      File.chmod(0600, exports_path)
+      original_stat = File.stat(exports_path)
+      described_class.nfs_write_exports("original content")
+      updated_stat = File.stat(exports_path)
+      expect(original_stat.mode).to eq(updated_stat.mode)
+    end
+
+    it "should raise exception when failing to move new exports file" do
+      expect(Vagrant::Util::Subprocess).to receive(:execute).and_return(
+        Vagrant::Util::Subprocess::Result.new(1, "Failed to move file", "")
+      )
+      expect{ described_class.nfs_write_exports("new content") }.to raise_error(Vagrant::Errors::NFSExportsFailed)
+    end
+
+    it "should retain existing file owner and group IDs" do
+      pending("investigate using a simulated FS to test")
+      test_with_simulated_fs
+    end
+
+    it "should raise custom exception when chown fails" do
+      pending("investigate using a simulated FS to test")
+      test_with_simulated_fs
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/test/unit/plugins/kernel_v2/config/push_test.rb

@@ -0,0 +1,352 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require Vagrant.source_root.join("plugins/kernel_v2/config/push")
+
+describe VagrantPlugins::Kernel_V2::PushConfig do
+  include_context "unit"
+
+  subject { described_class.new }
+
+  describe "#define" do
+    let(:pushes) { subject.instance_variable_get(:@__defined_pushes) }
+
+    it "pushes the strategy and block onto the defined pushes array" do
+      subject.define("foo") { "bar" }
+      subject.define("foo") { "zip" }
+      subject.define("foo") { "zap" }
+
+      expect(pushes.size).to eq(1)
+      expect(pushes[:foo].size).to eq(3)
+      expect(pushes[:foo][0]).to be_a(Array)
+      expect(pushes[:foo][0][0]).to eq(:foo)
+      expect(pushes[:foo][0][1]).to be_a(Proc)
+    end
+
+    context "when no strategy is given" do
+      it "defaults to the name" do
+        subject.define("foo") { "bar" }
+
+        expect(pushes.size).to eq(1)
+        expect(pushes[:foo].size).to eq(1)
+        expect(pushes[:foo][0]).to be_a(Array)
+        expect(pushes[:foo][0][0]).to eq(:foo)
+        expect(pushes[:foo][0][1]).to be_a(Proc)
+      end
+    end
+
+    context "when a strategy is given" do
+      it "uses the strategy" do
+        subject.define("foo", strategy: "bacon") { "bar" }
+
+        expect(pushes.size).to eq(1)
+        expect(pushes[:foo].size).to eq(1)
+        expect(pushes[:foo][0]).to be_a(Array)
+        expect(pushes[:foo][0][0]).to eq(:bacon)
+        expect(pushes[:foo][0][1]).to be_a(Proc)
+      end
+    end
+  end
+
+  describe "#merge" do
+    it "appends defined pushes" do
+      a = described_class.new.tap do |i|
+        i.define("foo") { "bar" }
+        i.define("bar") { "bar" }
+      end
+      b = described_class.new.tap do |i|
+        i.define("foo") { "zip" }
+      end
+
+      result = a.merge(b)
+      pushes = result.instance_variable_get(:@__defined_pushes)
+
+      expect(pushes[:foo]).to be_a(Array)
+      expect(pushes[:foo].size).to eq(2)
+
+      expect(pushes[:bar]).to be_a(Array)
+      expect(pushes[:bar].size).to eq(1)
+    end
+  end
+
+  describe "#__compiled_pushes" do
+    it "raises an exception if not finalized" do
+      subject.instance_variable_set(:@__finalized, false)
+      expect { subject.__compiled_pushes }.to raise_error(RuntimeError)
+    end
+
+    it "returns a copy of the compiled pushes" do
+      pushes =  { foo: "bar" }
+      subject.instance_variable_set(:@__finalized, true)
+      subject.instance_variable_set(:@__compiled_pushes, pushes)
+
+      expect(subject.__compiled_pushes).to_not be(pushes)
+      expect(subject.__compiled_pushes).to eq(pushes)
+    end
+  end
+
+  describe "#finalize!" do
+    let(:pushes) { a.merge(b).tap { |r| r.finalize! }.__compiled_pushes }
+    let(:key)    { pushes[:foo][0] }
+    let(:config) { pushes[:foo][1] }
+    let(:unset)  { Vagrant.plugin("2", :config).const_get(:UNSET_VALUE) }
+    let(:dummy_klass) { Vagrant::Config::V2::DummyConfig }
+
+    before do
+      register_plugin("2") do |plugin|
+        plugin.name "foo"
+
+        plugin.push(:foo) do
+          Class.new(Vagrant.plugin("2", :push))
+        end
+
+        plugin.config(:foo, :push) do
+          Class.new(Vagrant.plugin("2", :config)) do
+            attr_accessor :bar
+            attr_accessor :zip
+
+            def initialize
+              @bar = self.class.const_get(:UNSET_VALUE)
+              @zip = self.class.const_get(:UNSET_VALUE)
+            end
+          end
+        end
+      end
+    end
+
+    it "compiles the proper configuration with a single strategy" do
+      instance = described_class.new.tap do |i|
+        i.define "foo"
+      end
+
+      instance.finalize!
+
+      pushes = instance.__compiled_pushes
+      strategy, config = pushes[:foo]
+      expect(strategy).to eq(:foo)
+      expect(config.bar).to be(unset)
+    end
+
+    it "compiles the proper configuration with a single strategy and block" do
+      instance = described_class.new.tap do |i|
+        i.define "foo" do |b|
+          b.bar = 42
+        end
+      end
+
+      instance.finalize!
+
+      pushes = instance.__compiled_pushes
+      strategy, config = pushes[:foo]
+      expect(strategy).to eq(:foo)
+      expect(config.bar).to eq(42)
+    end
+
+    it "compiles the proper config with a name and explicit strategy" do
+      instance = described_class.new.tap do |i|
+        i.define "bar", strategy: "foo"
+      end
+
+      instance.finalize!
+
+      pushes = instance.__compiled_pushes
+      strategy, config = pushes[:bar]
+      expect(strategy).to eq(:foo)
+      expect(config.bar).to be(unset)
+    end
+
+    it "compiles the proper config with a name and explicit strategy with block" do
+      instance = described_class.new.tap do |i|
+        i.define "bar", strategy: "foo" do |b|
+          b.bar = 42
+        end
+      end
+
+      instance.finalize!
+
+      pushes = instance.__compiled_pushes
+      strategy, config = pushes[:bar]
+      expect(strategy).to eq(:foo)
+      expect(config.bar).to eq(42)
+    end
+
+    context "with the same name but different strategy" do
+      context "with no block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "bar")
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "zip")
+          end
+        end
+
+        it "chooses the last config" do
+          expect(key).to eq(:zip)
+          expect(config).to be_kind_of(dummy_klass)
+        end
+      end
+
+      context "with a block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "bar") do |p|
+              p.bar = "a"
+            end
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "zip") do |p|
+              p.zip = "b"
+            end
+          end
+        end
+
+        it "chooses the last config" do
+          expect(key).to eq(:zip)
+          expect(config).to be_kind_of(dummy_klass)
+        end
+      end
+
+      context "with a block, then no block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "bar") do |p|
+              p.bar, p.zip = "a", "a"
+            end
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "zip")
+          end
+        end
+
+        it "chooses the last config" do
+          expect(key).to eq(:zip)
+          expect(config).to be_kind_of(dummy_klass)
+        end
+      end
+
+      context "with no block, then a block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "bar")
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "zip") do |p|
+              p.bar, p.zip = "b", "b"
+            end
+          end
+        end
+
+        it "chooses the last config" do
+          expect(key).to eq(:zip)
+          expect(config).to be_kind_of(dummy_klass)
+        end
+      end
+    end
+
+    context "with the same name twice" do
+      context "with no block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo")
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo")
+          end
+        end
+
+        it "merges the configs" do
+          expect(key).to eq(:foo)
+          expect(config.bar).to be(unset)
+          expect(config.zip).to be(unset)
+        end
+      end
+
+      context "with a block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo") do |p|
+              p.bar = "a"
+            end
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo") do |p|
+              p.zip = "b"
+            end
+          end
+        end
+
+        it "merges the configs" do
+          expect(key).to eq(:foo)
+          expect(config.bar).to eq("a")
+          expect(config.zip).to eq("b")
+        end
+      end
+
+      context "with a block, then no block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo") do |p|
+              p.bar = "a"
+            end
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo")
+          end
+        end
+
+        it "merges the configs" do
+          expect(key).to eq(:foo)
+          expect(config.bar).to eq("a")
+          expect(config.zip).to be(unset)
+        end
+      end
+
+      context "with no block, then a block" do
+        let(:a) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "bar")
+          end
+        end
+
+        let(:b) do
+          described_class.new.tap do |i|
+            i.define("foo", strategy: "zip") do |p|
+              p.zip = "b"
+            end
+          end
+        end
+
+        it "merges the configs" do
+          expect(key).to eq(:zip)
+          expect(config).to be_kind_of(dummy_klass)
+        end
+      end
+    end
+
+    it "sets @__finalized to true" do
+      subject.finalize!
+      expect(subject.instance_variable_get(:@__finalized)).to be(true)
+    end
+  end
+end