vagrant-libvirt 0.8.2 → 0.10.1

data/spec/unit/action/create_domain_spec.rb

@@ -21,15 +21,9 @@ describe VagrantPlugins::ProviderLibvirt::Action::CreateDomain do
   let(:domain_volume) { instance_double(::Fog::Libvirt::Compute::Volume) }
 
   let(:domain_xml) { File.read(File.join(File.dirname(__FILE__), File.basename(__FILE__, '.rb'), domain_xml_file)) }
-  let(:storage_pool_xml) { File.read(File.join(File.dirname(__FILE__), File.basename(__FILE__, '.rb'), storage_pool_xml_file)) }
-  let(:libvirt_storage_pool) { double('storage_pool') }
 
   describe '#call' do
     before do
-      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver)
-        .to receive(:connection).and_return(connection)
-      allow(connection).to receive(:client).and_return(libvirt_client)
-
       allow(connection).to receive(:servers).and_return(servers)
       allow(connection).to receive(:volumes).and_return(volumes)
       allow(volumes).to receive(:all).and_return([domain_volume])
@@ -43,15 +37,17 @@ describe VagrantPlugins::ProviderLibvirt::Action::CreateDomain do
 
       env[:domain_name] = "vagrant-test_default"
 
-      env[:box_volumes] = []
-      env[:box_volumes].push({
+      env[:domain_volumes] = []
+      env[:domain_volumes].push({
+        :device=>'vda',
+        :bus=>'virtio',
+        :cache=>'default',
+        :absolute_path=>'/var/lib/libvirt/images/vagrant-test_default.img',
         :path=>"/test/box.img",
-        :name=>"test_vagrant_box_image_1.1.1_0.img", 
+        :name=>'test_vagrant_box_image_1.1.1_0.img',
         :virtual_size=> ByteNumber.new(5),
+        :pool=>'default',
       })
-      # should be ignored for system session and used for user session
-      allow(Process).to receive(:uid).and_return(9999)
-      allow(Process).to receive(:gid).and_return(9999)
     end
 
     context 'connection => qemu:///system' do
@@ -61,123 +57,181 @@ describe VagrantPlugins::ProviderLibvirt::Action::CreateDomain do
         allow(machine.provider_config).to receive(:qemu_use_session).and_return(false)
       end
 
-      context 'default pool' do
-        it 'should execute correctly' do
-          expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
-          expect(volumes).to_not receive(:create) # additional disks only
+      it 'should execute correctly' do
+        expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
+        expect(volumes).to_not receive(:create) # additional disks only
 
-          expect(subject.call(env)).to be_nil
+        expect(subject.call(env)).to be_nil
+      end
+
+      context 'additional disks' do
+        let(:disks) do
+          [
+            :device        => 'vdb',
+            :cache         => 'default',
+            :bus           => 'virtio',
+            :type          => 'qcow2',
+            :absolute_path => '/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2',
+            :virtual_size  => ByteNumber.new(20*1024*1024*1024),
+            :pool          => 'default',
+          ]
         end
 
-        context 'with no box' do
-          let(:storage_pool_xml_file) { 'default_system_storage_pool.xml' }
-          let(:vagrantfile) do
-            <<-EOF
-            Vagrant.configure('2') do |config|
-              config.vm.define :test
-            end
-            EOF
-          end
+        before do
+          env[:disks] = disks
+        end
 
-          it 'should query for the storage pool path' do
-            expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
-            expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
-            expect(servers).to receive(:create).and_return(machine)
+        context 'volume create failed' do
+          it 'should raise an exception' do
+            expect(volumes).to receive(:create).and_raise(Libvirt::Error)
 
-            expect(subject.call(env)).to be_nil
+            expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::FogCreateDomainVolumeError)
           end
         end
 
-        context 'additional disks' do
-          let(:vagrantfile_providerconfig) do
-            <<-EOF
-            libvirt.storage :file, :size => '20G'
-            EOF
-          end
+        context 'volume create succeeded' do
+          let(:domain_xml_file) { 'additional_disks_domain.xml' }
 
-          context 'volume create failed' do
-            it 'should raise an exception' do
-              expect(volumes).to receive(:create).and_raise(Libvirt::Error)
+          it 'should complete' do
+            expect(volumes).to receive(:create).with(
+              hash_including(
+                :path        => "/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2",
+                :owner       => 0,
+                :group       => 0,
+                :pool_name   => "default",
+              )
+            )
+            expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
 
-              expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::FogCreateDomainVolumeError)
-            end
+            expect(subject.call(env)).to be_nil
           end
