Merge pull request #1895 from rackspace/dns_page

[rackspace|dns] Fix Pagination in DNS

lib/fog/rackspace/dns.rb

@@ -130,7 +130,13 @@ module Fog
         end
 
         def array_to_query_string(arr)
-          arr.collect {|k,v| "#{k}=#{v}" }.join('&')
+          return "" unless arr
+          query_array = arr.collect do | k, v |
+            val_str = v.is_a?(Array) ? v.join(",") : v.to_s
+            "#{k}=#{val_str}"
+          end
+
+          query_array.join('&')
         end
 
         def validate_path_fragment(name, fragment)

lib/fog/rackspace/models/dns/zones.rb

@@ -6,6 +6,8 @@ module Fog
     class Rackspace
       class Zones < Fog::Collection
 
+        attribute :total_entries, :aliases => "totalEntries"
+
         model Fog::DNS::Rackspace::Zone
 
         # List all domains. Return by default a maximum of 100 items
@@ -15,32 +17,27 @@ module Fog
         # @option options [Integer] :offset starting offset of records to return
         def all(options={})
           clear
-          data = service.list_domains(options).body['domains']
-          load(data)
+          body = service.list_domains(options).body
+          merge_attributes(body)
+
+          load(body['domains'])
         end
         
         alias :each_zone_this_page :each
         def each
-          if !block_given?
-            self
-          else
-            body = service.list_domains.body
-            subset = dup.all
+          return self unless block_given?
 
-            subset.each_zone_this_page {|f| yield f}
-            if body.has_key?('links')
-              while !body['links'].select{|l| l['rel'] == 'next'}.empty?
-                url = body['links'].select{|l| l['rel'] == 'next'}.first['href']
-                query = url.match(/\?(.+)/)
-                parsed = CGI.parse($1)
-                
-                body = service.list_domains(:offset => parsed['offset'], :limit => parsed['limit']).body
-                subset = dup.all(:offset => parsed['offset'], :limit => parsed['limit'])
-                subset.each_zone_this_page {|f| yield f}
-              end
-            end
-            self
+          params = { :limit => 100} # prime loop (100 Records is default page size for Rackspace Cloud)
+          while params
+            body = service.list_domains(params).body
+            subset = dup.load(body["domains"])
+            self.merge_attributes(body)
+
+            params = next_params(body)
+
+            subset.each_zone_this_page {|zone| yield zone}
           end
+          self
         end
 
         def get(zone_id)
@@ -56,7 +53,23 @@ module Fog
         rescue Fog::Rackspace::Errors::ServiceUnavailable
           nil
         end
+
+        private
+        def next_params(body)
+          # return if we don't have any links
+          return nil unless body && body['links']
+
+          #return if links don't contain a href for the next page
+          next_link = body['links'].find {|h| h['rel'] == 'next'}
+          return nil unless next_link && next_link['href']
+
+          url = next_link['href']
+          uri = URI.parse url
+          return nil unless uri.query
+          CGI.parse uri.query
+        end
       end
+
     end
   end
 end

lib/fog/rackspace/requests/dns/list_domains.rb

@@ -5,8 +5,8 @@ module Fog
         def list_domains(options={})
 
           path = 'domains'
-          if !options.empty?
-            path = path + '?' + array_to_query_string(options)
+          unless options.empty?
+            path += "?#{array_to_query_string(options)}"
           end
 
           request(

tests/rackspace/dns_tests.rb

@@ -82,4 +82,15 @@ Shindo.tests('Fog::DNS::Rackspace', ['rackspace']) do
     end
   end
 
+  tests('array_to_query_string') do
+    pending if Fog.mocking?
+
+    @service = Fog::DNS::Rackspace.new
+    returns("") { @service.send(:array_to_query_string, nil) }
+    returns("param1=1") { @service.send(:array_to_query_string, {:param1 => [1]}) }
+    returns("param1=1") { @service.send(:array_to_query_string, {:param1 => 1}) }
+    returns("param1=1,2") { @service.send(:array_to_query_string, {:param1 => [1,2]}) }
+    returns("param1=1&param2=2") { @service.send(:array_to_query_string, {:param1 => [1], :param2 => [2]}) }
+  end
+
 end

tests/rackspace/models/dns/zones_tests.rb

@@ -1,22 +1,36 @@
 Shindo.tests('Fog::Rackspace::DNS | zones', ['rackspace']) do
-  pending if Fog.mocking?
 
   provider = Fog::DNS[:rackspace]
   domain_sld = uniq_id
   domain_name = domain_sld + '.com'
 
   begin
-    zone = provider.zones.create({:domain => domain_name, :email => "hostmaster@#{domain_name}"})
+    unless Fog.mocking?
+      zone = provider.zones.create({:domain => domain_name, :email => "hostmaster@#{domain_name}"})
+    end
 
     tests("zones.find(#{domain_sld}) => finds domain_name") do
-      returns(1) { provider.zones.find(domain_sld).length }
+      pending if Fog.mocking?
+      returns(true) { provider.zones.all.any? {|z| z.domain == domain_name} }
     end
 
     random_name = uniq_id
     tests("zones.find(#{random_name}) => finds nothing") do
-      returns(0) { provider.zones.find(random_name).length }
+      pending if Fog.mocking?
+      returns(false) { provider.zones.all.any? {|z| z.domain == random_name} }
     end
   ensure
-    zone.destroy
+    zone.destroy unless Fog.mocking?
   end
+
+  tests('next_params') do
+    zones = Fog::DNS::Rackspace::Zones.new
+    returns(nil, "no body") { zones.send(:next_params, nil)}
+    returns(nil, "no links") { zones.send(:next_params, {}) }
+    returns(nil, "links are empty") { zones.send(:next_params, {'links' => []}) }
+    returns(nil, "links does not contain next hash") { zones.send(:next_params, {'links' => [ {'rel' => 'previous'} ] }) }
+    returns(nil, "contains a link without parameters") { zones.send(:next_params, {'links' => [ {'rel' => 'next', 'href' => "http://localhost/next"} ] }) }
+    returns({"offset"=>["3"], "limit"=>["3"]}, "contains a link without parameters") { zones.send(:next_params, {'links' => [ {'rel' => 'next', 'href' => "http://localhost/next?offset=3&limit=3"} ] }) }
+  end
+
 end