fog 1.9.0 → 1.10.0

data/tests/dreamhost/models/dns/zones_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests("Fog::DNS[:dreamhost] | Zones Collection", ['dreamhost', 'dns']) do
+
+  service = Fog::DNS[:dreamhost]
+  
+  tests('#all') do
+    zones = service.zones
+
+    test('should be an array') { zones.is_a? Array }
+
+    test('should not be empty') { !zones.empty? }
+    
+    tests('should list Fog::DNS::Dreamhost::Zone') do
+      zones.each do |r|
+        test("as zone") { r.is_a?(Fog::DNS::Dreamhost::Zone) }
+      end
+    end
+  end
+
+  tests('#get') do
+    tests('should fetch a zone') do
+      zone = service.zones.get test_domain 
+      test('should be a Fog::DNS::Dreamhost::Zone') do
+        zone.is_a? Fog::DNS::Dreamhost::Zone
+      end
+    end
+  end
+
+end
+

data/tests/dreamhost/requests/dns/create_record_tests.rb

@@ -0,0 +1,39 @@
+Shindo.tests('Fog::DNS[:dreamhost] | create_record request', ['dreamhost', 'dns']) do
+
+  tests("success") do
+    
+    test("create an A resource record without comment") do
+      name = "foo.testing.#{test_domain}"
+      type = "A"
+      value = "1.2.3.4"
+      response = Fog::DNS[:dreamhost].create_record(name, type, value)
+
+      response.body['result'] == 'success'
+    end
+    
+    test("create an A resource record with comment") do
+      name = "foo2.testing.#{test_domain}"
+      type = "A"
+      value = "1.2.3.4"
+      comment = "test"
+      response = Fog::DNS[:dreamhost].create_record(name, type, value, comment)
+      
+      response.body['result'] == 'success'
+    end
+
+    test("create TXT record") do
+      name = "txt.testing.#{test_domain}"
+      type = "txt"
+      value = "foobar"
+      comment = "test"
+      response = Fog::DNS[:dreamhost].create_record(name, type, value, comment)
+      
+      response.body['result'] == 'success'
+    end
+
+  end
+
+  # helper
+  cleanup_records
+
+end

data/tests/dreamhost/requests/dns/delete_record_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests('Fog::DNS[:dreamhost] | delete_record request', ['dreamhost', 'dns']) do
+
+  tests("success") do
+    
+    test("delete testing records") do
+      name = "delete-test.#{test_domain}"
+      type = "A"
+      value = "1.2.3.4"
+      comment = "test"
+      Fog::DNS[:dreamhost].create_record(name, type, value, comment)
+      response = Fog::DNS[:dreamhost].delete_record(name, type, value)
+      response.body['result'] == 'success'
+    end
+
+  end
+
+  tests( 'failure') do
+    raises(RuntimeError, 'deleting non-existent record') do
+      Fog::DNS[:dreamhost].delete_record('foo.bar.bar', 'A', '1.2.3.4')
+    end
+  end
+
+  # helper
+  cleanup_records
+
+end

data/tests/dreamhost/requests/dns/list_records_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests('Fog::DNS[:dreamhost] | list_records request', ['dreamhost', 'dns']) do
+
+  tests("success") do
+    
+    response = Fog::DNS[:dreamhost].list_records
+
+    test("should return 200") do
+      if response.status == 200
+        @records = response.body["data"]
+      end
+      (response.status == 200) and (response.body.size == 2)
+    end
+
+    test("data should be an Array") do
+      @records.is_a? Array
+    end
+
+    tests("should return records") do
+      %w{type zone value comment record}.each do |elem|
+        test("with #{elem}") do
+          @records.first[elem].is_a? String
+        end
+      end
+    end
+    
+  end
+
+  # helper
+  cleanup_records
+
+end

data/tests/glesys/requests/compute/helper.rb

