fog-libvirt 0.5.0 → 0.9.0

data/minitests/server/server_test.rb

@@ -41,7 +41,7 @@ class ServerTest < Minitest::Test
     result.expect(:status, 0)
     result.expect(:stdout, "any_ip")
     fog_ssh.expect(:run, [result], [String])
-    uri = ::Fog::Compute::LibvirtUtil::URI.new('qemu+ssh://localhost:22?keyfile=nofile')
+    uri = ::Fog::Libvirt::Util::URI.new('qemu+ssh://localhost:22?keyfile=nofile')
     Fog::SSH.stub(:new, fog_ssh) do
       @server.send(:ssh_ip_command, "test command", uri)
     end

data/minitests/server/user_data_iso_test.rb

@@ -32,30 +32,27 @@ class UserDataIsoTest < Minitest::Test
   end
 
   def test_volume_is_created_during_user_data_iso_generation
-    iso_path = "iso_file_path"
     @server.stubs(:system).returns(true)
-    Fog::Compute::Libvirt::Volumes.any_instance.expects(:create).
+    Fog::Libvirt::Compute::Volumes.any_instance.expects(:create).
         with(has_entries(:name => @server.cloud_init_volume_name)).
         returns(@compute.volumes.new)
-    Fog::Compute::Libvirt::Volume.any_instance.stubs(:upload_image)
+    Fog::Libvirt::Compute::Volume.any_instance.stubs(:upload_image)
 
     @server.create_user_data_iso
   end
 
   def test_volume_is_uploaded_during_user_data_iso_generation
-    iso_path = "iso_file_path"
     @server.stubs(:system).returns(true)
-    Fog::Compute::Libvirt::Volumes.any_instance.stubs(:create).returns(@compute.volumes.new)
-    Fog::Compute::Libvirt::Volume.any_instance.expects(:upload_image).returns(true)
+    Fog::Libvirt::Compute::Volumes.any_instance.stubs(:create).returns(@compute.volumes.new)
+    Fog::Libvirt::Compute::Volume.any_instance.expects(:upload_image).returns(true)
 
     @server.create_user_data_iso
   end
 
   def test_iso_file_is_set_during_user_data_iso_generation
-    iso_path = "iso_file_path"
     @server.stubs(:system).returns(true)
-    Fog::Compute::Libvirt::Volumes.any_instance.stubs(:create).returns(@compute.volumes.new)
-    Fog::Compute::Libvirt::Volume.any_instance.stubs(:upload_image)
+    Fog::Libvirt::Compute::Volumes.any_instance.stubs(:create).returns(@compute.volumes.new)
+    Fog::Libvirt::Compute::Volume.any_instance.stubs(:upload_image)
 
     @server.create_user_data_iso
     assert_equal @server.cloud_init_volume_name, @server.iso_file
@@ -65,8 +62,8 @@ class UserDataIsoTest < Minitest::Test
     @server.stubs(:system).returns(true)
     volume = @compute.volumes.new
     volume.stubs(:path).returns("/srv/libvirt/#{@server.cloud_init_volume_name}")
-    Fog::Compute::Libvirt::Volumes.any_instance.stubs(:create).returns(volume)
-    Fog::Compute::Libvirt::Volume.any_instance.stubs(:upload_image)
+    Fog::Libvirt::Compute::Volumes.any_instance.stubs(:create).returns(volume)
+    Fog::Libvirt::Compute::Volume.any_instance.stubs(:upload_image)
 
     @server.create_user_data_iso
     assert_equal '/srv/libvirt', @server.iso_dir

data/minitests/test_helper.rb

@@ -1,5 +1,5 @@
 require 'minitest/autorun'
-require 'mocha/mini_test'
+require 'mocha/minitest'
 require 'fileutils'
 
 $: << File.join(File.dirname(__FILE__), '..', 'lib')

data/tests/helper.rb

@@ -3,7 +3,7 @@ ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
 
 require 'fog/libvirt'
 
-Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+Excon.defaults.merge!(debug_request: true, debug_response: true)
 
 require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
 

data/tests/helpers/formats_helper.rb

@@ -1,4 +1,6 @@
-require "fog/schema/data_validator"
+# frozen_string_literal: true
+
+require 'fog/schema/data_validator'
 
 # format related hackery
 # allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
