vagrant-libvirt 0.0.36 → 0.0.37

data/spec/unit/action/destroy_domain_spec.rb

@@ -1,51 +1,51 @@
-require "spec_helper"
-require "support/sharedcontext"
-require "support/libvirt_context"
+require 'spec_helper'
+require 'support/sharedcontext'
+require 'support/libvirt_context'
 
-require "vagrant-libvirt/action/destroy_domain"
+require 'vagrant-libvirt/action/destroy_domain'
 
 describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
-
   subject { described_class.new(app, env) }
 
-  include_context "unit"
-  include_context "libvirt"
+  include_context 'unit'
+  include_context 'libvirt'
 
-  let(:libvirt_domain) { double("libvirt_domain") }
-  let(:libvirt_client) { double("libvirt_client") }
-  let(:servers) { double("servers") }
+  let(:libvirt_domain) { double('libvirt_domain') }
+  let(:libvirt_client) { double('libvirt_client') }
+  let(:servers) { double('servers') }
 
-  describe "#call" do
+  describe '#call' do
     before do
-      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).
-        to receive(:connection).and_return(connection)
+      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver)
+        .to receive(:connection).and_return(connection)
       allow(connection).to receive(:client).and_return(libvirt_client)
-      allow(libvirt_client).to receive(:lookup_domain_by_uuid).
-        and_return(libvirt_domain)
+      allow(libvirt_client).to receive(:lookup_domain_by_uuid)
+        .and_return(libvirt_domain)
       allow(connection).to receive(:servers).and_return(servers)
       allow(servers).to receive(:get).and_return(domain)
       # always see this at the start of #call
-      expect(ui).to receive(:info).with("Removing domain...")
+      expect(ui).to receive(:info).with('Removing domain...')
     end
 
-    context "when no snapshots" do
-      let(:root_disk) { double("libvirt_root_disk") }
+    context 'when no snapshots' do
+      let(:root_disk) { double('libvirt_root_disk') }
 
       before do
         allow(libvirt_domain).to receive(:list_snapshots).and_return([])
         allow(libvirt_domain).to receive(:has_managed_save?).and_return(nil)
-        root_disk.stub(:name => "test.img")
+        root_disk.stub(name: 'test.img')
       end
 
-      context "when only has root disk" do
-        it "calls fog to destroy volumes" do
-          expect(domain).to receive(:destroy).with(:destroy_volumes => true)
+      context 'when only has root disk' do
+        it 'calls fog to destroy volumes' do
+          expect(domain).to receive(:destroy).with(destroy_volumes: true)
           expect(subject.call(env)).to be_nil
         end
       end
 
-      context "when has additional disks" do
-        let(:vagrantfile) { <<-EOF
+      context 'when has additional disks' do
+        let(:vagrantfile) do
+          <<-EOF
           Vagrant.configure('2') do |config|
             config.vm.define :test
             config.vm.provider :libvirt do |libvirt|
@@ -53,26 +53,27 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
             end
           end
           EOF
-        }
+        end
 
-        let(:extra_disk) { double("libvirt_extra_disk") }
+        let(:extra_disk) { double('libvirt_extra_disk') }
         before do
-          extra_disk.stub(:name => "test-vdb.qcow2")
+          extra_disk.stub(name: 'test-vdb.qcow2')
         end
 
-        it "destroys disks individually" do
-          allow(libvirt_domain).to receive(:name).and_return("test")
+        it 'destroys disks individually' do
+          allow(libvirt_domain).to receive(:name).and_return('test')
           allow(domain).to receive(:volumes).and_return([extra_disk], [root_disk])
 
-          expect(domain).to receive(:destroy).with(:destroy_volumes => false)
-          expect(extra_disk).to receive(:destroy)  # extra disk remove
+          expect(domain).to receive(:destroy).with(destroy_volumes: false)
+          expect(extra_disk).to receive(:destroy) # extra disk remove
           expect(root_disk).to receive(:destroy)  # root disk remove
           expect(subject.call(env)).to be_nil
         end
       end
 
