vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/configure_test.rb

@@ -1,125 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/configure")
-
-describe VagrantPlugins::HyperV::Action::Configure do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, config: config, provider_config: provider_config, data_dir: data_dir, id: "machineID") }
-  let(:data_dir){ double("data_dir") }
-  let(:config){ double("config", vm: vm) }
-  let(:vm){ double("vm", networks: networks) }
-  let(:networks){ [] }
-  let(:switches){ [
-    {"Name" => "Switch1", "Id" => "ID1"},
-    {"Name" => "Switch2", "Id" => "ID2"}
-  ]}
-  let(:sentinel){ double("sentinel") }
-  let(:provider_config){
-    double("provider_config",
-      memory: "1024",
-      maxmemory: "1024",
-      cpus: 1,
-      auto_start_action: "Nothing",
-      auto_stop_action: "Save",
-      enable_checkpoints: false,
-      enable_virtualization_extensions: false,
-      vm_integration_services: vm_integration_services
-    )
-  }
-  let(:vm_integration_services){ {} }
-
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(driver).to receive(:execute)
-    allow(app).to receive(:call)
-    expect(driver).to receive(:execute).with(:get_switches).and_return(switches)
-    allow(ui).to receive(:detail)
-    allow(ui).to receive(:output)
-    allow(ui).to receive(:ask).and_return("1")
-    allow(data_dir).to receive(:join).and_return(sentinel)
-    allow(sentinel).to receive(:file?).and_return(false)
-    allow(sentinel).to receive(:open)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  context "with missing switch sentinel file" do
-    it "should prompt for switch to use" do
-      expect(ui).to receive(:ask)
-      subject.call(env)
-    end
-
-    it "should write sentinel file" do
-      expect(sentinel).to receive(:open)
-      subject.call(env)
-    end
-  end
-
-  context "with existing switch sentinel file" do
-    before{ allow(sentinel).to receive(:file?).twice.and_return(true) }
-
-    it "should not prompt for switch to use" do
-      expect(ui).not_to receive(:ask)
-      subject.call(env)
-    end
-
-    it "should not write sentinel file" do
-      expect(sentinel).not_to receive(:open)
-      subject.call(env)
-    end
-  end
-
-  context "with bridge defined in networks" do
-    context "with valid bridge switch name" do
-      let(:networks){ [[:public_network, {bridge: "Switch1"}]] }
-
-      it "should not prompt for switch" do
-        expect(ui).not_to receive(:ask)
-        subject.call(env)
-      end
-    end
-
-    context "with valid bridge switch ID" do
-      let(:networks){ [[:public_network, {bridge: "ID1"}]] }
-
-      it "should not prompt for switch" do
-        expect(ui).not_to receive(:ask)
-        subject.call(env)
-      end
-    end
-
-    context "with invalid bridge switch name" do
-      let(:networks){ [[:public_network, {bridge: "UNKNOWN"}]] }
-
-      it "should prompt for switch" do
-        expect(ui).to receive(:ask)
-        subject.call(env)
-      end
-    end
-  end
-
-  context "with integration services enabled" do
-    let(:vm_integration_services){ {service: true} }
-
-    it "should call the driver to set the services" do
-      expect(driver).to receive(:set_vm_integration_services)
-      subject.call(env)
-    end
-  end
-
-  context "without available switches" do
-    let(:switches){ [] }
-
-    it "should raise an error" do
-      expect{ subject.call(env) }.to raise_error(VagrantPlugins::HyperV::Errors::NoSwitches)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/delete_vm_test.rb

@@ -1,41 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/delete_vm")
-
-describe VagrantPlugins::HyperV::Action::DeleteVM do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, data_dir: "/dev/null") }
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(app).to receive(:call)
-    allow(ui).to receive(:info)
-    allow(driver).to receive(:delete_vm)
-    allow(FileUtils).to receive(:rm_rf)
-    allow(FileUtils).to receive(:mkdir_p)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should call the driver to delete the vm" do
-    expect(driver).to receive(:delete_vm)
-    subject.call(env)
-  end
-
-  it "should delete the data directory" do
-    expect(FileUtils).to receive(:rm_rf).with(machine.data_dir)
-    subject.call(env)
-  end
-
-  it "should recreate the data directory" do
-    expect(FileUtils).to receive(:mkdir_p).with(machine.data_dir)
-    subject.call(env)
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/export_test.rb

