vagrant-libvirt 0.3.0 → 0.4.0

data/spec/unit/config_spec.rb

@@ -1,3 +1,5 @@
+require 'contextual_proc'
+
 require 'spec_helper'
 require 'support/sharedcontext'
 
@@ -8,6 +10,50 @@ describe VagrantPlugins::ProviderLibvirt::Config do
 
   let(:fake_env) { Hash.new }
 
+  describe '#clock_timer' do
+    it 'should handle all options' do
+      expect(
+        subject.clock_timer(
+          :name => 'rtc',
+          :track => 'wall',
+          :tickpolicy => 'delay',
+          :present => 'yes',
+        ).length
+      ).to be(1)
+      expect(
+        subject.clock_timer(
+          :name => 'tsc',
+          :tickpolicy => 'delay',
+          :frequency => '100',
+          :mode => 'auto',
+          :present => 'yes',
+        ).length
+      ).to be(2)
+    end
+
+    it 'should correctly save the options' do
+      opts = {:name => 'rtc', :track => 'wall'}
+      expect(subject.clock_timer(opts).length).to be(1)
+
+      expect(subject.clock_timers[0]).to eq(opts)
+
+      opts[:name] = 'tsc'
+      expect(subject.clock_timers[0]).to_not eq(opts)
+    end
+
+    it 'should error name option is missing' do
+      expect{ subject.clock_timer(:track => "wall") }.to raise_error("Clock timer name must be specified")
+    end
+
+    it 'should error if nil value for option supplied' do
+      expect{ subject.clock_timer(:name => "rtc", :track => nil) }.to raise_error("Value of timer option track is nil")
+    end
+
+    it 'should error if unrecognized option specified' do
+      expect{ subject.clock_timer(:name => "tsc", :badopt => "value") }.to raise_error("Unknown clock timer option: badopt")
+    end
+  end
+
   describe '#finalize!' do
     it 'is valid with defaults' do
       subject.finalize!
@@ -16,96 +62,264 @@ describe VagrantPlugins::ProviderLibvirt::Config do
     context '@uri' do
       before(:example) do
         stub_const("ENV", fake_env)
+        fake_env['HOME'] = "/home/tests"
       end
 