-      context "when has CDROMs attached" do
-        let(:vagrantfile) { <<-EOF
+      context 'when has CDROMs attached' do
+        let(:vagrantfile) do
+          <<-EOF
           Vagrant.configure('2') do |config|
             config.vm.define :test
             config.vm.provider :libvirt do |libvirt|
@@ -80,13 +81,13 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
             end
           end
           EOF
-        }
+        end
 
-        it "uses explicit removal of disks" do
-          allow(libvirt_domain).to receive(:name).and_return("test")
+        it 'uses explicit removal of disks' do
+          allow(libvirt_domain).to receive(:name).and_return('test')
           allow(domain).to receive(:volumes).and_return([root_disk])
 
-          expect(domain).to_not receive(:destroy).with(:destroy_volumes => true)
+          expect(domain).to_not receive(:destroy).with(destroy_volumes: true)
           expect(root_disk).to receive(:destroy)  # root disk remove
           expect(subject.call(env)).to be_nil
         end

data/spec/unit/action/set_name_of_domain_spec.rb

@@ -1,11 +1,11 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe VagrantPlugins::ProviderLibvirt::Action::SetNameOfDomain do
   before :each do
     @env = EnvironmentHelper.new
   end
 
-  it "builds unique domain name" do
+  it 'builds unique domain name' do
     @env.random_hostname = true
     dmn = VagrantPlugins::ProviderLibvirt::Action::SetNameOfDomain.new(Object.new, @env)
     first  = dmn.build_domain_name(@env)
@@ -13,8 +13,8 @@ describe VagrantPlugins::ProviderLibvirt::Action::SetNameOfDomain do
     first.should_not eq(second)
   end
 
-  it "builds simple domain name" do
-    @env.default_prefix= 'pre'
+  it 'builds simple domain name' do
+    @env.default_prefix = 'pre'
     dmn = VagrantPlugins::ProviderLibvirt::Action::SetNameOfDomain.new(Object.new, @env)
     dmn.build_domain_name(@env).should eq('pre_')
   end

data/spec/unit/action/wait_till_up_spec.rb

@@ -1,65 +1,64 @@
-require "vagrant-libvirt/action/wait_till_up"
-require "vagrant-libvirt/errors"
+require 'vagrant-libvirt/action/wait_till_up'
+require 'vagrant-libvirt/errors'
 
-require "spec_helper"
-require "support/sharedcontext"
-require "support/libvirt_context"
+require 'spec_helper'
+require 'support/sharedcontext'
+require 'support/libvirt_context'
 
 describe VagrantPlugins::ProviderLibvirt::Action::WaitTillUp do
-
   subject { described_class.new(app, env) }
 
-  include_context "vagrant-unit"
-  include_context "libvirt"
-  include_context "unit"
+  include_context 'vagrant-unit'
+  include_context 'libvirt'
+  include_context 'unit'
 
-  describe "#call" do
+  describe '#call' do
     before do
-      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).
-        to receive(:get_domain).and_return(domain)
-      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).to receive(:state).
-        and_return(:running)
+      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver)
+        .to receive(:get_domain).and_return(domain)
+      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).to receive(:state)
+        .and_return(:running)
     end
 
-    context "when machine does not exist" do
+    context 'when machine does not exist' do
       before do
-        allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).
-          to receive(:get_domain).and_return(nil)
+        allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver)
+          .to receive(:get_domain).and_return(nil)
       end
 
-      it "raises exception" do
+      it 'raises exception' do
         expect(app).to_not receive(:call)
-        expect{subject.call(env)}.to raise_error(::VagrantPlugins::ProviderLibvirt::Errors::NoDomainError,
-                                                 /No domain found. Domain dummy-vagrant_dummy not found/)
+        expect { subject.call(env) }.to raise_error(::VagrantPlugins::ProviderLibvirt::Errors::NoDomainError,
+                                                    /No domain found. Domain dummy-vagrant_dummy not found/)
       end
     end
 