@@ -15,62 +17,62 @@ module Fog
     module Array; end
   end
 end
-[FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)}
-[FalseClass, TrueClass, NilClass, Fog::Boolean].each {|klass| klass.send(:include, Fog::Nullable::Boolean)}
-[NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)}
-[NilClass, Time].each {|klass| klass.send(:include, Fog::Nullable::Time)}
-[Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)}
-[Float, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Float)}
-[Hash, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Hash)}
-[Array, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Array)}
+[FalseClass, TrueClass].each { |klass| klass.send(:include, Fog::Boolean) }
+[FalseClass, TrueClass, NilClass, Fog::Boolean].each { |klass| klass.send(:include, Fog::Nullable::Boolean) }
+[NilClass, String].each { |klass| klass.send(:include, Fog::Nullable::String) }
+[NilClass, Time].each { |klass| klass.send(:include, Fog::Nullable::Time) }
+[Integer, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Integer) }
+[Float, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Float) }
+[Hash, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Hash) }
+[Array, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Array) }
 
 module Shindo
+  # Generates a Shindo test that compares a hash schema to the result
+  # of the passed in block returning true if they match.
+  #
+  # The schema that is passed in is a Hash or Array of hashes that
+  # have Classes in place of values. When checking the schema the
+  # value should match the Class.
+  #
+  # Strict mode will fail if the data has additional keys. Setting
+  # +strict+ to +false+ will allow additional keys to appear.
+  #
+  # @param [Hash] schema A Hash schema
+  # @param [Hash] options Options to change validation rules
+  # @option options [Boolean] :allow_extra_keys
+  #     If +true+ does not fail when keys are in the data that are
+  #     not specified in the schema. This allows new values to
+  #     appear in API output without breaking the check.
+  # @option options [Boolean] :allow_optional_rules
+  #     If +true+ does not fail if extra keys are in the schema
+  #     that do not match the data. Not recommended!
+  # @yield Data to check with schema
+  #
+  # @example Using in a test
+  #     Shindo.tests("comparing welcome data against schema") do
+  #       data = {:welcome => "Hello" }
+  #       data_matches_schema(:welcome => String) { data }
+  #     end
+  #
+  #     comparing welcome data against schema
+  #     + data matches schema
+  #
+  # @example Example schema
+  #     {
+  #       "id" => String,
+  #       "ram" => Integer,
+  #       "disks" => [
+  #         {
+  #           "size" => Float
+  #         }
+  #       ],
+  #       "dns_name" => Fog::Nullable::String,
+  #       "active" => Fog::Boolean,
+  #       "created" => DateTime
+  #     }
+  #
+  # @return [Boolean]
   class Tests
-    # Generates a Shindo test that compares a hash schema to the result
-    # of the passed in block returning true if they match.
-    #
-    # The schema that is passed in is a Hash or Array of hashes that
-    # have Classes in place of values. When checking the schema the
-    # value should match the Class.
-    #
-    # Strict mode will fail if the data has additional keys. Setting
-    # +strict+ to +false+ will allow additional keys to appear.
-    #
-    # @param [Hash] schema A Hash schema
-    # @param [Hash] options Options to change validation rules
-    # @option options [Boolean] :allow_extra_keys
-    #     If +true+ does not fail when keys are in the data that are
-    #     not specified in the schema. This allows new values to
-    #     appear in API output without breaking the check.
-    # @option options [Boolean] :allow_optional_rules
-    #     If +true+ does not fail if extra keys are in the schema
-    #     that do not match the data. Not recommended!
-    # @yield Data to check with schema
-    #
-    # @example Using in a test
-    #     Shindo.tests("comparing welcome data against schema") do
-    #       data = {:welcome => "Hello" }
-    #       data_matches_schema(:welcome => String) { data }
-    #     end
-    #
-    #     comparing welcome data against schema
-    #     + data matches schema
-    #
-    # @example Example schema
-    #     {
-    #       "id" => String,
-    #       "ram" => Integer,
-    #       "disks" => [
-    #         {
-    #           "size" => Float
-    #         }
-    #       ],
-    #       "dns_name" => Fog::Nullable::String,
-    #       "active" => Fog::Boolean,
-    #       "created" => DateTime
-    #     }
-    #
-    # @return [Boolean]
     def data_matches_schema(schema, options = {})
       test('data matches schema') do
         validator = Fog::Schema::DataValidator.new
