vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/hosts/windows/cap/smb_test.rb

@@ -1,228 +0,0 @@
-require_relative "../../../../base"
-
-require_relative "../../../../../../plugins/hosts/windows/cap/smb"
-
-describe VagrantPlugins::HostWindows::Cap::SMB do
-  let(:subject){ VagrantPlugins::HostWindows::Cap::SMB }
-  let(:machine){ double(:machine, env: double(:machine_env, ui: double(:ui))) }
-  let(:env){ double(:env) }
-  let(:options){ {} }
-  let(:result){ Vagrant::Util::Subprocess::Result }
-  let(:powershell_version){ "3" }
-  let(:smblist){ <<-EOF
-Name        : vgt-CUSTOM_ID-1
-Path        : /a/path
-Description : vgt-CUSTOM_ID-1
-
-Name        : vgt-CUSTOM_ID-2
-Path        : /other/path
-Description : vgt-CUSTOM_ID-2
-
-Name        : my-share
-Path        : /my/path
-Description : Not Vagrant Owned
-
-    EOF
-  }
-  let(:netsharelist){ <<-EOF
-
-Share name        Resource     Remark
------------------------------------------------
-vgt-CUSTOM_ID-1   /a/path      vgt-CUSTOM_ID-1
-vgt-CUSTOM_ID-2   /other/path  vgt-CUSTOM_ID-2
-my-share          /my/path     Not Vagran...
-The command completed successfully.
-    EOF
-  }
-  let(:netshare1){ <<-EOF
-Share name vgt-CUSTOM_ID-1
-Path       /a/path
-Remark     vgt-CUSTOM_ID-1
-    EOF
-  }
-  let(:netshare2){ <<-EOF
-Share name vgt-CUSTOM_ID-2
-Path       /other/path
-Remark     vgt-CUSTOM_ID-2
-    EOF
-  }
-  let(:netshare_my){ <<-EOF
-Share name my-share
-Path       /my/path
-Remark     Not Vagrant Owned
-    EOF
-  }
-
-
-  before do
-    allow(subject).to receive(:machine_id).and_return("CUSTOM_ID")
-    allow(Vagrant::Util::PowerShell).to receive(:version).and_return(powershell_version)
-    allow(Vagrant::Util::PowerShell).to receive(:execute_cmd).and_return("")
-    allow(machine.env.ui).to receive(:warn)
-    allow(subject).to receive(:sleep)
-  end
-
-  describe ".smb_mount_options" do
-    it "should provide smb version of at least 2" do
-      result = subject.smb_mount_options(nil)
-      ver = result.detect{|i| i.start_with?("vers") }.to_s.split("=", 2).last.to_s.to_i
-      expect(ver).to be >= 2
-    end
-  end
-
-  describe ".smb_installed" do
-    context "when powershell version is greater than 2" do
-      it "is valid installation" do
-        expect(subject.smb_installed(nil)).to eq(true)
-      end
-    end
-
-    context "when powershell version is less than 3" do
-      let(:powershell_version){ "2" }
-
-      it "is not a valid installation" do
-        expect(subject.smb_installed(nil)).to eq(false)
-      end
-    end
-  end
-
-  describe ".smb_cleanup" do
-    before do
-      allow(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/Get-SmbShare/).
-        and_return(smblist)
-      allow(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/net share/).and_return(netsharelist)
-      allow(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/net share vgt-CUSTOM_ID-1/).and_return(netshare1)
-      allow(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/net share vgt-CUSTOM_ID-2/).and_return(netshare2)
-      allow(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/net share my/).and_return(netshare_my)
-      allow(Vagrant::Util::PowerShell).to receive(:execute).and_return(result.new(0, "", ""))
-    end
-    after{ subject.smb_cleanup(env, machine, options) }
-
-    it "should pause after warning user" do
-      expect(machine.env.ui).to receive(:warn)
-      expect(subject).to receive(:sleep)
-    end
-
-    it "should remove owned shares" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute) do |*args|
-        expect(args).to include("vgt-CUSTOM_ID-1")
-        expect(args).to include("vgt-CUSTOM_ID-2")
-        result.new(0, "", "")
-      end
-    end
-
-    it "should not remove owned shares" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute) do |*args|
-        expect(args).not_to include("my-share")
-        result.new(0, "", "")
-      end
-    end
-
-    it "should remove all shares in single call" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute).with(any_args, sudo: true).once
-    end
-
-    context "when no shares are defined" do
-      before do
-        expect(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/Get-SmbShare/).
-          and_return("")
-      end
-
-      it "should not attempt to remove shares" do
-        expect(Vagrant::Util::PowerShell).not_to receive(:execute).with(any_args, sudo: true)
-      end
-
-      it "should not warn user" do
-        expect(machine.env.ui).not_to receive(:warn)
-      end
-    end
-
-    context "when Get-SmbShare is not available" do
-      before do
-        expect(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/Get-SmbShare/).and_return(nil)
-      end
-
-      it "should fetch list using net.exe" do
-        expect(Vagrant::Util::PowerShell).to receive(:execute_cmd).with(/net share/).and_return("")
-      end
-
-      it "should remove owned shares" do
-        expect(Vagrant::Util::PowerShell).to receive(:execute) do |*args|
-          expect(args).to include("vgt-CUSTOM_ID-1")
-          expect(args).to include("vgt-CUSTOM_ID-2")
-          result.new(0, "", "")
-        end
-      end
-
-      it "should not remove owned shares" do
-        expect(Vagrant::Util::PowerShell).to receive(:execute) do |*args|
-          expect(args).not_to include("my-share")
-          result.new(0, "", "")
-        end
-      end
-    end
-  end
-
-  describe ".smb_prepare" do
-    let(:folders){ {"/first/path" => {hostpath: "/host/1"}, "/second/path" => {hostpath: "/host/2", smb_id: "ID1"}} }
-    let(:options){ {} }
-
-    before{ allow(Vagrant::Util::PowerShell).to receive(:execute).and_return(result.new(0, "", "")) }
-
-    it "should add ID when not defined" do
-      subject.smb_prepare(env, machine, folders, options)
-      expect(folders["/first/path"][:smb_id]).to start_with("vgt-")
-    end
-
-    it "should not modify ID when defined" do
-      subject.smb_prepare(env, machine, folders, options)
-      expect(folders["/second/path"][:smb_id]).to eq("ID1")
-    end
-
-    it "should pause after warning user" do
-      expect(machine.env.ui).to receive(:warn)
-      expect(subject).to receive(:sleep)
-      subject.smb_prepare(env, machine, folders, options)
-    end
-
-    it "should add all shares in single call" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute).with(any_args, sudo: true).once
-      subject.smb_prepare(env, machine, folders, options)
-    end
-
-    context "when share already exists" do
-      let(:shares){ {"ID1" => {"Path" => "/host/2"}} }
-      before do
-        allow(File).to receive(:expand_path).and_call_original
-        expect(subject).to receive(:existing_shares).and_return(shares)
-      end
-
-      it "should expand paths when comparing existing to requested" do
-        expect(File).to receive(:expand_path).at_least(2).with("/host/2").and_return("expanded_path")
-        subject.smb_prepare(env, machine, folders, options)
-      end
-
-      context "with different path" do
-        let(:shares){ {"ID1" => {"Path" => "/host/3"}} }
-
-        it "should raise an error" do
-          expect{
-            subject.smb_prepare(env, machine, folders, options)
-          }.to raise_error(VagrantPlugins::SyncedFolderSMB::Errors::SMBNameError)
-        end
-      end
-    end
-
-    context "when no shared are defined" do
-      after{ subject.smb_prepare(env, machine, {}, options) }
-
-      it "should not attempt to add shares" do
-        expect(Vagrant::Util::PowerShell).not_to receive(:execute).with(any_args, sudo: true)
-      end
-
-      it "should not warn user" do
-        expect(machine.env.ui).not_to receive(:warn)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/hosts/windows/cap/ssh_test.rb