-    context "when machine is booting" do
-      context "if interrupted looking for IP" do
+    context 'when machine is booting' do
+      context 'if interrupted looking for IP' do
         before do
           env[:interrupted] = true
         end
-        it "should exit" do
+        it 'should exit' do
           expect(app).to_not receive(:call)
-          expect(ui).to receive(:info).with("Waiting for domain to get an IP address...")
+          expect(ui).to receive(:info).with('Waiting for domain to get an IP address...')
           expect(subject.call(env)).to be_nil
         end
       end
 
-      context "if interrupted waiting for SSH" do
+      context 'if interrupted waiting for SSH' do
         before do
           allow(domain).to receive(:wait_for).and_return(true)
           allow(env).to receive(:[]).and_call_original
           allow(env).to receive(:[]).with(:interrupted).and_return(false, true, true)
-          allow(env).to receive(:[]).with(:ip_address).and_return("192.168.121.2")
+          allow(env).to receive(:[]).with(:ip_address).and_return('192.168.121.2')
         end
-        it "should exit after getting IP" do
+        it 'should exit after getting IP' do
           expect(app).to_not receive(:call)
-          expect(ui).to receive(:info).with("Waiting for domain to get an IP address...")
-          expect(ui).to receive(:info).with("Waiting for SSH to become available...")
+          expect(ui).to receive(:info).with('Waiting for domain to get an IP address...')
+          expect(ui).to receive(:info).with('Waiting for SSH to become available...')
           logger = subject.instance_variable_get(:@logger)
           expect(logger).to receive(:debug).with(/Searching for IP for MAC address: .*/)
-          expect(logger).to receive(:info).with("Got IP address 192.168.121.2")
+          expect(logger).to receive(:info).with('Got IP address 192.168.121.2')
           expect(logger).to receive(:info).with(/Time for getting IP: .*/)
           expect(env[:machine].communicate).to_not receive(:ready?)
           expect(subject.call(env)).to be_nil
@@ -67,57 +66,57 @@ describe VagrantPlugins::ProviderLibvirt::Action::WaitTillUp do
       end
     end
 
-    context "when machine boots and ssh available" do
+    context 'when machine boots and ssh available' do
       before do
         allow(domain).to receive(:wait_for).and_return(true)
         allow(env).to receive(:[]).and_call_original
         allow(env).to receive(:[]).with(:interrupted).and_return(false)
-        allow(env).to receive(:[]).with(:ip_address).and_return("192.168.121.2")
+        allow(env).to receive(:[]).with(:ip_address).and_return('192.168.121.2')
       end
-      it "should call the next hook" do
+      it 'should call the next hook' do
         expect(app).to receive(:call)
-        expect(ui).to receive(:info).with("Waiting for domain to get an IP address...")
-        expect(ui).to receive(:info).with("Waiting for SSH to become available...")
+        expect(ui).to receive(:info).with('Waiting for domain to get an IP address...')
+        expect(ui).to receive(:info).with('Waiting for SSH to become available...')
         expect(env[:machine].communicate).to receive(:ready?).and_return(true)
         expect(subject.call(env)).to be_nil
       end
     end
   end
 
-  describe "#recover" do
+  describe '#recover' do
     before do
       allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).to receive(:get_domain).and_return(machine)
-      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).to receive(:state).
-        and_return(:not_created)
+      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).to receive(:state)
+        .and_return(:not_created)
       allow(env).to receive(:[]).and_call_original
     end
 
-    it "should do nothing by default" do
+    it 'should do nothing by default' do
       expect(env).to_not receive(:[]).with(:action_runner) # cleanup
       expect(subject.recover(env)).to be_nil
     end
 
-    context "with machine coming up" do
+    context 'with machine coming up' do
       before do
-        allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).to receive(:state).
-          and_return(:running)
+        allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver).to receive(:state)
+          .and_return(:running)
         env[:destroy_on_error] = true
       end
 
-      context "and user has disabled destroy on failure" do
+      context 'and user has disabled destroy on failure' do
         before do
           env[:destroy_on_error] = false
         end
 