@@ -84,9 +86,9 @@ module Shindo
     def formats(format, strict = true)
       test('has proper format') do
         if strict
-          options = {:allow_extra_keys => false, :allow_optional_rules => true}
+          options = { allow_extra_keys: false, allow_optional_rules: true }
         else
-          options = {:allow_extra_keys => true, :allow_optional_rules => true}
+          options = { allow_extra_keys: true, allow_optional_rules: true }
         end
         validator = Fog::Schema::DataValidator.new
         valid = validator.validate(yield, format, options)

data/tests/helpers/formats_helper_tests.rb

@@ -1,37 +1,37 @@
 Shindo.tests('test_helper', 'meta') do
 
   tests('comparing welcome data against schema') do
-    data = {:welcome => "Hello" }
-    data_matches_schema(:welcome => String) { data }
+    data = { welcome: 'Hello' }
+    data_matches_schema(welcome: String) { data }
   end
 
   tests('#data_matches_schema') do
     tests('when value matches schema expectation') do
-      data_matches_schema({"key" => String}) { {"key" => "Value"} }
+      data_matches_schema('key' => String) { { 'key' => 'Value' } }
     end
 
     tests('when values within an array all match schema expectation') do
-      data_matches_schema({"key" => [Integer]}) { {"key" => [1, 2]} }
+      data_matches_schema('key' => [Integer]) { { 'key' => [1, 2] } }
     end
 
     tests('when nested values match schema expectation') do
-      data_matches_schema({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} }
+      data_matches_schema('key' => { nested_key: String }) { { 'key' => { nested_key: 'Value' } } }
     end
 
     tests('when collection of values all match schema expectation') do
-      data_matches_schema([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] }
+      data_matches_schema([{ 'key' => String }]) { [{ 'key' => 'Value' }, { 'key' => 'Value' }] }
     end
 
     tests('when collection is empty although schema covers optional members') do
-      data_matches_schema([{"key" => String}], {:allow_optional_rules => true}) { [] }
+      data_matches_schema([{ 'key' => String }], allow_optional_rules: true) { [] }
     end
 
     tests('when additional keys are passed and not strict') do
-      data_matches_schema({"key" => String}, {:allow_extra_keys => true}) { {"key" => "Value", :extra => "Bonus"} }
+      data_matches_schema({ 'key' => String }, allow_extra_keys: true) { { 'key' => 'Value', extra: 'Bonus' } }
     end
 
     tests('when value is nil and schema expects NilClass') do
-      data_matches_schema({"key" => NilClass}) { {"key" => nil} }
+      data_matches_schema('key' => NilClass) { { 'key' => nil } }
     end
 
     tests('when value and schema match as hashes') do
@@ -43,46 +43,45 @@ Shindo.tests('test_helper', 'meta') do
     end
 
     tests('when value is a Time') do
-      data_matches_schema({"time" => Time}) { {"time" => Time.now} }
+      data_matches_schema('time' => Time) { { 'time' => Time.now } }
     end
 
     tests('when key is missing but value should be NilClass (#1477)') do
-      data_matches_schema({"key" => NilClass}, {:allow_optional_rules => true}) { {} }
+      data_matches_schema({ 'key' => NilClass }, allow_optional_rules: true) { {} }
     end
 
     tests('when key is missing but value is nullable (#1477)') do
-      data_matches_schema({"key" => Fog::Nullable::String}, {:allow_optional_rules => true}) { {} }
+      data_matches_schema({ 'key' => Fog::Nullable::String }, allow_optional_rules: true) { {} }
     end
   end
 
   tests('#formats backwards compatible changes') do
-
     tests('when value matches schema expectation') do
-      formats({"key" => String}) { {"key" => "Value"} }
+      formats('key' => String) { { 'key' => 'Value' } }
     end
 
     tests('when values within an array all match schema expectation') do
-      formats({"key" => [Integer]}) { {"key" => [1, 2]} }
+      formats('key' => [Integer]) { { 'key' => [1, 2] } }
     end
 
     tests('when nested values match schema expectation') do
