vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/config_test.rb

@@ -1,224 +0,0 @@
-require_relative "../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/config")
-
-describe VagrantPlugins::HyperV::Config do
-
-  let(:machine){ double("machine", ui: ui) }
-  let(:ui){ double("ui") }
-
-  describe "#ip_address_timeout" do
-    it "can be set" do
-      subject.ip_address_timeout = 180
-      subject.finalize!
-      expect(subject.ip_address_timeout).to eq(180)
-    end
-    it "defaults to a number" do
-      subject.finalize!
-      expect(subject.ip_address_timeout).to eq(120)
-    end
-  end
-
-  describe "#vlan_id" do
-    it "can be set" do
-      subject.vlan_id = 100
-      subject.finalize!
-      expect(subject.vlan_id).to eq(100)
-    end
-  end
-
-  describe "#mac" do
-    it "can be set" do
-      subject.mac = "001122334455"
-      subject.finalize!
-      expect(subject.mac).to eq("001122334455")
-    end
-  end
-
-  describe "#vmname" do
-    it "can be set" do
-      subject.vmname = "test"
-      subject.finalize!
-      expect(subject.vmname).to eq("test")
-    end
-  end
-
-  describe "#memory" do
-    it "can be set" do
-      subject.memory = 512
-      subject.finalize!
-      expect(subject.memory).to eq(512)
-    end
-  end
-
-  describe "#maxmemory" do
-    it "can be set" do
-      subject.maxmemory = 1024
-      subject.finalize!
-      expect(subject.maxmemory).to eq(1024)
-    end
-  end
-
-  describe "#cpus" do
-    it "can be set" do
-      subject.cpus = 2
-      subject.finalize!
-      expect(subject.cpus).to eq(2)
-    end
-  end
-
-  describe "#vmname" do
-    it "can be set" do
-      subject.vmname = "custom"
-      subject.finalize!
-      expect(subject.vmname).to eq("custom")
-    end
-  end
-
-  describe "#differencing_disk" do
-    it "is false by default" do
-      subject.finalize!
-      expect(subject.differencing_disk).to eq(false)
-    end
-
-    it "can be set" do
-      subject.differencing_disk = true
-      subject.finalize!
-      expect(subject.differencing_disk).to eq(true)
-    end
-
-    it "should set linked_clone" do
-      subject.differencing_disk = true
-      subject.finalize!
-      expect(subject.differencing_disk).to eq(true)
-      expect(subject.linked_clone).to eq(true)
-    end
-
-    it "should provide a deprecation warning when set" do
-      expect(ui).to receive(:warn)
-      subject.differencing_disk = true
-      subject.finalize!
-      subject.validate(machine)
-    end
-  end
-
-  describe "#linked_clone" do
-    it "is false by default" do
-      subject.finalize!
-      expect(subject.linked_clone).to eq(false)
-    end
-
-    it "can be set" do
-      subject.linked_clone = true
-      subject.finalize!
-      expect(subject.linked_clone).to eq(true)
-    end
-
-    it "should set differencing_disk" do
-      subject.linked_clone = true
-      subject.finalize!
-      expect(subject.linked_clone).to eq(true)
-      expect(subject.differencing_disk).to eq(true)
-    end
-  end
-
-  describe "#auto_start_action" do
-    it "should be Nothing by default" do
-      subject.finalize!
-      expect(subject.auto_start_action).to eq("Nothing")
-    end
-
-    it "can be set" do
-      subject.auto_start_action = "Start"
-      subject.finalize!
-      expect(subject.auto_start_action).to eq("Start")
-    end
-
-    it "does not accept invalid values" do
-      subject.auto_start_action = "Invalid"
-      subject.finalize!
-      result = subject.validate(machine)
-      expect(result["Hyper-V"]).not_to be_empty
-    end
-  end
-
-  describe "#auto_stop_action" do
-    it "should be ShutDown by default" do
-      subject.finalize!
-      expect(subject.auto_stop_action).to eq("ShutDown")
-    end
-
-    it "can be set" do
-      subject.auto_stop_action = "Save"
-      subject.finalize!
-      expect(subject.auto_stop_action).to eq("Save")
-    end
-
-    it "does not accept invalid values" do
-      subject.auto_stop_action = "Invalid"
-      subject.finalize!
-      result = subject.validate(machine)
-      expect(result["Hyper-V"]).not_to be_empty
-    end
-  end
-
-  describe "#enable_checkpoints" do
-    it "is false by default" do
-      subject.finalize!
-      expect(subject.enable_checkpoints).to eq(false)
-    end
-
-    it "can be set" do
-      subject.enable_checkpoints = true
-      subject.finalize!
-      expect(subject.enable_checkpoints).to eq(true)
-    end
-  end
-
-  describe "#enable_virtualization_extensions" do
-    it "is false by default" do
-      subject.finalize!
-      expect(subject.enable_virtualization_extensions).to eq(false)
-    end
-
-    it "can be set" do
-      subject.enable_virtualization_extensions = true
-      subject.finalize!
-      expect(subject.enable_virtualization_extensions).to eq(true)
-    end
-  end
-
-  describe "#vm_integration_services" do
-    it "is empty by default" do
-      subject.finalize!
-      expect(subject.vm_integration_services).to be_empty
-    end
-
-    it "accepts new entries" do
-      subject.vm_integration_services["entry"] = "value"
-      subject.finalize!
-      expect(subject.vm_integration_services["entry"]).to eq("value")
-    end
-
-    it "does not accept non-Hash types" do
-      subject.vm_integration_services = "value"
-      subject.finalize!
-      result = subject.validate(machine)
-      expect(result["Hyper-V"]).not_to be_empty
-    end
-
-    it "accepts boolean values within Hash" do
-      subject.vm_integration_services["custom"] = true
-      subject.finalize!
-      result = subject.validate(machine)
-      expect(result["Hyper-V"]).to be_empty
-    end
-
-    it "does not accept non-boolean values within Hash" do
-      subject.vm_integration_services["custom"] = "value"
-      subject.finalize!
-      result = subject.validate(machine)
-      expect(result["Hyper-V"]).not_to be_empty
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/driver_test.rb