-        it "skips terminate on failure" do
+        it 'skips terminate on failure' do
           expect(env).to_not receive(:[]).with(:action_runner) # cleanup
           expect(subject.recover(env)).to be_nil
         end
       end
 
-      context "and using default settings" do
+      context 'and using default settings' do
         let(:runner) { double('runner') }
-        it "deletes VM on failure" do
+        it 'deletes VM on failure' do
           expect(env).to receive(:[]).with(:action_runner).and_return(runner) # cleanup
           expect(runner).to receive(:run)
           expect(subject.recover(env)).to be_nil

data/spec/unit/config_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'support/sharedcontext'
+
+require 'vagrant-libvirt/config'
+
+describe VagrantPlugins::ProviderLibvirt::Config do
+  include_context 'unit'
+
+  def assert_invalid
+    errors = subject.validate(machine)
+    raise "No errors: #{errors.inspect}" if errors.values.any? { |v| !v.empty? }
+  end
+
+  def assert_valid
+    errors = subject.validate(machine)
+    raise "Errors: #{errors.inspect}" unless errors.values.all?(&:empty?)
+  end
+
+  describe '#validate' do
+    it 'is valid with defaults' do
+      assert_valid
+    end
+
+    it 'is valid if relative path used for disk' do
+      subject.storage :file, path: '../path/to/file.qcow2'
+      assert_valid
+    end
+
+    it 'should be invalid if absolute path used for disk' do
+      subject.storage :file, path: '/absolute/path/to/file.qcow2'
+      assert_invalid
+    end
+
+    context 'with mac defined' do
+      let (:vm) { double('vm') }
+      let (:networks) { double('networks') }
+      before do
+        allow(vm).to receive(:networks).and_return(networks)
+        allow(machine.config).to receive(:vm).and_return(vm)
+      end
+
+      it 'is valid with valid mac' do
+        allow(networks).to receive(:each).and_return([:public, { mac: 'aa:bb:cc:dd:ee:ff' }])
+        assert_valid
+      end
+
+      it 'should be invalid if MAC not formatted correctly' do
+        allow(networks).to receive(:each).and_return([:public, { mac: 'aabbccddeeff' }])
+        assert_invalid
+      end
+    end
+  end
+
+  describe '#merge' do
+    let(:one) { described_class.new }
+    let(:two) { described_class.new }
+
+    subject { one.merge(two) }
+
+    context 'storage' do
+      context 'with disks' do
+        context 'assigned specific devices' do
+          it 'should merge disks with specific devices' do
+            one.storage(:file, device: 'vdb')
+            two.storage(:file, device: 'vdc')
+            subject.finalize!
+            expect(subject.disks).to include(include(device: 'vdb'),
+                                             include(device: 'vdc'))
+          end
+        end
+
+        context 'without devices given' do
+          it 'should merge disks with different devices assigned automatically' do
+            one.storage(:file)
+            two.storage(:file)
+            subject.finalize!
+            expect(subject.disks).to include(include(device: 'vdb'),
+                                             include(device: 'vdc'))
+          end
+        end
+      end
+
+      context 'with cdroms only' do
+        context 'assigned specific devs' do
+          it 'should merge disks with specific devices' do
+            one.storage(:file, device: :cdrom, dev: 'hda')
+            two.storage(:file, device: :cdrom, dev: 'hdb')
+            subject.finalize!
+            expect(subject.cdroms).to include(include(dev: 'hda'),
+                                              include(dev: 'hdb'))
+          end
+        end
+
+        context 'without devs given' do
+          it 'should merge cdroms with different devs assigned automatically' do
+            one.storage(:file, device: :cdrom)
+            two.storage(:file, device: :cdrom)
+            subject.finalize!
+            expect(subject.cdroms).to include(include(dev: 'hda'),
+                                              include(dev: 'hdb'))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/templates/domain_all_settings.xml