-      context 'when LIBVIRT_DEFAULT_URI is defined' do
-        it 'should always use this value' do
-          fake_env['LIBVIRT_DEFAULT_URI'] = "custom:///custom_path"
+      # table describing expected behaviour of inputs that affect the resulting uri as
+      # well as any subsequent settings that might be inferred if the uri was
+      # explicitly set.
+      [
+        # settings
+        [ # all default
+          {},
+          {:uri => "qemu:///system"},
+        ],
+
+        # explicit uri settings
+        [ # transport and hostname
+          {:uri => "qemu+ssh://localhost/system"},
+          {:uri => "qemu+ssh://localhost/system", :connect_via_ssh => true, :host => "localhost", :username => nil},
+        ],
+        [ # tcp transport with port
+          {:uri => "qemu+tcp://localhost:5000/system"},
+          {:uri => "qemu+tcp://localhost:5000/system", :connect_via_ssh => false, :host => "localhost", :username => nil},
+        ],
+        [ # connect explicit to unix socket
+          {:uri => "qemu+unix:///system"},
+          {:uri => "qemu+unix:///system", :connect_via_ssh => false, :host => nil, :username => nil},
+        ],
+        [ # via libssh2 should enable ssh as well
+          {:uri => "qemu+libssh2://user@remote/system?known_hosts=/home/user/.ssh/known_hosts"},
+          {
+            :uri => "qemu+libssh2://user@remote/system?known_hosts=/home/user/.ssh/known_hosts",
+            :connect_via_ssh => true, :host => "remote", :username => "user",
+          },
+        ],
+        [ # xen
+          {:uri => "xen://remote/system?no_verify=1"},
+          {
+            :uri => "xen://remote/system?no_verify=1",
+            :connect_via_ssh => false, :host => "remote", :username => nil,
+            :id_ssh_key_file => nil,
+          },
+          {
+            :setup => ContextualProc.new {
+              expect(File).to_not receive(:file?)
+            }
+          }
+        ],
+        [ # xen
+          {:uri => "xen+ssh://remote/system?no_verify=1"},
+          {
+            :uri => "xen+ssh://remote/system?no_verify=1",
+            :connect_via_ssh => true, :host => "remote", :username => nil,
+            :id_ssh_key_file => "/home/tests/.ssh/id_rsa",
+          },
+          {
+            :setup => ContextualProc.new {
+              expect(File).to receive(:file?).with("/home/tests/.ssh/id_rsa").and_return(true)
+            }
+          }
+        ],
+
+        # with LIBVIRT_DEFAULT_URI
+        [ # all other set to default
+          {},
+          {:uri => "custom:///custom_path", :qemu_use_session => false},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => "custom:///custom_path"},
+          }
+        ],
+        [ # with session
+          {},
+          {:uri => "qemu:///session", :qemu_use_session => true},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => "qemu:///session"},
+          }
+        ],
+        [ # with session and using ssh infer connect by ssh and ignore host as not provided
+          {},
+          {:uri => "qemu+ssh:///session", :qemu_use_session => true, :connect_via_ssh => true, :host => nil},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => "qemu+ssh:///session"},
+          }
+        ],
+        [ # with session and using ssh to specific host with additional query options provided, infer host and ssh
+          {},
+          {:uri => "qemu+ssh://remote/session?keyfile=my_id_rsa", :qemu_use_session => true, :connect_via_ssh => true, :host => 'remote'},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => "qemu+ssh://remote/session?keyfile=my_id_rsa"},
+          }
+        ],
+        [ # when session not set
+          {},
+          {:uri => "qemu:///system", :qemu_use_session => false},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => "qemu:///system"},
+          }
+        ],
+        [ # when session appearing elsewhere
+          {},
+          {:uri => "qemu://remote/system?keyfile=my_session_id", :qemu_use_session => false},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => "qemu://remote/system?keyfile=my_session_id"},
+          }
+        ],
+
+        # ignore LIBVIRT_DEFAULT_URI due to explicit settings
+        [ # when uri explicitly set
+          {:uri => 'qemu:///system'},
+          {:uri => 'qemu:///system'},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => 'qemu://session'},
+          }
+        ],
+        [ # when host explicitly set
+          {:host => 'remote'},
+          {:uri => 'qemu://remote/system'},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => 'qemu://session'},
+          }
+        ],
+        [ # when connect_via_ssh explicitly set
+          {:connect_via_ssh => true},
+          {:uri => 'qemu+ssh://localhost/system?no_verify=1'},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => 'qemu://session'},
+          }
+        ],
+        [ # when username explicitly set without ssh
+          {:username => 'my_user' },
+          {:uri => 'qemu:///system'},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => 'qemu://session'},
+          }
+        ],
+        [ # when username explicitly set with host but without ssh
+          {:username => 'my_user', :host => 'remote'},
+          {:uri => 'qemu://remote/system'},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => 'qemu://session'},
+          }
+        ],
+        [ # when password explicitly set
+          {:password => 'some_password'},
+          {:uri => 'qemu:///system', :password => 'some_password'},
+          {
+            :env => {'LIBVIRT_DEFAULT_URI' => 'qemu://session'},
+          }
+        ],
+
+        # driver settings
+        [ # set to kvm only
+          {:driver => 'kvm'},
+          {:uri => "qemu:///system"},
+        ],
+        [ # set to qemu only
+          {:driver => 'qemu'},
+          {:uri => "qemu:///system"},
+        ],
+        [ # set to qemu with session enabled
+          {:driver => 'qemu', :qemu_use_session => true},
+          {:uri => "qemu:///session"},
+        ],
+        [ # set to openvz only
+          {:driver => 'openvz'},
+          {:uri => "openvz:///system"},
+        ],
+        [ # set to esx
+          {:driver => 'esx'},
+          {:uri => "esx:///"},
+        ],
+        [ # set to vbox only
+          {:driver => 'vbox'},
+          {:uri => "vbox:///session"},
+        ],
+
+        # connect_via_ssh settings
+        [ # enabled
+          {:connect_via_ssh => true},
+          {:uri => "qemu+ssh://localhost/system?no_verify=1"},
+        ],
+        [ # enabled with user
+          {:connect_via_ssh => true, :username => 'my_user'},
+          {:uri => "qemu+ssh://my_user@localhost/system?no_verify=1"},
+        ],
+        [ # enabled with host
+          {:connect_via_ssh => true, :host => 'remote_server'},
+          {:uri => "qemu+ssh://remote_server/system?no_verify=1"},
+        ],
+
+        # id_ssh_key_file behaviour
+        [ # set should take given value
+          {:connect_via_ssh => true, :id_ssh_key_file => '/path/to/keyfile'},
+          {:uri => 'qemu+ssh://localhost/system?no_verify=1&keyfile=/path/to/keyfile', :connect_via_ssh => true},
+        ],
+        [ # set should infer use of ssh
+          {:id_ssh_key_file => '/path/to/keyfile'},
+          {:uri => 'qemu+ssh://localhost/system?no_verify=1&keyfile=/path/to/keyfile', :connect_via_ssh => true},
+        ],
+        [ # connect_via_ssh should enable default but ignore due to not existing
+          {:connect_via_ssh => true},
+          {:uri => 'qemu+ssh://localhost/system?no_verify=1', :id_ssh_key_file => nil},
+          {
+            :setup => ContextualProc.new {
+              expect(File).to receive(:file?).with("/home/tests/.ssh/id_rsa").and_return(false)
+            }
+          }
+        ],
+        [ # connect_via_ssh should enable default and include due to existing
+          {:connect_via_ssh => true},
+          {:uri => 'qemu+ssh://localhost/system?no_verify=1&keyfile=/home/tests/.ssh/id_rsa', :id_ssh_key_file => '/home/tests/.ssh/id_rsa'},
+          {
+            :setup => ContextualProc.new {
+              expect(File).to receive(:file?).with("/home/tests/.ssh/id_rsa").and_return(true)
+            }
+          }
+        ],
+
+        # socket behaviour
+        [ # set
+          {:socket => '/var/run/libvirt/libvirt-sock'},
+          {:uri => "qemu:///system?socket=/var/run/libvirt/libvirt-sock"},
+        ],
+      ].each do |inputs, outputs, options|
+        opts = {}
+        opts.merge!(options) if options
+
+        it "should handle inputs #{inputs} with env (#{opts[:env]})" do
+          # allow some of these to fail for now if marked as such
+          if !opts[:allow_failure].nil?
+            pending(opts[:allow_failure])
+          end
 