@@ -1,175 +0,0 @@
-require_relative "../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/driver")
-
-describe VagrantPlugins::HyperV::Driver do
-  def generate_result(obj)
-    "===Begin-Output===\n" +
-      JSON.dump(obj) +
-      "\n===End-Output==="
-  end
-
-  def generate_error(msg)
-    "===Begin-Error===\n#{JSON.dump(error: msg)}\n===End-Error===\n"
-  end
-
-  let(:result){
-    Vagrant::Util::Subprocess::Result.new(
-      result_exit, result_stdout, result_stderr) }
-  let(:subject){ described_class.new(vm_id) }
-  let(:vm_id){ 1 }
-  let(:result_stdout){ "" }
-  let(:result_stderr){ "" }
-  let(:result_exit){ 0 }
-
-  context "public methods" do
-    before{ allow(subject).to receive(:execute_powershell).and_return(result) }
-
-    describe "#execute" do
-      it "should convert symbol into path string" do
-        expect(subject).to receive(:execute_powershell).with(kind_of(String), any_args)
-          .and_return(result)
-        subject.execute(:thing)
-      end
-
-      it "should append extension when converting symbol" do
-        expect(subject).to receive(:execute_powershell).with("thing.ps1", any_args)
-          .and_return(result)
-        subject.execute(:thing)
-      end
-
-      context "when command returns non-zero exit code" do
-        let(:result_exit){ 1 }
-
-        it "should raise an error" do
-          expect{ subject.execute(:thing) }.to raise_error(VagrantPlugins::HyperV::Errors::PowerShellError)
-        end
-      end
-
-      context "when command stdout matches error pattern" do
-        let(:result_stdout){ generate_error("Error Message") }
-
-        it "should raise an error" do
-          expect{ subject.execute(:thing) }.to raise_error(VagrantPlugins::HyperV::Errors::PowerShellError)
-        end
-      end
-
-      context "with valid JSON output" do
-        let(:result_stdout){ generate_result(:custom => "value") }
-
-        it "should return parsed JSON data" do
-          expect(subject.execute(:thing)).to eq("custom" => "value")
-        end
-      end
-
-      context "with invalid JSON output" do
-        let(:result_stdout){ "value" }
-        it "should return nil" do
-          expect(subject.execute(:thing)).to be_nil
-        end
-      end
-    end
-
-    describe "#has_vmcx_support?" do
-      context "when support is available" do
-        let(:result_stdout){ generate_result(:result => true) }
-
-        it "should be true" do
-          expect(subject.has_vmcx_support?).to eq(true)
-        end
-      end
-
-      context "when support is not available" do
-        let(:result_stdout){ generate_result(:result => false) }
-
-        it "should be false" do
-          expect(subject.has_vmcx_support?).to eq(false)
-        end
-      end
-    end
-
-    describe "#set_vm_integration_services" do
-      it "should map known integration services names automatically" do
-        expect(subject).to receive(:execute) do |name, args|
-          expect(args[:Name]).to eq("Shutdown")
-        end
-        subject.set_vm_integration_services(shutdown: true)
-      end
-
-      it "should set enable when value is true" do
-        expect(subject).to receive(:execute) do |name, args|
-          expect(args[:Enable]).to eq(true)
-        end
-        subject.set_vm_integration_services(shutdown: true)
-      end
-
-      it "should not set enable when value is false" do
-        expect(subject).to receive(:execute) do |name, args|
-          expect(args[:Enable]).to be_nil
-        end
-        subject.set_vm_integration_services(shutdown: false)
-      end
-
-      it "should pass unknown key names directly through" do
-        expect(subject).to receive(:execute) do |name, args|
-          expect(args[:Name]).to eq("CustomKey")
-        end
-        subject.set_vm_integration_services(CustomKey: true)
-      end
-    end
-  end
-
-  describe "#execute_powershell" do
-    before{ allow(Vagrant::Util::PowerShell).to receive(:execute) }
-
-    it "should call the PowerShell module to execute" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute)
-      subject.send(:execute_powershell, "path", {})
-    end
-
-    it "should modify the path separators" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute)
-        .with("\\path\\to\\script.ps1", any_args)
-      subject.send(:execute_powershell, "/path/to/script.ps1", {})
-    end
-
-    it "should include ErrorAction option as Stop" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute) do |path, *args|
-        expect(args).to include("-ErrorAction")
-        expect(args).to include("Stop")
-      end
-      subject.send(:execute_powershell, "path", {})
-    end
-
-    it "should automatically include module path" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute) do |path, *args|
-        opts = args.detect{|i| i.is_a?(Hash)}
-        expect(opts[:module_path]).not_to be_nil
-      end
-      subject.send(:execute_powershell, "path", {})
-    end
-
-    it "should covert hash options into arguments" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute) do |path, *args|
-        expect(args).to include("-Custom")
-        expect(args).to include("'Value'")
-      end
-      subject.send(:execute_powershell, "path", "Custom" => "Value")
-    end
-
-    it "should treat keys with `true` value as switches" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute) do |path, *args|
-        expect(args).to include("-Custom")
-        expect(args).not_to include("'true'")
-      end
-      subject.send(:execute_powershell, "path", "Custom" => true)
-    end
-
-    it "should not include keys with `false` value" do
-      expect(Vagrant::Util::PowerShell).to receive(:execute) do |path, *args|
-        expect(args).not_to include("-Custom")
-      end
-      subject.send(:execute_powershell, "path", "Custom" => false)
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/provider_test.rb