@@ -5,7 +5,7 @@ class Glesys
 
         LIST = {
           'debug' => {
-            'input' => []
+            'input' => Array
           },
           'servers' => [{
             'serverid' => String,
@@ -122,7 +122,7 @@ class Glesys
               'current' => Fog::Nullable::Integer,
               'unit'    => String
             },
-            'warnings'  => []
+            'warnings'  => Array
           },
           'status' => {
             'timestamp' => String,
@@ -161,7 +161,7 @@ class Glesys
             'netmask'     => Fog::Nullable::String,
             'broadcast'   => Fog::Nullable::String,
             'gateway'     => Fog::Nullable::String,
-            'nameservers' => [],
+            'nameservers' => Array,
             'datacenter'  => String,
             'serverid'    => Fog::Nullable::String,
             'platform'    => String,
@@ -189,7 +189,7 @@ class Glesys
             'ipversion'   => Integer,
             'datacenter'  => String,
             'platform'    => String,
-            "ipaddresses" => []
+            "ipaddresses" => Array
           },
           'status' => {
             'timestamp' => String,
@@ -214,7 +214,7 @@ class Glesys
             'netmask'     => String,
             'broadcast'   => String,
             'gateway'     => String,
-            'nameservers' => [],
+            'nameservers' => Array,
             'datacenter'  => String,
             'serverid'    => Fog::Nullable::String,
             'platform'    => String,

data/tests/helper.rb

@@ -18,7 +18,7 @@ end
 all_providers = Fog.registered_providers.map {|provider| provider.downcase}
 
 # Manually remove these providers since they are local applications, not lacking credentials
-all_providers = all_providers - ["libvirt", "virtualbox", "vmfusion"]
+all_providers = all_providers - ["libvirt", "vmfusion"]
 
 available_providers = Fog.available_providers.map {|provider| provider.downcase}
 

data/tests/helpers/formats_helper.rb

@@ -1,3 +1,5 @@
+require "fog/schema/data_validator"
+
 # format related hackery
 # allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
 # allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String)
@@ -25,62 +27,73 @@ end
 module Shindo
   class Tests
 
-    def formats(format, strict=true)
-      raise ArgumentError, 'format is nil' unless format
-
-      test('has proper format') do
-        formats_kernel(instance_eval(&Proc.new), format, true, strict)
+    # 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
+        valid = validator.validate(yield, schema, options)
+        @message = validator.message unless valid
+        valid
       end
     end
 
-    private
-
-    def formats_kernel(original_data, original_format, original = true, strict = true)
-      valid = true
-      data = original_data.dup
-      format = original_format.dup
-      if format.is_a?(Array)
-        data   = {:element => data}
-        format = {:element => format}
-      end
-      for key, value in format
-        datum = data.delete(key)
-        format.delete(key)
-        case value
-        when Array
-          p("#{key.inspect} not Array: #{datum.inspect}") unless datum.is_a?(Array)
-          valid &&= datum.is_a?(Array)
-          if datum.is_a?(Array) && !value.empty?
-            for element in datum
-              type = value.first
-              if type.is_a?(Hash)
-                valid &&= formats_kernel({:element => element}, {:element => type}, false, strict)
-              else
-                valid &&= element.is_a?(type)
-              end
-            end
-          end
-        when Hash
-          p("#{key.inspect} not Hash: #{datum.inspect}") unless datum.is_a?(Hash)
-          valid &&= datum.is_a?(Hash)
-          valid &&= formats_kernel(datum, value, false, strict)
+    # @deprecated #formats is deprecated. Use #data_matches_schema instead
+    def formats(format, strict = true)
+      test('has proper format') do
+        if strict
+          options = {:allow_extra_keys => false, :allow_optional_rules => true}
         else
-          p "#{key.inspect} not #{value.inspect}: #{datum.inspect}" unless datum.is_a?(value)
-          valid &&= datum.is_a?(value)
+          options = {:allow_extra_keys => true, :allow_optional_rules => true}
         end
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, format, options)
+        @message = validator.message unless valid
+        valid
       end
-      p data unless data.empty?
-      p format unless format.empty?
-      if strict
-        valid &&= data.empty? && format.empty?
-      else
-        valid &&= format.empty?
-      end
-      if !valid && original
-        @message = "#{original_data.inspect} does not match #{original_format.inspect}"
-      end
-      valid
     end
-
   end
 end

data/tests/helpers/formats_helper_tests.rb

@@ -1,60 +1,111 @@
 Shindo.tests('test_helper', 'meta') do
 
-  tests('#formats_kernel') do
+  tests('comparing welcome data against schema') do
+    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"} }
+    end
+
+    tests('when values within an array all match schema expectation') do
+      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"}} }
+    end
+
+    tests('when collection of values all match schema expectation') do
+      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}) { [] }
+    end
+
+    tests('when additional keys are passed and not strict') do
+      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} }
+    end
+
+    tests('when value and schema match as hashes') do
+      data_matches_schema({}) { {} }
+    end
 