+        end
+      end
 
-          context 'volume create succeeded' do
-            let(:domain_xml_file) { 'additional_disks_domain.xml' }
-
-            it 'should complete' do
-              expect(volumes).to receive(:create).with(
-                hash_including(
-                  :path        => "/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2",
-                  :owner       => 0,
-                  :group       => 0,
-                  :pool_name   => "default",
-                )
-              )
-              expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
+      context 'with custom disk device setting' do
+        let(:domain_xml_file) { 'custom_disk_settings.xml' }
 
-              expect(subject.call(env)).to be_nil
-            end
-          end
+        before do
+          env[:domain_volumes][0][:device] = 'sda'
         end
 
-        context 'with custom disk device setting' do
-          let(:domain_xml_file) { 'custom_disk_settings.xml' }
-          let(:vagrantfile_providerconfig) {
-            <<-EOF
-              libvirt.disk_device = 'sda'
-            EOF
-          }
+        it 'should set the domain device' do
+          expect(ui).to receive(:info).with(/ -- Image\(sda\):.*/)
+          expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
 
-          it 'should set the domain device' do
-            expect(ui).to receive(:info).with(/ -- Image\(sda\):.*/)
-            expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
+          expect(subject.call(env)).to be_nil
+        end
+      end
 
-            expect(subject.call(env)).to be_nil
-          end
+      context 'with two domain disks' do
+        let(:domain_xml_file) { 'two_disk_settings.xml' }
+        let(:domain_volume_2) { double('domain_volume 2') }
+
+        before do
+          expect(volumes).to receive(:all).with(name: 'vagrant-test_default.img').and_return([domain_volume])
+          expect(volumes).to receive(:all).with(name: 'vagrant-test_default_1.img').and_return([domain_volume_2])
+          expect(domain_volume_2).to receive(:pool_name).and_return('default')
+
+          env[:domain_volumes].push({
+            :device=>'vdb',
+            :bus=>'virtio',
+            :cache=>'default',
+            :absolute_path=>'/var/lib/libvirt/images/vagrant-test_default_1.img',
+            :path=>"/test/box_1.img",
+            :name=>"test_vagrant_box_image_1.1.1_1.img",
+            :virtual_size=> ByteNumber.new(5),
+            :pool=>'default',
+          })
         end
 
-        context 'with two domain disks' do
-          let(:domain_xml_file) { 'two_disk_settings.xml' }
-          let(:domain_volume_2) { double('domain_volume 2') }
+        it 'should list multiple device entries' do
+          expect(ui).to receive(:info).with(/ -- Image\(vda\):.*/)
+          expect(ui).to receive(:info).with(/ -- Image\(vdb\):.*/)
+          expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
 
-          before do
-            expect(volumes).to receive(:all).and_return([domain_volume])
-            expect(volumes).to receive(:all).and_return([domain_volume_2])
-            expect(domain_volume_2).to receive(:pool_name).and_return('default')
-            expect(domain_volume_2).to receive(:path).and_return('/var/lib/libvirt/images/vagrant-test_default_1.img')
+          expect(subject.call(env)).to be_nil
+        end
+      end
 
-            env[:box_volumes].push({
-              :path=>"/test/box_1.img",
-              :name=>"test_vagrant_box_image_1.1.1_1.img",
-              :virtual_size=> ByteNumber.new(5),
-            })
-          end
+      context 'with disk controller model virtio-scsi' do
+        before do
+          allow(machine.provider_config).to receive(:disk_controller_model).and_return('virtio-scsi')
+          expect(volumes).to receive(:all).with(name: 'vagrant-test_default.img').and_return([domain_volume])
 
-          it 'should correctly assign device entries' do
-            expect(ui).to receive(:info).with(/ -- Image\(vda\):.*/)
-            expect(ui).to receive(:info).with(/ -- Image\(vdb\):.*/)
-            expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
+          env[:domain_volumes][0][:bus] = 'scsi'
+        end
 