@@ -1,38 +0,0 @@
-require_relative "../../../../base"
-
-require_relative "../../../../../../plugins/hosts/windows/cap/ssh"
-
-describe VagrantPlugins::HostWindows::Cap::SSH do
-  let(:subject){ VagrantPlugins::HostWindows::Cap::SSH }
-  let(:result){ Vagrant::Util::Subprocess::Result.new(exit_code, stdout, stderr) }
-  let(:exit_code){ 0 }
-  let(:stdout){ "" }
-  let(:stderr){ "" }
-
-  let(:key_path){ double("keypath", to_s: "keypath") }
-  let(:env){ double("env") }
-
-  before do
-    allow(Vagrant::Util::PowerShell).to receive(:execute).and_return(result)
-  end
-
-  it "should execute PowerShell script" do
-    expect(Vagrant::Util::PowerShell).to receive(:execute).with(
-      /set_ssh_key_permissions.ps1/, "-KeyPath", key_path.to_s, any_args
-    ).and_return(result)
-    subject.set_ssh_key_permissions(env, key_path)
-  end
-
-  it "should return the result" do
-
-    expect(subject.set_ssh_key_permissions(env, key_path)).to eq(result)
-  end
-
-  context "when command fails" do
-    let(:exit_code){ 1 }
-
-    it "should raise an error" do
-      expect{ subject.set_ssh_key_permissions(env, key_path) }.to raise_error(Vagrant::Errors::PowerShellError)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/kernel_v2/config/package_test.rb

@@ -1,14 +0,0 @@
-require File.expand_path("../../../../base", __FILE__)
-
-require Vagrant.source_root.join("plugins/kernel_v2/config/package")
-
-describe VagrantPlugins::Kernel_V2::PackageConfig do
-  subject { described_class.new }
-
-  describe "#name" do
-    it "defaults to nil" do
-      subject.finalize!
-      expect(subject.name).to be_nil
-    end
-  end
-end

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

@@ -1,352 +0,0 @@
-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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/kernel_v2/config/ssh_test.rb

@@ -1,21 +0,0 @@
-require File.expand_path("../../../../base", __FILE__)
-
-require Vagrant.source_root.join("plugins/kernel_v2/config/ssh")
-
-describe VagrantPlugins::Kernel_V2::SSHConfig do
-  subject { described_class.new }
-
-  describe "#default" do
-    it "defaults to vagrant username" do
-      subject.finalize!
-      expect(subject.default.username).to eq("vagrant")
-    end
-  end
-
-  describe "#sudo_command" do
-    it "defaults properly" do
-      subject.finalize!
-      expect(subject.sudo_command).to eq("sudo -E -H %c")
-    end
-  end
-end