-          subject.finalize!
-          expect(subject.uri).to eq("custom:///custom_path")
-          expect(subject.qemu_use_session).to eq(false)
-        end
+          if !opts[:setup].nil?
+            opts[:setup].apply(binding)
+          end
 
-        context 'when LIBVIRT_DEFAULT_URI contains "qemu"' do
-          [
-            [
-              'set qemu_use_session if "session" present',
-              'qemu:///session',
-              true,
-            ],
-            [
-              'handle different protocol additions',
-              'qemu+ssh:///session',
-              true,
-            ],
-            [
-              'handle options before and after path',
-              'qemu://remote/session?keyfile=my_id_rsa',
-              true,
-            ],
-            [
-              'identify when session not set',
-              'qemu://remote/system',
-              false,
-            ],
-            [
-              'handle session appearing elsewhere',
-              'qemu://remote/system?keyfile=my_session_id',
-              false,
-            ],
-          ].each do |title, uri, session|
-            it "should #{title}" do
-              fake_env['LIBVIRT_DEFAULT_URI'] = uri
-
-              subject.finalize!
-              expect(subject.uri).to eq(uri)
-              expect(subject.qemu_use_session).to eq(session)
-            end
+          inputs.each do |k, v|
+            subject.instance_variable_set("@#{k}", v)
           end