@@ -1,106 +0,0 @@
-require_relative "../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/provider")
-
-describe VagrantPlugins::HyperV::Provider do
-  let(:machine) { double("machine") }
-  let(:platform)   { double("platform") }
-  let(:powershell) { double("powershell") }
-
-  subject { described_class.new(machine) }
-
-  before do
-    stub_const("Vagrant::Util::Platform", platform)
-    stub_const("Vagrant::Util::PowerShell", powershell)
-    allow(machine).to receive(:id).and_return("foo")
-    allow(platform).to receive(:windows?).and_return(true)
-    allow(platform).to receive(:wsl?).and_return(false)
-    allow(platform).to receive(:windows_admin?).and_return(true)
-    allow(platform).to receive(:windows_hyperv_admin?).and_return(true)
-    allow(powershell).to receive(:available?).and_return(true)
-  end
-
-  describe ".usable?" do
-    subject { described_class }
-
-    it "returns false if not windows" do
-      allow(platform).to receive(:windows?).and_return(false)
-      expect(subject).to_not be_usable
-    end
-
-    it "returns true if within WSL" do
-      expect(platform).to receive(:windows?).and_return(false)
-      expect(platform).to receive(:wsl?).and_return(true)
-      expect(subject).to be_usable
-    end
-
-    it "returns false if neither an admin nor a hyper-v admin" do
-      allow(platform).to receive(:windows_admin?).and_return(false)
-      allow(platform).to receive(:windows_hyperv_admin?).and_return(false)
-      expect(subject).to_not be_usable
-    end
-
-    it "returns true if not an admin but is a hyper-v admin" do
-      allow(platform).to receive(:windows_admin?).and_return(false)
-      allow(platform).to receive(:windows_hyperv_admin?).and_return(true)
-      expect(subject).to be_usable
-    end
-
-    it "returns false if powershell is not available" do
-      allow(powershell).to receive(:available?).and_return(false)
-      expect(subject).to_not be_usable
-    end
-
-    it "raises an exception if not windows" do
-      allow(platform).to receive(:windows?).and_return(false)
-
-      expect { subject.usable?(true) }.
-        to raise_error(VagrantPlugins::HyperV::Errors::WindowsRequired)
-    end
-
-    it "raises an exception if neither an admin nor a hyper-v admin" do
-      allow(platform).to receive(:windows_admin?).and_return(false)
-      allow(platform).to receive(:windows_hyperv_admin?).and_return(false)
-
-      expect { subject.usable?(true) }.
-        to raise_error(VagrantPlugins::HyperV::Errors::AdminRequired)
-    end
-
-    it "raises an exception if neither an admin nor a hyper-v admin" do
-      allow(platform).to receive(:windows_admin?).and_return(false)
-      allow(platform).to receive(:windows_hyperv_admin?).and_return(false)
-
-      expect { subject.usable?(true) }.
-        to raise_error(VagrantPlugins::HyperV::Errors::AdminRequired)
-    end
-
-    it "raises an exception if powershell is not available" do
-      allow(powershell).to receive(:available?).and_return(false)
-
-      expect { subject.usable?(true) }.
-        to raise_error(VagrantPlugins::HyperV::Errors::PowerShellRequired)
-    end
-  end
-
-  describe "#driver" do
-    it "is initialized" do
-      expect(subject.driver).to be_kind_of(VagrantPlugins::HyperV::Driver)
-    end
-  end
-
-  describe "#state" do
-    it "returns not_created if no ID" do
-      allow(machine).to receive(:id).and_return(nil)
-
-      expect(subject.state.id).to eq(:not_created)
-    end
-
-    it "calls an action to determine the ID" do
-      allow(machine).to receive(:id).and_return("foo")
-      expect(machine).to receive(:action).with(:read_state).
-        and_return({ machine_state_id: :bar })
-
-      expect(subject.state.id).to eq(:bar)
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/virtualbox/action/network_fix_ipv6_test.rb