@@ -1,42 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/export")
-
-describe VagrantPlugins::HyperV::Action::Export do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, state: state) }
-  let(:state){ double("state", id: machine_state) }
-  let(:machine_state){ :off }
-
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(app).to receive(:call)
-    allow(ui).to receive(:info)
-    allow(ui).to receive(:clear_line)
-    allow(ui).to receive(:report_progress)
-    allow(driver).to receive(:export)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should call the driver to perform the export" do
-    expect(driver).to receive(:export)
-    subject.call(env)
-  end
-
-  context "with invalid machine state" do
-    let(:machine_state){ :on }
-
-    it "should raise an error" do
-      expect{ subject.call(env) }.to raise_error(Vagrant::Errors::VMPowerOffToPackage)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/import_test.rb

@@ -1,130 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/import")
-
-describe VagrantPlugins::HyperV::Action::Import do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, provider_config: provider_config, box: box, data_dir: data_dir, name: "machname") }
-  let(:provider_config){
-    double("provider_config",
-      linked_clone: false,
-      vmname: "VMNAME"
-    )
-  }
-  let(:box){ double("box", directory: box_directory) }
-  let(:box_directory){ double("box_directory") }
-  let(:data_dir){ double("data_dir") }
-  let(:vm_dir){ double("vm_dir") }
-  let(:hd_dir){ double("hd_dir") }
-
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(app).to receive(:call)
-    allow(box_directory).to receive(:join).with("Virtual Machines").and_return(vm_dir)
-    allow(box_directory).to receive(:join).with("Virtual Hard Disks").and_return(hd_dir)
-    allow(vm_dir).to receive(:directory?).and_return(true)
-    allow(vm_dir).to receive(:each_child).and_yield(Pathname.new("file.txt"))
-    allow(hd_dir).to receive(:directory?).and_return(true)
-    allow(hd_dir).to receive(:each_child).and_yield(Pathname.new("file.txt"))
-    allow(driver).to receive(:has_vmcx_support?).and_return(true)
-    allow(data_dir).to receive(:join).and_return(data_dir)
-    allow(data_dir).to receive(:to_s).and_return("DATA_DIR_PATH")
-    allow(driver).to receive(:import).and_return("id" => "VMID")
-    allow(machine).to receive(:id=)
-    allow(ui).to receive(:output)
-    allow(ui).to receive(:detail)
-  end
-
-  context "with missing virtual machines directory" do
-    before{ expect(vm_dir).to receive(:directory?).and_return(false) }
-
-    it "should raise an error" do
-      expect{ subject.call(env) }.to raise_error(VagrantPlugins::HyperV::Errors::BoxInvalid)
-    end
-  end
-
-  context "with missing hard disks directory" do
-    before{ expect(hd_dir).to receive(:directory?).and_return(false) }
-
-    it "should raise an error" do
-      expect{ subject.call(env) }.to raise_error(VagrantPlugins::HyperV::Errors::BoxInvalid)
-    end
-  end
-
-  context "with missing configuration file" do
-    before do
-      allow(hd_dir).to receive(:each_child).and_yield(Pathname.new("image.vhd"))
-    end
-
-    it "should raise an error" do
-      expect{ subject.call(env) }.to raise_error(VagrantPlugins::HyperV::Errors::BoxInvalid)
-    end
-  end
-
-  context "with missing image file" do
-    before do
-      allow(vm_dir).to receive(:each_child).and_yield(Pathname.new("config.xml"))
-    end
-
-    it "should raise an error" do
-      expect{ subject.call(env) }.to raise_error(VagrantPlugins::HyperV::Errors::BoxInvalid)
-    end
-  end
-
-  context "with image and config files" do
-    before do
-      allow(vm_dir).to receive(:each_child).and_yield(Pathname.new("config.xml"))
-      allow(hd_dir).to receive(:each_child).and_yield(Pathname.new("image.vhd"))
-    end
-
-    it "should call the app on success" do
-      expect(app).to receive(:call)
-      subject.call(env)
-    end
-
-    it "should request import via the driver" do
-      expect(driver).to receive(:import).and_return("id" => "VMID")
-      subject.call(env)
-    end
-
-    it "should set the machine ID after import" do
-      expect(machine).to receive(:id=).with("VMID")
-      subject.call(env)
-    end
-
-    context "with no vmcx support" do
-      before do
-        expect(driver).to receive(:has_vmcx_support?).and_return(false)
-      end
-
-      it "should match XML config file" do
-        subject.call(env)
-      end
-
-      it "should not match VMCX config file" do
-        expect(vm_dir).to receive(:each_child).and_yield(Pathname.new("config.vmcx"))
-        expect{ subject.call(env) }.to raise_error(VagrantPlugins::HyperV::Errors::BoxInvalid)
-      end
-    end
-
-    context "with vmcx support" do
-      before do
-        expect(driver).to receive(:has_vmcx_support?).and_return(true)
-      end
-
-      it "should match XML config file" do
-        subject.call(env)
-      end
-
-      it "should match VMCX config file" do
-        expect(vm_dir).to receive(:each_child).and_yield(Pathname.new("config.vmcx"))
-        subject.call(env)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/is_windows_test.rb