-            expect(subject.call(env)).to be_nil
-          end
+        it 'should add a virtio-scsi disk controller' do
+          expect(ui).to receive(:info).with(/ -- Image\(vda\):.*/)
+          expect(servers).to receive(:create) do |args|
+            expect(args[:xml]).to match(/<controller type='scsi' model='virtio-scsi' index='0'\/>/)
+          end.and_return(machine)
+
+          expect(subject.call(env)).to be_nil
         end
       end
 
-      context 'no default pool' do
-        let(:vagrantfile) do
+      context 'sysinfo' do
+        let(:domain_xml_file) { 'sysinfo.xml' }
+        let(:vagrantfile_providerconfig) do
           <<-EOF
-          Vagrant.configure('2') do |config|
-            config.vm.define :test
-          end
+          libvirt.sysinfo = {
+            'bios': {
+              'vendor': 'Test Vendor',
+              'version': '',
+            },
+            'system': {
+              'manufacturer': 'Test Manufacturer',
+              'version': '0.1.0',
+              'serial': '',
+            },
+            'base board': {
+              'manufacturer': 'Test Manufacturer',
+              'version': '',
+            },
+            'chassis': {
+              'manufacturer': 'Test Manufacturer',
+              'serial': 'AABBCCDDEE',
+              'asset': '',
+            },
+            'oem strings': [
+              'app1: string1',
+              'app1: string2',
+              'app2: string1',
+              'app2: string2',
+              '',
+              '',
+            ],
+          }
           EOF
         end
 
-        it 'should raise an exception' do
-          expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(nil)
+        it 'should populate sysinfo as expected' do
+          expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
+
+          expect(subject.call(env)).to be_nil
+        end
 
-          expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::NoStoragePool)
+        context 'with block of empty entries' do
+          let(:domain_xml_file) { 'sysinfo_only_required.xml' }
+          let(:vagrantfile_providerconfig) do
+            <<-EOF
+            libvirt.sysinfo = {
+              'bios': {
+                'vendor': 'Test Vendor',
+              },
+              'system': {
+                'serial': '',
+              },
+            }
+            EOF
+          end
+
+          it 'should skip outputting the surrounding tags' do
+            expect(servers).to receive(:create).with(xml: domain_xml).and_return(machine)
+
+            expect(subject.call(env)).to be_nil
+          end
         end
       end
     end
@@ -187,57 +241,51 @@ describe VagrantPlugins::ProviderLibvirt::Action::CreateDomain do
         allow(machine.provider_config).to receive(:qemu_use_session).and_return(true)
       end
 
-      context 'default pool' do
-        it 'should execute correctly' do
-          expect(servers).to receive(:create).and_return(machine)
+      it 'should execute correctly' do
+        expect(servers).to receive(:create).and_return(machine)
 
-          expect(subject.call(env)).to be_nil
+        expect(subject.call(env)).to be_nil
+      end
+
+      context 'additional disks' do
+        let(:vagrantfile_providerconfig) do
+          <<-EOF
+          libvirt.qemu_use_session = true
+          EOF
         end
 
-        context 'with no box' do
-          let(:storage_pool_xml_file) { 'default_user_storage_pool.xml' }
-          let(:vagrantfile) do
-            <<-EOF
-            Vagrant.configure('2') do |config|
-              config.vm.define :test
-              config.vm.provider :libvirt do |libvirt|
-                #{vagrantfile_providerconfig}
-              end
-            end
-            EOF
-          end
+        let(:disks) do
+          [
+            :device        => 'vdb',
+            :cache         => 'default',
+            :bus           => 'virtio',
+            :type          => 'qcow2',
+            :absolute_path => '/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2',
+            :virtual_size  => ByteNumber.new(20*1024*1024*1024),
+            :pool          => 'default',
+          ]
+        end
 
-          it 'should query for the storage pool path' do
-            expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
-            expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
-            expect(servers).to receive(:create).and_return(machine)
+        before do
+          expect(Process).to receive(:uid).and_return(9999).at_least(:once)
+          expect(Process).to receive(:gid).and_return(9999).at_least(:once)
 