@@ -1,165 +0,0 @@
-require_relative "../base"
-require 'socket'
-
-describe VagrantPlugins::ProviderVirtualBox::Action::NetworkFixIPv6 do
-  include_context "unit"
-  include_context "virtualbox"
-
-  let(:iso_env) do
-    env = isolated_environment
-    env.vagrantfile("")
-    env.create_vagrant_env
-  end
-
-  let(:machine) do
-    iso_env.machine(iso_env.machine_names[0], :dummy).tap do |m|
-      allow(m.provider).to receive(:driver).and_return(driver)
-    end
-  end
-
-  let(:env) {{ machine: machine }}
-  let(:app) { lambda { |*args| }}
-  let(:driver) { double("driver") }
-
-  subject { described_class.new(app, env) }
-
-  it "ignores nil IP addresses" do
-    allow(machine.config.vm).to receive(:networks)
-      .and_return(private_network: { ip: nil })
-    expect { subject.call(env) }.to_not raise_error
-  end
-
-  it "blank nil IP addresses" do
-    allow(machine.config.vm).to receive(:networks)
-      .and_return(private_network: { ip: "" })
-    expect { subject.call(env) }.to_not raise_error
-  end
-
-  context "with IPv6 interfaces" do
-    let(:socket) { double("socket") }
-
-    before do
-      # This address is only used to trigger the fixup code. It doesn't matter
-      # what it is.
-      allow(machine.config.vm).to receive(:networks)
-        .and_return(private_network: { ip: 'fe:80::' })
-      allow(UDPSocket).to receive(:new).with(Socket::AF_INET6)
-        .and_return(socket)
-      allow(socket).to receive(:connect)
-    end
-
-    it "only checks the interfaces associated with the VM" do
-      all_networks = [{name: "vboxnet0",
-                       ipv6: "dead:beef::",
-                       ipv6_prefix: 64,
-                       status: 'Up'
-                      },
-                      {name: "vboxnet1",
-                       ipv6: "badd:badd::",
-                       ipv6_prefix: 64,
-                       status: 'Up'
-                      }
-                     ]
-      ifaces = { 1 => {type: :hostonly, hostonly: "vboxnet0"}
-               }
-      allow(machine.provider.driver).to receive(:read_network_interfaces)
-        .and_return(ifaces)
-      allow(machine.provider.driver).to receive(:read_host_only_interfaces)
-        .and_return(all_networks)
-      subject.call(env)
-      expect(socket).to have_received(:connect)
-        .with(all_networks[0][:ipv6] + (['ffff']*4).join(':'), 80)
-    end
-
-    it "correctly uses the netmask to figure out the probe address" do
-      all_networks = [{name: "vboxnet0",
-                       ipv6: "dead:beef::",
-                       ipv6_prefix: 113,
-                       status: 'Up'
-                      }
-                     ]
-      ifaces = { 1 => {type: :hostonly, hostonly: "vboxnet0"}
-               }
-      allow(machine.provider.driver).to receive(:read_network_interfaces)
-        .and_return(ifaces)
-      allow(machine.provider.driver).to receive(:read_host_only_interfaces)
-        .and_return(all_networks)
-      subject.call(env)
-      expect(socket).to have_received(:connect)
-        .with(all_networks[0][:ipv6] + '7fff', 80)
-    end
-
-    it "should ignore interfaces that are down" do
-      all_networks = [{name: "vboxnet0",
-                       ipv6: "dead:beef::",
-                       ipv6_prefix: 64,
-                       status: 'Down'
-                      }
-                     ]
-      ifaces = { 1 => {type: :hostonly, hostonly: "vboxnet0"}
-               }
-      allow(machine.provider.driver).to receive(:read_network_interfaces)
-        .and_return(ifaces)
-      allow(machine.provider.driver).to receive(:read_host_only_interfaces)
-        .and_return(all_networks)
-      subject.call(env)
-      expect(socket).to_not have_received(:connect)
-    end
-
-    it "should ignore interfaces without an IPv6 address" do
-      all_networks = [{name: "vboxnet0",
-                       ipv6: "",
-                       ipv6_prefix: 0,
-                       status: 'Up'
-                      }
-                     ]
-      ifaces = { 1 => {type: :hostonly, hostonly: "vboxnet0"}
-               }
-      allow(machine.provider.driver).to receive(:read_network_interfaces)
-        .and_return(ifaces)
-      allow(machine.provider.driver).to receive(:read_host_only_interfaces)
-        .and_return(all_networks)
-      subject.call(env)
-      expect(socket).to_not have_received(:connect)
-    end
-
-    it "should ignore nat interfaces" do
-      all_networks = [{name: "vboxnet0",
-                       ipv6: "",
-                       ipv6_prefix: 0,
-                       status: 'Up'
-                      }
-                     ]
-      ifaces = { 1 => {type: :nat}
-               }
-      allow(machine.provider.driver).to receive(:read_network_interfaces)
-        .and_return(ifaces)
-      allow(machine.provider.driver).to receive(:read_host_only_interfaces)
-        .and_return(all_networks)
-      subject.call(env)
-      expect(socket).to_not have_received(:connect)
-    end
-
-    it "should reconfigure an interface if unreachable" do
-      all_networks = [{name: "vboxnet0",
-                       ipv6: "dead:beef::",
-                       ipv6_prefix: 64,
-                       status: 'Up'
-                      }
-                     ]
-      ifaces = { 1 => {type: :hostonly, hostonly: "vboxnet0"}
-               }
-      allow(machine.provider.driver).to receive(:read_network_interfaces)
-        .and_return(ifaces)
-      allow(machine.provider.driver).to receive(:read_host_only_interfaces)
-        .and_return(all_networks)
-      allow(socket).to receive(:connect)
-        .with(all_networks[0][:ipv6] + (['ffff']*4).join(':'), 80)
-        .and_raise Errno::EHOSTUNREACH
-      allow(machine.provider.driver).to receive(:reconfig_host_only)
-      subject.call(env)
-      expect(machine.provider.driver).to have_received(:reconfig_host_only)
-        .with(all_networks[0])
-    end
-  end
-end