-        end
-      end
 
-      context 'when @driver is defined' do
-        defaults = {'id_ssh_key_file' => nil}
-        [
-          [
-            {'driver' => 'kvm'},
-            'qemu:///system?no_verify=1',
-            false,
-          ],
-          [
-            {'driver' => 'qemu'},
-            'qemu:///system?no_verify=1',
-            false,
-          ],
-          [
-            {'driver' => 'qemu', 'qemu_use_session' => true},
-            'qemu:///session?no_verify=1',
-            true,
-          ],
-          [
-            {'driver' => 'openvz'},
-            'openvz:///system?no_verify=1',
-            false,
-          ],
-          [
-            {'driver' => 'vbox'},
-            'vbox:///session?no_verify=1',
-            false,
-          ],
-        ].each do |inputs, output_uri, output_session|
-          it "should detect #{inputs}" do
-            inputs.merge(defaults).each do |k, v|
-              subject.instance_variable_set("@#{k}", v)
+          if !opts[:env].nil?
+            opts[:env].each do |k, v|
+              fake_env[k] = v
             end
+          end
 
-            subject.finalize!
-            expect(subject.uri).to eq(output_uri)
-            expect(subject.qemu_use_session).to eq(output_session)
+          subject.finalize!
+
+          # ensure failed output indicates which settings are incorrect in the failed test
+          got = subject.instance_variables.each_with_object({}) do |name, hash|
+            if outputs.key?(name.to_s[1..-1].to_sym)
+              hash["#{name.to_s[1..-1]}".to_sym] =subject.instance_variable_get(name)
+            end
           end
+          expect(got).to eq(outputs)
         end
+      end
 
+      context 'when invalid @driver is defined' do
         it "should raise exception for unrecognized" do
           subject.driver = "bad-driver"
 
@@ -113,65 +327,106 @@ describe VagrantPlugins::ProviderLibvirt::Config do
         end
       end
 
-      context 'when @connect_via_ssh defined' do
-        defaults = {'driver' => 'qemu', 'id_ssh_key_file' => nil}
-        [
-          [
-            {'connect_via_ssh' => true},
-            'qemu+ssh://localhost/system?no_verify=1',
-          ],
-          [
-            {'connect_via_ssh' => true, 'username' => 'my_user'},
-            'qemu+ssh://my_user@localhost/system?no_verify=1',
-          ],
-          [
-            {'connect_via_ssh' => true, 'host' => 'remote_server'},
-            'qemu+ssh://remote_server/system?no_verify=1',
-          ],
-        ].each do |inputs, output_uri|
-          it "should detect #{inputs}" do
-            inputs.merge(defaults).each do |k, v|
-              subject.instance_variable_set("@#{k}", v)
-            end
+      context 'when invalid @uri is defined' do
+        it "should raise exception for unrecognized" do
+          subject.uri = "://bad-uri"
 
-            subject.finalize!
-            expect(subject.uri).to eq(output_uri)
-          end
+          expect { subject.finalize! }.to raise_error("@uri set to invalid uri '://bad-uri'")
         end
       end
+    end
+
+    context '@proxy_command' do
+      before(:example) do
+        stub_const("ENV", fake_env)
+        fake_env['HOME'] = "/home/tests"
+      end
 