@@ -1,37 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/is_windows")
-
-describe VagrantPlugins::HyperV::Action::IsWindows do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, config: config) }
-  let(:config){ double("config", vm: vm) }
-  let(:vm){ double("vm", guest: :windows) }
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(app).to receive(:call)
-    allow(env).to receive(:[]=)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should update the env with the result" do
-    expect(env).to receive(:[]=).with(:result, true)
-    subject.call(env)
-  end
-
-  it "should set the result to false when not windows" do
-    expect(vm).to receive(:guest).and_return(:linux)
-    expect(env).to receive(:[]=).with(:result, false)
-    subject.call(env)
-  end
-
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/net_set_mac_test.rb

@@ -1,40 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/net_set_mac")
-
-describe VagrantPlugins::HyperV::Action::NetSetMac do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, provider_config: provider_config) }
-  let(:provider_config){ double("provider_config", mac: mac) }
-  let(:mac){ "ADDRESS" }
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(ui).to receive(:info)
-    allow(driver).to receive(:net_set_mac)
-    allow(app).to receive(:call)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should call the driver to set the MAC address" do
-    expect(driver).to receive(:net_set_mac).with(mac)
-    subject.call(env)
-  end
-
-  context "with no MAC address provided" do
-    let(:mac){ nil }
-
-    it "should not call driver to set the MAC address" do
-      expect(driver).not_to receive(:net_set_mac)
-      subject.call(env)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/net_set_vlan_test.rb

@@ -1,40 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/net_set_vlan")
-
-describe VagrantPlugins::HyperV::Action::NetSetVLan do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, provider_config: provider_config) }
-  let(:provider_config){ double("provider_config", vlan_id: vlan_id) }
-  let(:vlan_id){ "VID" }
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(ui).to receive(:info)
-    allow(driver).to receive(:net_set_vlan)
-    allow(app).to receive(:call)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should call the driver to set the vlan id" do
-    expect(driver).to receive(:net_set_vlan).with(vlan_id)
-    subject.call(env)
-  end
-
-  context "with no vlan id provided" do
-    let(:vlan_id){ nil }
-
-    it "should not call driver to set the vlan id" do
-      expect(driver).not_to receive(:net_set_vlan)
-      subject.call(env)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/read_guest_ip_test.rb

@@ -1,39 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/read_guest_ip")
-
-describe VagrantPlugins::HyperV::Action::ReadGuestIP do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider) }
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(app).to receive(:call)
-    allow(env).to receive(:[]=)
-    allow(machine).to receive(:id)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  context "with machine ID set" do
-    before{ allow(machine).to receive(:id).and_return("VMID") }
-
-    it "should request guest IP from the driver" do
-      expect(driver).to receive(:read_guest_ip).and_return("ip" => "ADDRESS")
-      subject.call(env)
-    end
-
-    it "should set the host information into the env" do
-      expect(env).to receive(:[]=).with(:machine_ssh_info, host: "ADDRESS")
-      expect(driver).to receive(:read_guest_ip).and_return("ip" => "ADDRESS")
-      subject.call(env)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/read_state_test.rb