-      formats({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} }
+      formats('key' => { nested_key: String }) { { 'key' => { nested_key: 'Value' } } }
     end
 
     tests('when collection of values all match schema expectation') do
-      formats([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] }
+      formats([{ 'key' => String }]) { [{ 'key' => 'Value' }, { 'key' => 'Value' }] }
     end
 
     tests('when collection is empty although schema covers optional members') do
-      formats([{"key" => String}]) { [] }
+      formats([{ 'key' => String }]) { [] }
     end
 
     tests('when additional keys are passed and not strict') do
-      formats({"key" => String}, false) { {"key" => "Value", :extra => "Bonus"} }
+      formats({ 'key' => String }, false) { { 'key' => 'Value', :extra => 'Bonus' } }
     end
 
     tests('when value is nil and schema expects NilClass') do
-      formats({"key" => NilClass}) { {"key" => nil} }
+      formats('key' => NilClass) { { 'key' => nil } }
     end
 
     tests('when value and schema match as hashes') do
@@ -94,17 +93,15 @@ Shindo.tests('test_helper', 'meta') do
     end
 
     tests('when value is a Time') do
-      formats({"time" => Time}) { {"time" => Time.now} }
+      formats('time' => Time) { { 'time' => Time.now } }
     end
 
     tests('when key is missing but value should be NilClass (#1477)') do
-      formats({"key" => NilClass}) { {} }
+      formats('key' => NilClass) { {} }
     end
 
     tests('when key is missing but value is nullable (#1477)') do
-      formats({"key" => Fog::Nullable::String}) { {} }
+      formats('key' => Fog::Nullable::String) { {} }
     end
-
   end
-
 end

data/tests/helpers/mock_helper.rb

@@ -9,6 +9,6 @@ end
 # if in mocked mode, fill in some fake credentials for us
 if Fog.mock?
   Fog.credentials = {
-    :libvirt_uri                      => 'qemu://libvirt/system',
+    libvirt_uri:                       'qemu://libvirt/system',
   }.merge(Fog.credentials)
 end

data/tests/helpers/succeeds_helper.rb

@@ -1,8 +1,8 @@
 module Shindo
   class Tests
-    def succeeds
+    def succeeds(&block)
       test('succeeds') do
-        !!instance_eval(&Proc.new)
+        !instance_eval(&Proc.new(&block)).nil?
       end
     end
   end

data/tests/libvirt/compute_tests.rb

@@ -9,7 +9,8 @@ Shindo.tests('Fog::Compute[:libvirt]', ['libvirt']) do
   end
 
   tests("Compute requests") do