@@ -0,0 +1,125 @@
+<domain type='kvm'>
+  <name></name>
+  <uuid></uuid>
+  <memory></memory>
+  <vcpu>1</vcpu>
+
+
+  <cpu mode='custom'>
+      <model fallback='allow'>qemu64</model>
+        <feature name='AAA' policy='required'/>
+  </cpu>
+
+
+  <os>
+        <type arch='x86_64' machine='pc-compatible'>hvm</type>
+      <loader readonly='yes' type='rom'>/efi/loader</loader>
+      <bootmenu enable='yes'/>
+    <kernel></kernel>
+    <initrd></initrd>
+    <cmdline></cmdline>
+  </os>
+  <features>
+    <acpi/>
+    <apic/>
+    <pae/>
+  </features>
+  <clock offset='utc'/>
+  <devices>
+    <emulator>/usr/bin/kvm-spice</emulator>
+    <disk type='file' device='disk'>
+      <driver name='qemu' type='qcow2' cache='unsafe'/>
+      <source file='/var/lib/libvirt/images/test.qcow2'/>
+      <target dev='vda' bus='ide'/>
+    </disk>
+    <disk type='file' device='disk'>
+      <driver name='qemu' type='qcow2' cache='default'/>
+      <source file='/var/lib/libvirt/images/test-disk1.qcow2'/>
+      <target dev='vdb' bus='virtio'/>
+    </disk>
+    <disk type='file' device='disk'>
+      <driver name='qemu' type='qcow2' cache='default'/>
+      <source file='/var/lib/libvirt/images/test-disk2.qcow2'/>
+      <target dev='vdc' bus='virtio'/>
+    </disk>
+
+    <disk type='file' device='cdrom'>
+      <source file=''/>
+      <target dev='hda' bus='ide'/>
+      <readonly/>
+    </disk>
+    <disk type='file' device='cdrom'>
+      <source file=''/>
+      <target dev='hdb' bus='ide'/>
+      <readonly/>
+    </disk>
+
+    <serial type='pty'>
+      <target port='0'/>
+    </serial>
+    <console type='pty'>
+      <target port='0'/>
+    </console>
+
+  <channel type='unix' >
+      <source mode=''
+      />
+      <target type='virtio'
+               name="org.qemu.guest_agent.0"
+      />
+  </channel>
+  <channel type='unix' >
+      <source mode=''
+               path="/tmp/foo"
+      />
+      <target type='guestfwd'
+               address="192.0.2.42"
+               port="4242"
+      />
+  </channel>
+
+    <input type='mouse' bus='ps2'/>
+
+      <graphics type='vnc' port='5900' autoport='yes' listen='127.0.0.1' keymap='en-us'  />
+      <video>
+        <model type='cirrus' vram='9216' heads='1'/>
+      </video>
+      <rng model='virtio'>
+        <backend model='random'>/dev/random</backend>
+      </rng>
+      <hostdev mode='subsystem' type='pci' managed='yes'>
+        <source>
+          <address domain='0x0000'
+            bus='0x06'
+            slot='0x12'
+            function='0x5'/>
+        </source>
+      </hostdev>
+      <hostdev mode='subsystem' type='pci' managed='yes'>
+        <source>
+          <address domain='0x0000'
+            bus='0x03'
+            slot='0x00'
+            function='0x0'/>
+        </source>
+      </hostdev>
+      <hostdev mode='subsystem' type='usb'>
+        <source startupPolicy='mandatory'>
+          <vendor id='0x1234'/>
+          <product id='0xabcd'/>
+          <address bus='1' device='2'/>
+        </source>
+      </hostdev>
+        <redirdev bus='usb' type='tcp'>
+        </redirdev>
+        <redirfilter>
+          <usbdev class='0x0b' vendor='0x0b' product='0x0b' version='0x0b' allow='yes'/>
+        </redirfilter>
+
+    <tpm model='tpm-tis'>
+      <backend type='passthrough'>
+        <device path='/dev/tpm0'/>
+      </backend>
+    </tpm>
+  </devices>
+</domain>

data/spec/unit/templates/domain_defaults.xml