@@ -1,56 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/read_state")
-
-describe VagrantPlugins::HyperV::Action::ReadState do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine, machine_state_id: state_id} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider) }
-  let(:state_id){ nil }
-
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(app).to receive(:call)
-    allow(env).to receive(:[]=)
-    allow(machine).to receive(:id)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should set machine state into the env as not created" do
-    expect(env).to receive(:[]=).with(:machine_state_id, :not_created)
-    subject.call(env)
-  end
-
-  context "with machine ID set" do
-    before{ allow(machine).to receive(:id).and_return("VMID") }
-
-    it "should request machine state from the driver" do
-      expect(driver).to receive(:get_current_state).and_return("state" => "running")
-      subject.call(env)
-    end
-
-    it "should set machine state into the env" do
-      expect(driver).to receive(:get_current_state).and_return("state" => "running")
-      expect(env).to receive(:[]=).with(:machine_state_id, :running)
-      subject.call(env)
-    end
-
-    context "with machine state ID as not_created" do
-      let(:state_id){ :not_created }
-
-      it "should clear the machine ID" do
-        expect(driver).to receive(:get_current_state).and_return("state" => "not_created")
-        expect(machine).to receive(:id=).with(nil)
-        subject.call(env)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/set_name_test.rb

@@ -1,61 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/set_name")
-
-describe VagrantPlugins::HyperV::Action::SetName do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine, root_path: Pathname.new("path")} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, provider_config: provider_config, data_dir: data_dir, name: "machname") }
-  let(:data_dir){ double("data_dir") }
-  let(:provider_config){ double("provider_config", vmname: vmname) }
-  let(:vmname){ "VMNAME" }
-  let(:sentinel){ double("sentinel") }
-
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(ui).to receive(:info)
-    allow(driver).to receive(:set_name)
-    allow(app).to receive(:call)
-    allow(data_dir).to receive(:join).and_return(sentinel)
-    allow(sentinel).to receive(:file?).and_return(false)
-    allow(sentinel).to receive(:open)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should call the driver to set the name" do
-    expect(driver).to receive(:set_name)
-    subject.call(env)
-  end
-
-  it "should use the configured name when setting" do
-    expect(driver).to receive(:set_name).with(vmname)
-    subject.call(env)
-  end
-
-  it "should write sentinel after name is set" do
-    expect(sentinel).to receive(:open)
-    subject.call(env)
-  end
-
-  context "when no name is provided in the config" do
-    let(:vmname){ nil }
-
-    it "should generate a name based on path and machine" do
-      expect(driver).to receive(:set_name).with(/^#{env[:root_path].to_s}_#{machine.name}_.+/)
-      subject.call(env)
-    end
-
-    it "should not set name if sentinel exists" do
-      expect(sentinel).to receive(:file?).and_return(true)
-      subject.call(env)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/providers/hyperv/action/wait_for_ip_address_test.rb

@@ -1,40 +0,0 @@
-require_relative "../../../../base"
-
-require Vagrant.source_root.join("plugins/providers/hyperv/action/wait_for_ip_address")
-
-describe VagrantPlugins::HyperV::Action::WaitForIPAddress do
-  let(:app){ double("app") }
-  let(:env){ {ui: ui, machine: machine} }
-  let(:ui){ double("ui") }
-  let(:provider){ double("provider", driver: driver) }
-  let(:driver){ double("driver") }
-  let(:machine){ double("machine", provider: provider, provider_config: provider_config) }
-  let(:provider_config){ double("provider_config", ip_address_timeout: ip_address_timeout) }
-  let(:ip_address_timeout){ 1 }
-
-  let(:subject){ described_class.new(app, env) }
-
-  before do
-    allow(ui).to receive(:output)
-    allow(ui).to receive(:detail)
-    allow(driver).to receive(:read_guest_ip).and_return("ip" => "127.0.0.1")
-    allow(app).to receive(:call)
-  end
-
-  it "should call the app on success" do
-    expect(app).to receive(:call)
-    subject.call(env)
-  end
-
-  it "should set a timeout for waiting" do
-    expect(Timeout).to receive(:timeout).with(ip_address_timeout)
-    subject.call(env)
-  end
-
-  it "should retry until it receives a valid address" do
-    expect(driver).to receive(:read_guest_ip).and_return("ip" => "ADDRESS")
-    expect(driver).to receive(:read_guest_ip).and_return("ip" => "127.0.0.1")
-    expect(subject).to receive(:sleep)
-    subject.call(env)
-  end
-end