-      context 'when @id_ssh_key_file defined' do
-        defaults = {'driver' => 'qemu'}
+      [
+        # no connect_via_ssh
         [
-          [
-            {},
-            'qemu:///system?no_verify=1&keyfile=/home/user/.ssh/id_rsa',
-          ],
-          [
-            {'id_ssh_key_file' => '/path/to/keyfile'},
-            'qemu:///system?no_verify=1&keyfile=/path/to/keyfile',
-          ],
-        ].each do |inputs, output_uri|
-          it "should detect #{inputs}" do
-            inputs.merge(defaults).each do |k, v|
-              subject.instance_variable_set("@#{k}", v)
-            end
+          {:host => "remote"},
+          nil,
+        ],
+
+        # connect_via_ssh
+        [ # host
+          {:connect_via_ssh => true, :host => 'remote'},
+          "ssh 'remote' -W %h:%p",
+        ],
+        [ # include user
+          {:connect_via_ssh => true, :host => 'remote', :username => 'myuser'},
+          "ssh 'remote' -l 'myuser' -W %h:%p",
+        ],
+        [ # include user and default ssh key exists
+          {:connect_via_ssh => true, :host => 'remote', :username => 'myuser'},
+          "ssh 'remote' -l 'myuser' -i '/home/tests/.ssh/id_rsa' -W %h:%p",
+          {
+            :setup => ContextualProc.new {
+              expect(File).to receive(:file?).with("/home/tests/.ssh/id_rsa").and_return(true)
+            }
+          }
+        ],
+
+        # disable id_ssh_key_file
+        [
+          {:connect_via_ssh => true, :host => 'remote', :id_ssh_key_file => nil},
+          "ssh 'remote' -W %h:%p",
+        ],
+        [ # include user
+          {:connect_via_ssh => true, :host => 'remote', :id_ssh_key_file => nil},
+          "ssh 'remote' -W %h:%p",
+        ],
+
+        # use @uri
+        [
+          {:uri => 'qemu+ssh://remote/system'},
+          "ssh 'remote' -W %h:%p",
+        ],
+        [
+          {:uri => 'qemu+ssh://myuser@remote/system'},
+          "ssh 'remote' -l 'myuser' -W %h:%p",
+        ],
+        [
+          {:uri => 'qemu+ssh://remote/system?keyfile=/some/path/to/keyfile'},
+          "ssh 'remote' -i '/some/path/to/keyfile' -W %h:%p",
+          {:allow_failure => "keyfile not yet inferred from uri"},
+        ],
 
-            fake_env['HOME'] = '/home/user'
+        # provide custom template
+        [
+          {:connect_via_ssh => true, :host => 'remote', :proxy_command => "ssh {host} nc %h %p" },
+          "ssh remote nc %h %p",
+        ],
+        [
+          {:connect_via_ssh => true, :host => 'remote', :username => 'myuser', :proxy_command => "ssh {host} nc %h %p" },
+          "ssh remote nc %h %p",
+        ],
+        [
+          {:connect_via_ssh => true, :host => 'remote', :username => 'myuser', :proxy_command => "ssh {host} -l {username} nc %h %p" },
+          "ssh remote -l myuser nc %h %p",
+        ],
+      ].each do |inputs, proxy_command, options|
+        opts = {}
+        opts.merge!(options) if options
+
+        it "should handle inputs #{inputs}" do
+          # allow some of these to fail for now if marked as such
+          if !opts[:allow_failure].nil?
+            pending(opts[:allow_failure])
+          end
 
-            subject.finalize!
-            expect(subject.uri).to eq(output_uri)
+          if !opts[:setup].nil?
+            opts[:setup].apply(binding)
           end
-        end
-      end
 
-      context 'when @socket defined' do
-        it "should detect @socket set" do
-          subject.socket = '/var/run/libvirt/libvirt-sock'
-          subject.id_ssh_key_file = false
+          inputs.each do |k, v|
+            subject.instance_variable_set("@#{k}", v)
+          end
 
           subject.finalize!
-          expect(subject.uri).to eq('qemu:///system?no_verify=1&socket=/var/run/libvirt/libvirt-sock')
+
+          expect(subject.proxy_command).to eq(proxy_command)
         end
       end
     end
@@ -282,5 +537,15 @@ describe VagrantPlugins::ProviderLibvirt::Config do
         end
       end
     end
+
+    context 'clock_timers' do
+      it 'should merge clock_timers' do
+        one.clock_timer(:name => 'rtc', :tickpolicy => 'catchup')
+        two.clock_timer(:name => 'hpet', :present => 'no')
+
+        expect(subject.clock_timers).to include(include(name: 'rtc'),
+                                                include(name: 'hpet'))
+      end
+    end
   end
 end