@@ -0,0 +1,44 @@
+<domain type=''>
+  <name></name>
+  <uuid></uuid>
+  <memory></memory>
+  <vcpu>1</vcpu>
+
+
+  <cpu mode='host-model'>
+      <model fallback='allow'></model>
+  </cpu>
+
+
+  <os>
+        <type>hvm</type>
+    <kernel></kernel>
+    <initrd></initrd>
+    <cmdline></cmdline>
+  </os>
+  <features>
+    <acpi/>
+    <apic/>
+    <pae/>
+  </features>
+  <clock offset='utc'/>
+  <devices>
+
+
+    <serial type='pty'>
+      <target port='0'/>
+    </serial>
+    <console type='pty'>
+      <target port='0'/>
+    </console>
+
+
+    <input type='mouse' bus='ps2'/>
+
+      <graphics type='vnc' port='5900' autoport='yes' listen='127.0.0.1' keymap='en-us'  />
+      <video>
+        <model type='cirrus' vram='9216' heads='1'/>
+      </video>
+
+  </devices>
+</domain>

data/spec/unit/templates/domain_spec.rb

@@ -0,0 +1,69 @@
+require 'support/sharedcontext'
+
+require 'vagrant-libvirt/config'
+require 'vagrant-libvirt/util/erb_template'
+
+describe 'templates/domain' do
+  include_context 'unit'
+
+  class DomainTemplateHelper < VagrantPlugins::ProviderLibvirt::Config
+    include VagrantPlugins::ProviderLibvirt::Util::ErbTemplate
+  end
+
+  let(:domain) { DomainTemplateHelper.new }
+  let(:xml_expected) { File.read(File.join(File.dirname(__FILE__), test_file)) }
+
+  context 'when only defaults used' do
+    let(:test_file) { 'domain_defaults.xml' }
+    it 'renders template' do
+      domain.finalize!
+      expect(domain.to_xml('domain')).to eq xml_expected
+    end
+  end
+
+  context 'when all settings enabled' do
+    before do
+      domain.instance_variable_set('@domain_type', 'kvm')
+      domain.cpu_mode = 'custom'
+      domain.cpu_feature(name: 'AAA', policy: 'required')
+      domain.machine_type = 'pc-compatible'
+      domain.machine_arch = 'x86_64'
+      domain.loader = '/efi/loader'
+      domain.boot('network')
+      domain.boot('cdrom')
+      domain.boot('hd')
+      domain.emulator_path = '/usr/bin/kvm-spice'
+      domain.instance_variable_set('@domain_volume_path', '/var/lib/libvirt/images/test.qcow2')
+      domain.instance_variable_set('@domain_volume_cache', 'unsafe')
+      domain.disk_bus = 'ide'
+      domain.storage(:file, path: 'test-disk1.qcow2')
+      domain.storage(:file, path: 'test-disk2.qcow2')
+      domain.disks.each do |disk|
+        disk[:absolute_path] = '/var/lib/libvirt/images/' + disk[:path]
+      end
+      domain.storage(:file, device: :cdrom)
+      domain.storage(:file, device: :cdrom)
+      domain.channel(type: 'unix',
+                     target_name: 'org.qemu.guest_agent.0',
+                     target_type: 'virtio')
+      domain.channel(type: 'unix',
+                     target_type: 'guestfwd',
+                     target_address: '192.0.2.42',
+                     target_port: '4242',
+                     source_path: '/tmp/foo')
+      domain.random(model: 'random')
+      domain.pci(bus: '0x06', slot: '0x12', function: '0x5')
+      domain.pci(bus: '0x03', slot: '0x00', function: '0x0')
+      domain.usb(bus: '1', device: '2', vendor: '0x1234', product: '0xabcd')
+      domain.redirdev(type: 'tcp', host: 'localhost', port: '4000')
+      domain.redirfilter(class: '0x0b', vendor: '0x08e6',
+                         product: '0x3437', version: '2.00', allow: 'yes')
+      domain.tpm_path = '/dev/tpm0'
+    end
+    let(:test_file) { 'domain_all_settings.xml' }
+    it 'renders template' do
+      domain.finalize!
+      expect(domain.to_xml('domain')).to eq xml_expected
+    end
+  end
+end