-            expect(subject.call(env)).to be_nil
-          end
+          env[:disks] = disks
         end
 
-        context 'additional disks' do
-          let(:vagrantfile_providerconfig) do
-            <<-EOF
-            libvirt.qemu_use_session = true
-            libvirt.storage :file, :size => '20G'
-            EOF
-          end
-
-          context 'volume create succeeded' do
-            it 'should complete' do
-              expect(volumes).to receive(:create).with(
-                hash_including(
-                  :path        => "/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2",
-                  :owner       => 9999,
-                  :group       => 9999,
-                  :pool_name   => "default",
-                )
+        context 'volume create succeeded' do
+          it 'should complete' do
+            expect(volumes).to receive(:create).with(
+              hash_including(
+                :path        => "/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2",
+                :owner       => 9999,
+                :group       => 9999,
+                :pool_name   => "default",
               )
-              expect(servers).to receive(:create).and_return(machine)
+            )
+            expect(servers).to receive(:create).and_return(machine)
 
-              expect(subject.call(env)).to be_nil
-            end
+            expect(subject.call(env)).to be_nil
           end
         end
       end

data/spec/unit/action/create_domain_volume_spec.rb

@@ -26,9 +26,6 @@ describe VagrantPlugins::ProviderLibvirt::Action::CreateDomainVolume do
 
   describe '#call' do
     before do
-      allow_any_instance_of(VagrantPlugins::ProviderLibvirt::Driver)
-        .to receive(:connection).and_return(connection)
-      allow(connection).to receive(:client).and_return(libvirt_client)
       allow(connection).to receive(:volumes).and_return(volumes)
       allow(volumes).to receive(:all).and_return(all)
       allow(all).to receive(:first).and_return(box_volume)

data/spec/unit/action/destroy_domain_spec.rb

@@ -19,10 +19,14 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
 
   let(:domain_xml) { File.read(File.join(File.dirname(__FILE__), File.basename(__FILE__, '.rb'), domain_xml_file)) }
 
+  let(:destroy_method) { double('destroy_method') }
+
   before do
     allow(machine.provider).to receive('driver').and_return(driver)
     allow(driver).to receive(:connection).and_return(connection)
     allow(logger).to receive(:info)
+    allow(domain).to receive(:method).with(:destroy).and_return(destroy_method)
+    allow(destroy_method).to receive(:parameters).and_return([[:opt, :options, :flags]])
   end
 
   describe '#call' do
@@ -49,7 +53,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
 
       context 'when box only has one root disk' do
         it 'calls fog to destroy volumes' do
-          expect(domain).to receive(:destroy).with(destroy_volumes: true)
+          expect(domain).to receive(:destroy).with(destroy_volumes: true, flags: 0)
           expect(subject.call(env)).to be_nil
         end
 
@@ -69,7 +73,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
           end
 
           it 'destroys disks individually' do
-            expect(domain).to receive(:destroy).with(destroy_volumes: false)
+            expect(domain).to receive(:destroy).with(destroy_volumes: false, flags: 0)
             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
@@ -81,7 +85,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
         let(:domain_xml_file) { 'box_multiple_disks.xml' }
 
         it 'calls fog to destroy volumes' do
-          expect(domain).to receive(:destroy).with(destroy_volumes: true)
+          expect(domain).to receive(:destroy).with(destroy_volumes: true, flags: 0)
           expect(subject.call(env)).to be_nil
         end
 
@@ -111,7 +115,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
               expect(disk).to receive(:name).and_return(name).at_least(:once)
               expect(disk).to receive(:destroy)
             end
-            expect(domain).to receive(:destroy).with(destroy_volumes: false)
+            expect(domain).to receive(:destroy).with(destroy_volumes: false, flags: 0)
             expect(subject.call(env)).to be_nil
           end
 
@@ -133,7 +137,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
                 next if disk == domain_disks.last.first
                 expect(disk).to receive(:destroy)
               end
-              expect(domain).to receive(:destroy).with(destroy_volumes: false)
+              expect(domain).to receive(:destroy).with(destroy_volumes: false, flags: 0)
               expect(subject.call(env)).to be_nil
             end
 
@@ -141,7 +145,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
               let(:domain_xml_file) { 'box_multiple_disks_and_additional_and_custom_disks_no_aliases.xml' }
 
               it 'only destroys expected disks' do
-                expect(ui).to receive(:warn).with(/Destroying machine that was originally created without device aliases.*/)
+                expect(ui).to receive(:warn).with(/Machine that was originally created without device aliases.*/)
                 expect(ui).to receive(:warn).with(/Unexpected number of volumes detected/)
                 expect(ui).to receive(:warn).with(/box metadata not available to get volume list during destroy, assuming inferred list/)
                 domain_disks.each do |disk, name|
@@ -150,7 +154,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
                   next if domain_disks.last.first == disk
                   expect(disk).to receive(:destroy)
                 end
-                expect(domain).to receive(:destroy).with(destroy_volumes: false)
+                expect(domain).to receive(:destroy).with(destroy_volumes: false, flags: 0)
                 expect(subject.call(env)).to be_nil
               end
 
@@ -168,7 +172,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
                 end
 
                 it 'only destroys expected disks' do
-                  expect(ui).to receive(:warn).with(/Destroying machine that was originally created without device aliases.*/)
+                  expect(ui).to receive(:warn).with(/Machine that was originally created without device aliases.*/)
                   expect(ui).to receive(:warn).with(/Unexpected number of volumes detected/)
                   domain_disks.each do |disk, name|
                     expect(disk).to receive(:name).and_return(name).at_least(:once)
@@ -176,7 +180,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
                     next if domain_disks.last.first == disk
                     expect(disk).to receive(:destroy)
                   end
-                  expect(domain).to receive(:destroy).with(destroy_volumes: false)
+                  expect(domain).to receive(:destroy).with(destroy_volumes: false, flags: 0)
                   expect(subject.call(env)).to be_nil
                 end
               end
@@ -185,6 +189,35 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
         end
       end
 
+      context 'when has nvram' do
+        let(:vagrantfile) do
+          <<-EOF
+          Vagrant.configure('2') do |config|
+            config.vm.define :test
+            config.vm.provider :libvirt do |libvirt|
+              libvirt.nvram = "test"
+            end
+          end
+          EOF
+        end
+
+        it 'sets destroy flags to keep nvram' do
+          expect(domain).to receive(:destroy).with(destroy_volumes: true, flags: VagrantPlugins::ProviderLibvirt::Util::DomainFlags::VIR_DOMAIN_UNDEFINE_KEEP_NVRAM)
+          expect(subject.call(env)).to be_nil
+        end
+
+        context 'when fog does not support destroy with flags' do
+          before do
+            expect(destroy_method).to receive(:parameters).and_return([[:opt, :options]])
+          end
+
+          it 'skips setting additional destroy flags' do
+            expect(domain).to receive(:destroy).with(destroy_volumes: true)
+            expect(subject.call(env)).to be_nil
+          end
+        end
+      end
+
       context 'when has CDROMs attached' do
         let(:vagrantfile_providerconfig) do
           <<-EOF
@@ -197,7 +230,7 @@ describe VagrantPlugins::ProviderLibvirt::Action::DestroyDomain do
           expect(domain).to receive(:volumes).and_return([root_disk, nil])
           expect(libvirt_domain).to receive(:xml_desc).and_return(domain_xml)
 
-          expect(domain).to_not receive(:destroy).with(destroy_volumes: true)
+          expect(domain).to_not receive(:destroy).with(destroy_volumes: true, flags: 0)
           expect(root_disk).to receive(:destroy)  # root disk remove
           expect(subject.call(env)).to be_nil
         end

data/spec/unit/action/forward_ports_spec.rb

@@ -195,7 +195,6 @@ describe VagrantPlugins::ProviderLibvirt::Action::ClearForwardedPorts do
         end
       end
       it 'should terminate each of the processes' do
-        expect(logger).to receive(:info).with(no_args) # don't know how to test translations from vagrant
         expect(subject).to receive(:ssh_pid?).with("10001").and_return(true)
         expect(subject).to receive(:ssh_pid?).with("10002").and_return(true)
         expect(logger).to receive(:debug).with(/Killing pid/).twice()