-    %w{ create_domain create_volume define_domain define_pool destroy_interface destroy_network get_node_info list_domains
+    %w{ create_domain create_volume define_domain define_pool destroy_interface destroy_network get_node_info
+        update_autostart list_domains
         list_interfaces list_networks list_pools list_pool_volumes list_volumes pool_action vm_action volume_action
         dhcp_leases }.each do |request|
       test("it should respond to #{request}") { compute.respond_to? request }

data/tests/libvirt/models/compute/interface_tests.rb

@@ -21,7 +21,7 @@ Shindo.tests('Fog::Compute[:libvirt] | interface model', ['libvirt']) do
         end
       end
     end
-    test('be a kind of Fog::Compute::Libvirt::Interface') { interface.kind_of? Fog::Compute::Libvirt::Interface }
+    test('be a kind of Fog::Libvirt::Compute::Interface') { interface.kind_of? Fog::Libvirt::Compute::Interface }
   end
 
 end

data/tests/libvirt/models/compute/interfaces_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('Fog::Compute[:libvirt] | interfaces collection', ['libvirt']) do
 
   tests('The interfaces collection') do
     test('should not be empty') { not interfaces.empty? }
-    test('should be a kind of Fog::Compute::Libvirt::Interfaces') { interfaces.kind_of? Fog::Compute::Libvirt::Interfaces }
+    test('should be a kind of Fog::Libvirt::Compute::Interfaces') { interfaces.kind_of? Fog::Libvirt::Compute::Interfaces }
     tests('should be able to reload itself').succeeds { interfaces.reload }
     tests('should be able to get a model') do
       tests('by instance name').succeeds { interfaces.get interfaces.first.name }

data/tests/libvirt/models/compute/network_tests.rb

@@ -25,7 +25,7 @@ Shindo.tests('Fog::Compute[:libvirt] | network model', ['libvirt']) do
         end
       end
     end
-    test('be a kind of Fog::Compute::Libvirt::Network') { network.kind_of? Fog::Compute::Libvirt::Network }
+    test('be a kind of Fog::Libvirt::Compute::Network') { network.kind_of? Fog::Libvirt::Compute::Network }
   end
 
 end

data/tests/libvirt/models/compute/networks_tests.rb

@@ -3,7 +3,7 @@ Shindo.tests('Fog::Compute[:libvirt] | networks collection', ['libvirt']) do
   networks = Fog::Compute[:libvirt].networks
 
   tests('The networks collection') do
-    test('should be a kind of Fog::Compute::Libvirt::Networks') { networks.kind_of? Fog::Compute::Libvirt::Networks }
+    test('should be a kind of Fog::Libvirt::Compute::Networks') { networks.kind_of? Fog::Libvirt::Compute::Networks }
     tests('should be able to reload itself').succeeds { networks.reload }
     tests('should be able to get a model') do
       tests('by instance id').succeeds { networks.get networks.first.uuid }

data/tests/libvirt/models/compute/nic_tests.rb

@@ -25,7 +25,7 @@ Shindo.tests('Fog::Compute[:libvirt] | nic model', ['libvirt']) do
         end
       end
     end
-    test('be a kind of Fog::Compute::Libvirt::Nic') { nic.kind_of? Fog::Compute::Libvirt::Nic }
+    test('be a kind of Fog::Libvirt::Compute::Nic') { nic.kind_of? Fog::Libvirt::Compute::Nic }
   end
 
 end

data/tests/libvirt/models/compute/pool_tests.rb

@@ -21,7 +21,7 @@ Shindo.tests('Fog::Compute[:libvirt] | interface model', ['libvirt']) do
         end
       end
     end
-    test('be a kind of Fog::Compute::Libvirt::Pool') { pool.kind_of? Fog::Compute::Libvirt::Pool }
+    test('be a kind of Fog::Libvirt::Compute::Pool') { pool.kind_of? Fog::Libvirt::Compute::Pool }
   end
 
 end

data/tests/libvirt/models/compute/pools_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('Fog::Compute[:libvirt] | pools request', ['libvirt']) do
 
   tests('The pools collection') do
       test('should not be empty') { not pools.empty? }
-      test('should be a kind of Fog::Compute::Libvirt::Pools') { pools.kind_of? Fog::Compute::Libvirt::Pools }
+      test('should be a kind of Fog::Libvirt::Compute::Pools') { pools.kind_of? Fog::Libvirt::Compute::Pools }
       tests('should be able to reload itself').succeeds { pools.reload }
       tests('should be able to get a model') do
         tests('by instance id').succeeds { pools.get pools.first.uuid }

data/tests/libvirt/models/compute/server_tests.rb

@@ -5,6 +5,8 @@ Shindo.tests('Fog::Compute[:libvirt] | server model', ['libvirt']) do
 
   tests('The server model should') do
     tests('have the action') do
+      test('autostart') { server.respond_to? 'autostart' }
+      test('update_autostart') { server.respond_to? 'update_autostart' }
       test('reload') { server.respond_to? 'reload' }
       %w{ start stop destroy reboot suspend }.each do |action|
         test(action) { server.respond_to? action }
@@ -42,6 +44,7 @@ Shindo.tests('Fog::Compute[:libvirt] | server model', ['libvirt']) do
         :volumes,
         :active,
         :boot_order,
+        :hugepages,
         :state]
       tests("The server model should respond to") do
         attributes.each do |attribute|
@@ -55,6 +58,6 @@ Shindo.tests('Fog::Compute[:libvirt] | server model', ['libvirt']) do
         end
       end
     end
-    test('be a kind of Fog::Compute::Libvirt::Server') { server.kind_of? Fog::Compute::Libvirt::Server }
+    test('be a kind of Fog::Libvirt::Compute::Server') { server.kind_of? Fog::Libvirt::Compute::Server }
   end
 end