-    tests('returns true') do
+    tests('when value and schema match as arrays') do
+      data_matches_schema([]) { [] }
+    end
 
-      test('when format of value matches') do
-        formats_kernel({:a => :b}, {:a => Symbol})
-      end
+    tests('when value is a Time') do
+      data_matches_schema({"time" => Time}) { {"time" => Time.now} }
+    end
 
-      test('when format of nested array elements matches') do
-        formats_kernel({:a => [:b, :c]}, {:a => [Symbol]})
-      end
+    tests('when key is missing but value should be NilClass (#1477)') do
+      data_matches_schema({"key" => NilClass}, {:allow_optional_rules => true}) { {} }
+    end
 
-      test('when format of nested hash matches') do
-        formats_kernel({:a => {:b => :c}}, {:a => {:b => Symbol}})
-      end
+    tests('when key is missing but value is nullable (#1477)') do
+      data_matches_schema({"key" => Fog::Nullable::String}, {:allow_optional_rules => true}) { {} }
+    end
+  end
 
-      test('when format of an array') do
-        formats_kernel([{:a => :b}], [{:a => Symbol}])
-      end
+  tests('#formats backwards compatible changes') do
 
-      test('non strict extra data') do
-        formats_kernel({:a => :b, :b => :c}, {:a => Symbol}, true, false)
-      end
+    tests('when value matches schema expectation') do
+      formats({"key" => String}) { {"key" => "Value"} }
+    end
 
+    tests('when values within an array all match schema expectation') do
+      formats({"key" => [Integer]}) { {"key" => [1, 2]} }
     end
 
-    tests('returns false') do
+    tests('when nested values match schema expectation') do
+      formats({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} }
+    end
 
-      test('when format of value does not match') do
-        !formats_kernel({:a => :b}, {:a => String})
-      end
+    tests('when collection of values all match schema expectation') do
+      formats([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] }
+    end
 
-      test('when not all keys are checked') do
-        !formats_kernel({:a => :b}, {})
-      end
+    tests('when collection is empty although schema covers optional members') do
+      formats([{"key" => String}]) { [] }
+    end
 
-      test('when some keys do not appear') do
-        !formats_kernel({}, {:a => String})
-      end
+    tests('when additional keys are passed and not strict') do
+      formats({"key" => String}, false) { {"key" => "Value", :extra => "Bonus"} }
+    end
+
+    tests('when value is nil and schema expects NilClass') do
+      formats({"key" => NilClass}) { {"key" => nil} }
+    end
 
-      test('when an array is expected but another data type is found') do
-        !formats_kernel({:a => 'not an array'}, {:a => []})
-      end
+    tests('when value and schema match as hashes') do
+      formats({}) { {} }
+    end
 
-      test('when a hash is expected but another data type is found') do
-        !formats_kernel({:a => 'not a hash'}, {:a => {}}, true, false)
-      end
+    tests('when value and schema match as arrays') do
+      formats([]) { [] }
+    end
 
+    tests('when value is a Time') do
+      formats({"time" => Time}) { {"time" => Time.now} }
+    end
 
-      test('non strict extra data') do
-        !formats_kernel({:a => :b, :b => :c}, {:z => Symbol}, true, false)
-      end
+    tests('when key is missing but value should be NilClass (#1477)') do
+      formats({"key" => NilClass}) { {} }
+    end
 
+    tests('when key is missing but value is nullable (#1477)') do
+      formats({"key" => Fog::Nullable::String}) { {} }
     end
 
   end
 
+
 end