Merge pull request #3195 from frodenas/gce_dns

[google|dns] Add missing models, requests and tests

lib/fog/google/dns.rb

@@ -10,34 +10,68 @@ module Fog
       GOOGLE_DNS_BASE_URL        = 'https://www.googleapis.com/dns/'
       GOOGLE_DNS_API_SCOPE_URLS  = %w(https://www.googleapis.com/auth/ndev.clouddns.readwrite)
 
+      ##
+      # MODELS
+      model_path 'fog/google/models/dns'
+
+      # Zone
+      model :zone
+      collection :zones
+
+      # Record
+      model :record
+      collection :records
+
+      # Change
+      model :change
+      collection :changes
+
+      # Project
+      model :project
+      collection :projects
+
+      ##
+      # REQUESTS
       request_path 'fog/google/requests/dns'
+
+      # Zone
       request :create_managed_zone
       request :delete_managed_zone
       request :get_managed_zone
       request :list_managed_zones
 
+      # Record
+      request :list_resource_record_sets
+
+      # Change
+      request :create_change
+      request :get_change
+      request :list_changes
+
+      # Project
+      request :get_project
+
       class Mock
-	include Fog::Google::Shared
+        include Fog::Google::Shared
 
         def initialize(options)
           shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
         end
 
-	def self.data(api_version)
-	  @data ||= {}
-	end
+        def self.data(api_version)
+          @data ||= {}
+        end
 
-	def self.reset
-	  @data = nil
-	end
+        def self.reset
+          @data = nil
+        end
 
         def data(project=@project)
           self.class.data(api_version)[project] ||= {
-              :managed_zones => {
-                  :by_id => {},
-                  :by_name => {},
-              },
-	  }
+            :managed_zones => {},
+            :resource_record_sets => {},
+            :changes => {},
+          }
         end
 
         def reset_data

lib/fog/google/examples/dns/project.rb

@@ -0,0 +1,8 @@
+def test
+  connection = Fog::DNS::Google.new
+
+  puts 'Get the Project limits...'
+  puts '-------------------------'
+  connection.projects.get(Fog::DNS[:google].project)
+
+end

lib/fog/google/examples/dns/zones.rb

@@ -0,0 +1,39 @@
+def test
+  connection = Fog::DNS::Google.new
+
+  puts 'Create a Zone...'
+  puts '----------------'
+  zone = connection.zones.create(name: 'mytestdomain', domain: 'example.org.', description: 'This is my test domain')
+
+  puts 'List all Zones...'
+  puts '-----------------'
+  connection.zones.all
+
+  puts 'Get the Zone...'
+  puts '---------------'
+  zone = connection.zones.get(zone.id)
+
+  puts 'Create an "A" Record...'
+  puts '-----------------------'
+  record = zone.records.create(name: 'test.example.org.', type: 'A', ttl: 3600, rrdatas: ['192.168.1.1'])
+
+  puts 'Get the Zone Resource Record Sets...'
+  puts '------------------------------------'
+  zone.records
+
+  puts 'Modify the "A" Record...'
+  puts '------------------------'
+  record.modify(ttl: 2600)
+
+  puts 'Delete the "A" Record...'
+  puts '------------------------'
+  record.destroy
+
+  puts 'Get the Zone Changes...'
+  puts '-----------------------'
+  zone.changes
+
+  puts 'Delete the Zone...'
+  puts '------------------'
+  zone.destroy
+end

lib/fog/google/models/dns/change.rb

@@ -0,0 +1,40 @@
+require 'fog/core/model'
+
+module Fog
+  module DNS
+    class Google
+      ##
+      # Represents a Change resource
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/changes
+      class Change < Fog::Model
+        identity :id
+
+        attribute :kind
+        attribute :start_time, :aliases => 'startTime'
+        attribute :status
+        attribute :additions
+        attribute :deletions
+
+        DONE_STATE    = 'done'
+        PENDING_STATE = 'pending'
+
+        ##
+        # Checks if the change operation is pending
+        #
+        # @return [Boolean] True if the change operation is pending; False otherwise
+        def pending?
+          self.status == PENDING_STATE
+        end
+
+        ##
+        # Checks if the change operation is done
+        #
+        # @return [Boolean] True if the change operation is done; False otherwise
+        def ready?
+          self.status == DONE_STATE
+        end
+      end
+    end
+  end
+end

lib/fog/google/models/dns/changes.rb

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/google/models/dns/zone'
+
+module Fog
+  module DNS
+    class Google
+      class Changes < Fog::Collection
+        model Fog::DNS::Google::Change
+
+        attribute :zone
+
+        ##
+        # Enumerates the list of Changes
+        #
+        # @return [Array<Fog::DNS::Google::Change>] List of Changes resources
+        def all
+          requires :zone
+
+          data = service.list_changes(zone.identity).body['changes'] || []
+          load(data)
+        rescue Fog::Errors::NotFound
+          []
+        end
+
+        ##
+        # Fetches the representation of an existing Change
+        #
+        # @param [String] identity Change identity
+        # @return [Fog::DNS::Google::Change] Change resource
+        def get(identity)
+          requires :zone
+
+          if change = service.get_change(zone.identity, identity).body
+            new(change)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

lib/fog/google/models/dns/project.rb

@@ -0,0 +1,75 @@
+require 'fog/core/model'
+
+module Fog
+  module DNS
+    class Google
+      ##
+      # Represents a Project resource
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/projects
+      class Project < Fog::Model
+        identity :id
+
+        attribute :kind
+        attribute :number
+        attribute :quota
+
+        # These attributes are not available in the representation of a 'Project' returned by the Google DNS API
+        attribute :managed_zones
+        attribute :rrsets_per_managed_zone
+        attribute :resource_records_per_rrset
+        attribute :rrset_additions_per_change
+        attribute :rrset_deletions_per_change
+        attribute :total_rrdatasize_per_change
+
+        ##
+        # Returns the maximum allowed number of managed zones in the project
+        #
+        # @return [Integer] Maximum allowed number of managed zones in the project
+        def managed_zones
+          self.quota['managedZones']
+        end
+
+        ##
+        # Returns the maximum allowed number of ResourceRecordSets per zone in the project
+        #
+        # @return [Integer] The maximum allowed number of ResourceRecordSets per zone in the project
+        def rrsets_per_managed_zone
+          self.quota['rrsetsPerManagedZone']
+        end
+
+        ##
+        # Returns the maximum allowed number of resource records per ResourceRecordSet
+        #
+        # @return [Integer] The maximum allowed number of resource records per ResourceRecordSet
+        def resource_records_per_rrset
+          self.quota['resourceRecordsPerRrset']
+        end
+
+        ##
+        # Returns the maximum allowed number of ResourceRecordSets to add per Changes.create request
+        #
+        # @return [Integer] The maximum allowed number of ResourceRecordSets to add per Changes.create request
+        def rrset_additions_per_change
+          self.quota['rrsetAdditionsPerChange']
+        end
+
+        ##
+        # Returns the maximum allowed number of ResourceRecordSets to delete per Changes.create request
+        #
+        # @return [Integer] The maximum allowed number of ResourceRecordSets to delete per Changes.create request
+        def rrset_deletions_per_change
+          self.quota['rrsetDeletionsPerChange']
+        end
+
+        ##
+        # Returns the maximum allowed size in bytes for the rrdata field in one Changes.create request
+        #
+        # @return [Integer] The maximum allowed size in bytes for the rrdata field in one Changes.create request
+        def total_rrdatasize_per_change
+          self.quota['totalRrdataSizePerChange']
+        end
+      end
+    end
+  end
+end

lib/fog/google/models/dns/projects.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/google/models/dns/project'
+
+module Fog
+  module DNS
+    class Google
+      class Projects < Fog::Collection
+        model Fog::DNS::Google::Project
+
+        ##
+        # Fetches the representation of an existing Project
+        #
+        # @param [String] identity Project identity
+        # @return [Fog::DNS::Google::Project] Project resource
+        def get(identity)
+          if project = service.get_project(identity).body
+            new(project)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

lib/fog/google/models/dns/record.rb

@@ -0,0 +1,87 @@
+require 'fog/core/model'
+
+module Fog
+  module DNS
+    class Google
+      ##
+      # Resource Record Sets resource
+      #
+      # @see https://cloud.google.com/dns/api/v1beta1/resourceRecordSets
+      class Record < Fog::Model
+        identity :name
+
+        attribute :kind
+        attribute :type
+        attribute :ttl
+        attribute :rrdatas
+
+        ##
+        # Deletes a previously created Resource Record Sets resource
+        #
+        # @return [Boolean] If the Resource Record Set has been deleted
+        def destroy
+          requires :name, :type, :ttl, :rrdatas
+
+          service.create_change(self.zone.id, [], [resource_record_set_format])
+          true
+        end
+
+        ##
+        # Modifies a previously created Resource Record Sets resource
+        #
+        # @return [Fog::DNS::Google::Record] Resource Record Sets resource
+        def modify(new_attributes)
+          requires :name, :type, :ttl, :rrdatas
+
+          deletions = resource_record_set_format
+          merge_attributes(new_attributes)
+
+          service.create_change(self.zone.id, [resource_record_set_format], [deletions])
+          self
+        end
+
+        ##
+        # Creates a new Resource Record Sets resource
+        #
+        # @return [Fog::DNS::Google::Record] Resource Record Sets resource
+        def save
+          requires :name, :type, :ttl, :rrdatas
+
+          service.create_change(self.zone.id, [resource_record_set_format], [])
+          self
+        end
+
+        ##
+        # Returns the Managed Zone of the Resource Record Sets resource
+        #
+        # @return [Fog::DNS::Google::Zone] Managed Zone of the Resource Record Sets resource
+        def zone
+          @zone
+        end
+
+        private
+
+        ##
+        # Assigns the Managed Zone of the Resource Record Sets resource
+        #
+        # @param [Fog::DNS::Google::Zone] new_zone Managed Zone of the Resource Record Sets resource
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+        ##
+        # Resource Record Sets resource representation
+        #
+        def resource_record_set_format
+          {
+            'kind' => 'dns#resourceRecordSet',
+            'name' => self.name,
+            'type' => self.type,
+            'ttl'  => self.ttl,
+            'rrdatas' => self.rrdatas,
+          }
+        end
+      end
+    end
+  end
+end

lib/fog/google/models/dns/records.rb

@@ -0,0 +1,37 @@
+require 'fog/core/collection'
+require 'fog/google/models/dns/record'
+
+module Fog
+  module DNS
+    class Google
+      class Records < Fog::Collection
+        model Fog::DNS::Google::Record
+
+        attribute :zone
+
+        ##
+        # Enumerates Resource Record Sets that have been created but not yet deleted
+        #
+        # @return [Array<Fog::DNS::Google::Record>] List of Resource Record Sets resources
+        def all
+          requires :zone
+
+          data = service.list_resource_record_sets(zone.identity).body['rrsets'] || []
+          load(data)
+        rescue Fog::Errors::NotFound
+          []
+        end
+
+        ##
+        # Creates a new instance of a Resource Record Set
+        #
+        # @return [Fog::DNS::Google::Record] Resource Record Set resource
+        def new(attributes = {})
+          requires :zone
+
+          super({ :zone => zone }.merge!(attributes))
+        end
+      end
+    end
+  end
+end

lib/fog/google/models/dns/zone.rb

@@ -0,0 +1,74 @@
+require 'fog/core/model'
+
+module Fog
+  module DNS
+    class Google
+      ##
+      # Managed Zone resource
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/managedZones
+      class Zone < Fog::Model
+        identity :id
+
+        attribute :creation_time, :aliases => 'creationTime'
+        attribute :description
+        attribute :domain, :aliases => 'dnsName'
+        attribute :kind
+        attribute :name
+        attribute :nameservers, :aliases => 'nameServers'
+
+        ##
+        # Enumerates the list of Changes for the Managed Zone
+        #
+        # @return Array<Fog::DNS::Google::Change>] List of Changes for the Managed Zone
+        def changes
+          @changes = begin
+            Fog::DNS::Google::Changes.new(
+              :service => service,
+              :zone => self
+            )
+          end
+        end
+
+        ##
+        # Deletes a previously created Managed Zone
+        #
+        # @return [Boolean] If the Managed Zone has been deleted
+        def destroy
+          requires :identity
+
+          service.delete_managed_zone(self.identity)
+          true
+        end
+
+        ##
+        # Enumerates the list of Resource Record Sets for the Managed Zone
+        #
+        # @return Array<Fog::DNS::Google::Record>] List of Resource Record Sets for the Managed Zone
+        def records
+          @records = begin
+            Fog::DNS::Google::Records.new(
+              :service => service,
+              :zone => self
+            )
+          end
+        end
+
+        ##
+        # Creates a new Managed Zone
+        #
+        # @return [Fog::DNS::Google::Zone] Managed Zone
+        # @raise [Fog::Errors::Error] If Managed Zone already exists
+        def save
+          requires :name, :domain, :description
+
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+
+          data = service.create_managed_zone(self.name, self.domain, self.description)
+          merge_attributes(data.body)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/google/models/dns/zone'
+
+module Fog
+  module DNS
+    class Google
+      class Zones < Fog::Collection
+        model Fog::DNS::Google::Zone
+
+        ##
+        # Enumerates Managed Zones that have been created but not yet deleted
+        #
+        # @return [Array<Fog::DNS::Google::Zone>] List of Managed Zone resources
+        def all
+          data = service.list_managed_zones.body['managedZones'] || []
+          load(data)
+        end
+
+        ##
+        # Fetches the representation of an existing Managed Zone
+        #
+        # @param [String] name_or_id Managed Zone name or identity
+        # @return [Fog::DNS::Google::Zone] Managed Zone resource
+        def get(name_or_id)
+          if zone = service.get_managed_zone(name_or_id).body
+            new(zone)
+          end
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

lib/fog/google/requests/dns/create_change.rb

@@ -0,0 +1,64 @@
+module Fog
+  module DNS
+    class Google
+      ##
+      # Atomically updates a ResourceRecordSet collection.
+      #
+      # @see https://cloud.google.com/dns/api/v1beta1/changes/create
+      class Real
+        def create_change(zone_name_or_id, additions = [], deletions = [])
+          api_method = @dns.changes.create
+          parameters = {
+            'project' => @project,
+            'managedZone' => zone_name_or_id,
+          }
+
+          body = {
+            'additions' => additions,
+            'deletions' => deletions,
+          }
+
+          request(api_method, parameters, body)
+        end
+      end
+
+      class Mock
+        def create_change(zone_name_or_id, additions = [], deletions = [])
+          if self.data[:managed_zones].has_key?(zone_name_or_id)
+            zone = self.data[:managed_zones][zone_name_or_id]
+          else
+            zone = self.data[:managed_zones].values.find { |zone| zone['name'] = zone_name_or_id }
+          end
+
+          unless zone
+            raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{zone_name_or_id}' does not exist."
+          end
+
+          deletions.each do |del|
+            rrset = self.data[:resource_record_sets][zone['id']].reject! { |r| r['name'] == del['name'] && r['type'] == del['type'] }
+            unless rrset
+              raise Fog::Errors::NotFound, "The 'entity.change.deletions[0]' resource named '#{del['name']} ('#{del['type']})' does not exist."
+            end
+          end
+
+          additions.each do |add|
+            self.data[:resource_record_sets][zone['id']] << add
+          end
+
+          id = self.data[:changes][zone['id']].max_by { |c| c['id'] }['id']
+          data = {
+            'kind' => 'dns#change',
+            'id' => (id.to_i + 1).to_s,
+            'startTime' => DateTime.now.strftime('%FT%T.%LZ'),
+            'status' => 'done',
+            'additions' => additions,
+            'deletions' => deletions,
+          }
+          self.data[:changes][zone['id']] << data
+
+          build_excon_response(data)
+        end
+      end
+    end
+  end
+end

lib/fog/google/requests/dns/create_managed_zone.rb

@@ -2,48 +2,81 @@ require 'date'
 module Fog
   module DNS
     class Google
-
-      class Mock
-        def create_managed_zone(zone_name, dns_name, descr='')
-          id = Fog::Mock.random_numbers(19).to_s
-          object = {
-            "kind" => "dns#managedZone",
-            "id" => id,
-            "creationTime" => DateTime.now.strftime('%FT%T.%LZ'),
-            "name" => zone_name,
-            "dnsName" => dns_name,
-            "description" => descr,
-	    "nameServers" => [
-	      "ns-cloud-e1.googledomains.com.",
-	      "ns-cloud-e2.googledomains.com.",
-	      "ns-cloud-e3.googledomains.com.",
-	      "ns-cloud-e4.googledomains.com.",
-	    ],
-	  }
-          self.data[:managed_zones][:by_name][zone_name] = object
-          self.data[:managed_zones][:by_id][id] = object
-
-          build_excon_response(object)
-        end
-
-      end
-
+      ##
+      # Creates a new Managed Zone.
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/managedZones/create
       class Real
-        def create_managed_zone(zone_name, dns_name, descr='')
+        def create_managed_zone(name, dns_name, description)
           api_method = @dns.managed_zones.create
           parameters = {
             'project' => @project,
           }
 
           body_object = {
-	    'name' => zone_name,
-	    'dnsName' => dns_name,
-	  }
-	  body_object['description'] = descr unless descr.nil?
+            'name' => name,
+            'dnsName' => dns_name,
+            'description' => description,
+          }
 
           request(api_method, parameters, body_object)
         end
       end
+
+      class Mock
+        def create_managed_zone(name, dns_name, description)
+          id = Fog::Mock.random_numbers(19).to_s
+          data = {
+            'kind' => 'dns#managedZone',
+            'id' => id,
+            'creationTime' => DateTime.now.strftime('%FT%T.%LZ'),
+            'name' => name,
+            'dnsName' => dns_name,
+            'description' => description,
+            'nameServers' => [
+              'ns-cloud-e1.googledomains.com.',
+              'ns-cloud-e2.googledomains.com.',
+              'ns-cloud-e3.googledomains.com.',
+              'ns-cloud-e4.googledomains.com.',
+            ],
+          }
+          self.data[:managed_zones][id] = data
+          self.data[:resource_record_sets][id] = [
+            {
+              'kind' => 'dns#resourceRecordSet',
+              'name' => dns_name,
+              'type' => 'NS',
+              'ttl' => 21600,
+              'rrdatas' => [
+                'ns-cloud-c1.googledomains.com.',
+                'ns-cloud-c2.googledomains.com.',
+                'ns-cloud-c3.googledomains.com.',
+                'ns-cloud-c4.googledomains.com.',
+              ]
+            },
+            {
+              'kind' => 'dns#resourceRecordSet',
+              'name' => dns_name,
+              'type' => 'SOA',
+              'ttl' => 21600,
+              'rrdatas' => [
+                'ns-cloud-c1.googledomains.com. dns-admin.google.com. 0 21600 3600 1209600 300',
+              ]
+            },
+          ]
+          self.data[:changes][id] = [
+            {
+              'kind' => 'dns#change',
+              'id' => '0',
+              'startTime' => DateTime.now.strftime('%FT%T.%LZ'),
+              'status' => 'done',
+              'additions' => self.data[:resource_record_sets][id],
+            },
+          ]
+
+          build_excon_response(data)
+        end
+      end
     end
   end
 end

lib/fog/google/requests/dns/delete_managed_zone.rb

@@ -1,39 +1,35 @@
 module Fog
   module DNS
     class Google
-
-      class Mock
-        def delete_managed_zone(zone_name_or_id)
-	  if self.data[:managed_zones][:by_name].has_key?(zone_name_or_id)
-            zone_name = zone_name_or_id
-            zone = self.data[:managed_zones][:by_name][zone_name]
-	    zone_id = zone['id']
-	  elsif self.data[:managed_zones][:by_id].has_key?(zone_name_or_id)
-            zone_id = zone_name_or_id
-            zone = self.data[:managed_zones][:by_name][zone_id]
-	    zone_name = zone['name']
-	  else
-	    raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{zone_name_or_id}' does not exist."
-	  end
-	  self.data[:managed_zones][:by_name].delete(zone_name)
-	  self.data[:managed_zones][:by_id].delete(zone_id)
-
-          build_excon_response(nil)
-        end
-
-      end
-
+      ##
+      # Deletes a previously created Managed Zone.
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/managedZones/delete
       class Real
-        def delete_managed_zone(zone_name_or_id)
+        def delete_managed_zone(name_or_id)
           api_method = @dns.managed_zones.delete
           parameters = {
             'project' => @project,
-	    'managedZone' => zone_name_or_id,
+            'managedZone' => name_or_id,
           }
 
           request(api_method, parameters)
         end
       end
+
+      class Mock
+        def delete_managed_zone(name_or_id)
+          if self.data[:managed_zones].has_key?(name_or_id)
+            self.data[:managed_zones].delete(name_or_id)
+          elsif zone = self.data[:managed_zones].values.find { |zone| zone['name'] = name_or_id }
+            self.data[:managed_zones].delete(zone['id'])
+          else
+            raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{name_or_id}' does not exist."
+          end
+
+          build_excon_response(nil)
+        end
+      end
     end
   end
 end

lib/fog/google/requests/dns/get_change.rb

@@ -0,0 +1,42 @@
+module Fog
+  module DNS
+    class Google
+      ##
+      # Fetches the representation of an existing Change.
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/changes/get
+      class Real
+        def get_change(zone_name_or_id, identity)
+          api_method = @dns.changes.get
+          parameters = {
+            'project' => @project,
+            'managedZone' => zone_name_or_id,
+            'changeId' => identity,
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def get_change(zone_name_or_id, identity)
+          if self.data[:managed_zones].has_key?(zone_name_or_id)
+            zone = self.data[:managed_zones][zone_name_or_id]
+          else
+            zone = self.data[:managed_zones].values.find { |zone| zone['name'] = zone_name_or_id }
+          end
+
+          unless zone
+            raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{zone_name_or_id}' does not exist."
+          end
+
+          unless data = self.data[:changes][zone['id']].find { |c| c['id'] == identity }
+            raise Fog::Errors::NotFound, "The 'parameters.changeId' resource named '#{identity}' does not exist."
+          end
+
+          build_excon_response(data)
+        end
+      end
+    end
+  end
+end

lib/fog/google/requests/dns/get_managed_zone.rb

@@ -1,31 +1,37 @@
 module Fog
   module DNS
     class Google
-
-      class Mock
-        def get_managed_zone(zone_name_or_id)
-	  if self.data[:managed_zones][:by_name].has_key?(zone_name_or_id)
-            build_excon_response(self.data[:managed_zones][:by_name][zone_name_or_id])
-	  elsif self.data[:managed_zones][:by_id].has_key?(zone_name_or_id)
-            build_excon_response(self.data[:managed_zones][:by_id][zone_name_or_id])
-	  else
-	    raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{zone_name_or_id}' does not exist."
-	  end
-        end
-
-      end
-
+      ##
+      # Fetches the representation of an existing Managed Zone.
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/managedZones/get
       class Real
-        def get_managed_zone(zone_name_or_id)
+        def get_managed_zone(name_or_id)
           api_method = @dns.managed_zones.get
           parameters = {
             'project' => @project,
-	    'managedZone' => zone_name_or_id,
+            'managedZone' => name_or_id,
           }
 
           request(api_method, parameters)
         end
       end
+
+      class Mock
+        def get_managed_zone(name_or_id)
+          if self.data[:managed_zones].has_key?(name_or_id)
+            data = self.data[:managed_zones][name_or_id]
+          else
+            data = self.data[:managed_zones].values.find { |zone| zone['name'] = name_or_id }
+          end
+
+          unless data
+            raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{name_or_id}' does not exist."
+          end
+
+          build_excon_response(data)
+        end
+      end
     end
   end
 end

lib/fog/google/requests/dns/get_project.rb

@@ -0,0 +1,42 @@
+module Fog
+  module DNS
+    class Google
+      ##
+      # Fetches the representation of an existing Project. Use this method to look up the limits on the number of
+      # resources that are associated with your project.
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/projects/get
+      class Real
+        def get_project(identity)
+          api_method = @dns.projects.get
+          parameters = {
+            :project => identity,
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def get_project(identity)
+          body = {
+            'kind' => 'dns#project',
+            'number' => Fog::Mock.random_numbers(12).to_s,
+            'id' => identity,
+            'quota' => {
+              'kind' => 'dns#quota',
+              'managedZones' => 100,
+              'rrsetsPerManagedZone' => 10000,
+              'rrsetAdditionsPerChange' => 100,
+              'rrsetDeletionsPerChange'=>100,
+              'totalRrdataSizePerChange' => 10000,
+              'resourceRecordsPerRrset' => 20,
+            }
+          }
+
+          build_excon_response(body)
+        end
+      end
+    end
+  end
+end

lib/fog/google/requests/dns/list_changes.rb

@@ -0,0 +1,41 @@
+module Fog
+  module DNS
+    class Google
+      ##
+      # Enumerates the list of Changes.
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/changes/list
+      class Real
+        def list_changes(zone_name_or_id)
+          api_method = @dns.changes.list
+          parameters = {
+            'project' => @project,
+            'managedZone' => zone_name_or_id,
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def list_changes(zone_name_or_id)
+          if self.data[:managed_zones].has_key?(zone_name_or_id)
+            zone = self.data[:managed_zones][zone_name_or_id]
+          else
+            zone = self.data[:managed_zones].values.find { |zone| zone['name'] == zone_name_or_id }
+          end
+
+          unless zone
+            raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{zone_name_or_id}' does not exist."
+          end
+
+          body = {
+            'kind' => 'dns#changesListResponse',
+            'changes' => self.data[:changes][zone['id']],
+          }
+          build_excon_response(body)
+        end
+      end
+    end
+  end
+end

lib/fog/google/requests/dns/list_managed_zones.rb

@@ -1,16 +1,10 @@
 module Fog
   module DNS
     class Google
-      class Mock
-        def list_managed_zones()
-          zones = self.data[:managed_zones][:by_id].values
-          build_excon_response({
-	    "kind" => "dns#managedZonesListResponse",
-	    "managedZones" => zones,
-          })
-        end
-      end
-
+      ##
+      # Enumerates Managed Zones that have been created but not yet deleted.
+      #
+      # @see hhttps://developers.google.com/cloud-dns/api/v1beta1/managedZones/list
       class Real
         def list_managed_zones()
           api_method = @dns.managed_zones.list
@@ -21,6 +15,17 @@ module Fog
           request(api_method, parameters)
         end
       end
+
+      class Mock
+        def list_managed_zones()
+          body = {
+            'kind' => 'dns#managedZonesListResponse',
+            'managedZones' => self.data[:managed_zones].values,
+          }
+
+          build_excon_response(body)
+        end
+      end
     end
   end
 end

lib/fog/google/requests/dns/list_resource_record_sets.rb

@@ -0,0 +1,41 @@
+module Fog
+  module DNS
+    class Google
+      ##
+      # Enumerates Resource Record Sets that have been created but not yet deleted.
+      #
+      # @see https://developers.google.com/cloud-dns/api/v1beta1/resourceRecordSets/list
+      class Real
+        def list_resource_record_sets(zone_name_or_id)
+          api_method = @dns.resource_record_sets.list
+          parameters = {
+            'project' => @project,
+            'managedZone' => zone_name_or_id,
+          }
+
+          request(api_method, parameters)
+        end
+      end
+
+      class Mock
+        def list_resource_record_sets(zone_name_or_id)
+          if self.data[:managed_zones].has_key?(zone_name_or_id)
+            zone = self.data[:managed_zones][zone_name_or_id]
+          else
+            zone = self.data[:managed_zones].values.find { |zone| zone['name'] = zone_name_or_id }
+          end
+
+          unless zone
+            raise Fog::Errors::NotFound, "The 'parameters.managedZone' resource named '#{zone_name_or_id}' does not exist."
+          end
+
+          body = {
+            'kind' => 'dns#resourceRecordSetsListResponse',
+            'rrsets' => self.data[:resource_record_sets][zone['id']],
+          }
+          build_excon_response(body)
+        end
+      end
+    end
+  end
+end

tests/google/models/dns/change_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::DNS[:google] | change model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+  @zone = @dns.zones.create(
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  )
+
+  tests('success') do
+
+    tests('#pending?').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).get('0').pending? == false
+    end
+
+    tests('#ready?').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).get('0').ready? == true
+    end
+
+  end
+
+  @zone.destroy
+end

tests/google/models/dns/changes_tests.rb

@@ -0,0 +1,36 @@
+Shindo.tests('Fog::DNS[:google] | changes model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+  @zone = @dns.zones.create(
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  )
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).all
+    end
+
+    tests('#get').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).get('0')
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get').returns(nil) do
+      @dns.changes(:service => @dns, :zone => @zone).get(Fog::Mock.random_letters_and_numbers(16))
+    end
+
+  end
+
+  @zone.destroy
+end

tests/google/models/dns/projects_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests('Fog::DNS[:google] | projects model', ['google']) do
+  @projects = Fog::DNS[:google].projects
+
+  tests('success') do
+
+    tests('#get').succeeds do
+      @projects.get(Fog::DNS[:google].project)
+    end
+
+  end
+
+end

tests/google/models/dns/record_tests.rb

@@ -0,0 +1,38 @@
+Shindo.tests('Fog::DNS[:google] | record model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+  params = {
+    :name => "#{Fog::Mock.random_letters(16)}.#{ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain}",
+    :type => 'A',
+    :ttl => 3600,
+    :rrdatas => ['192.168.1.1'],
+  }
+
+  tests('success') do
+    @zone = @dns.zones.create(
+      :name => Fog::Mock.random_letters(8),
+      :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+      :description => 'Fog test domain'
+    )
+
+    tests('#save').succeeds do
+      @record = @zone.records.create(params)
+    end
+
+    tests('#modify').succeeds do
+      @record.modify({ :ttl => 2600 })
+    end
+
+    tests('#destroy').succeeds do
+      @record.destroy
+    end
+
+    @zone.destroy
+  end
+
+end

tests/google/models/dns/records_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::DNS[:google] | records model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+
+  tests('success') do
+    @zone = @dns.zones.create(
+      :name => Fog::Mock.random_letters(16),
+      :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+      :description => 'Fog test domain'
+    )
+
+    tests('#all').succeeds do
+      @dns.records(:service => @dns, :zone => @zone).all
+    end
+
+    @zone.destroy
+  end
+
+end

tests/google/models/dns/zone_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::DNS[:google] | zone model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  params = {
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  }
+  model_tests(Fog::DNS[:google].zones, params)
+
+  tests('success') do
+    @zone = Fog::DNS[:google].zones.create(params)
+
+    tests('#changes').succeeds do
+      @zone.changes
+    end
+
+    tests('#records').succeeds do
+      @zone.records
+    end
+
+    @zone.destroy
+  end
+end

tests/google/models/dns/zones_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::DNS[:google] | zones model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  params = {
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  }
+  collection_tests(Fog::DNS[:google].zones, params)
+end

tests/google/requests/dns/change_tests.rb

@@ -0,0 +1,86 @@
+Shindo.tests('Fog::DNS[:google] | change requests', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+
+  @get_change_format = {
+    'kind' => String,
+    'id' => String,
+    'startTime' => String,
+    'status' => String,
+    'additions' => Fog::Nullable::Array,
+    'deletions' => Fog::Nullable::Array,
+  }
+
+  @list_changes_format = {
+    'kind' => String,
+    'changes' => [@get_change_format],
+  }
+
+  @zone = @dns.zones.create(
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  )
+
+  rrset_resource = {
+    :name => "#{Fog::Mock.random_letters(16)}.#{ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain}",
+    :type => 'A',
+    :ttl => 3600,
+    :rrdatas => ['192.168.1.1'],
+  }
+
+  tests('success') do
+
+    tests('#create_change.additions').formats(@get_change_format) do
+      @dns.create_change(@zone.identity, [rrset_resource], []).body
+    end
+
+    tests('#create_change.additions.deletions').formats(@get_change_format) do
+      @dns.create_change(@zone.identity, [rrset_resource], [rrset_resource]).body
+    end
+
+    tests('#create_change.deletions').formats(@get_change_format) do
+      @dns.create_change(@zone.identity, [], [rrset_resource]).body
+    end
+
+    tests('#list_changes').formats(@list_changes_format) do
+      @dns.list_changes(@zone.identity).body
+    end
+
+    tests('#get_change').formats(@get_change_format) do
+      @dns.get_change(@zone.identity, '0').body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#list_changes').raises(Fog::Errors::NotFound) do
+      @dns.list_changes(generate_unique_domain).body
+    end
+
+    tests('#get_change').raises(Fog::Errors::NotFound) do
+      @dns.get_change(generate_unique_domain, Fog::Mock.random_letters_and_numbers(16)).body
+    end
+
+    tests('#get_change').raises(Fog::Errors::NotFound) do
+      @dns.get_change(@zone.identity, Fog::Mock.random_letters_and_numbers(16)).body
+    end
+
+    tests('#create_change').raises(Fog::Errors::NotFound) do
+      @dns.create_change(generate_unique_domain, [], [rrset_resource]).body
+    end
+
+    tests('#create_change').raises(Fog::Errors::NotFound) do
+      @dns.create_change(@zone.identity, [], [rrset_resource]).body
+    end
+
+  end
+
+  @zone.destroy
+end

tests/google/requests/dns/managed_zone_tests.rb

@@ -33,7 +33,7 @@ Shindo.tests('Fog::DNS[:google] | managed_zone requests', ['google']) do
 
     tests("#create_managed_zone").data_matches_schema(
         @managed_zone_schema, {:allow_extra_keys => false}) do
-      @google.create_managed_zone(zone_name, zone_dns_name).body
+      @google.create_managed_zone(zone_name, zone_dns_name, 'Fog test domain').body
     end
 
     tests("#get_managed_zone") do

tests/google/requests/dns/project_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Fog::DNS[:google] | project requests', ['google']) do
+  @dns = Fog::DNS[:google]
+
+  @project_quota_format = {
+    'kind' => String,
+    'managedZones' => Integer,
+    'rrsetsPerManagedZone' => Integer,
+    'rrsetAdditionsPerChange' => Integer,
+    'rrsetDeletionsPerChange'=>Integer,
+    'totalRrdataSizePerChange' => Integer,
+    'resourceRecordsPerRrset' => Integer,
+  }
+
+  @get_project_format = {
+    'kind' => String,
+    'number' => String,
+    'id' => String,
+    'quota' => @project_quota_format,
+  }
+
+  tests('success') do
+
+    tests('#get_project').formats(@get_project_format) do
+      @dns.get_project(@dns.project).body
+    end
+
+  end
+
+end

tests/google/requests/dns/record_tests.rb

@@ -0,0 +1,45 @@
+Shindo.tests('Fog::DNS[:google] | record requests', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+
+  @get_resource_record_sets_format = {
+    'kind' => String,
+    'name' => String,
+    'type' => String,
+    'ttl' => Integer,
+    'rrdatas' => Array,
+  }
+
+  @list_resource_record_sets_format = {
+    'kind' => String,
+    'rrsets' => [@get_resource_record_sets_format],
+  }
+
+  tests('success') do
+    @zone = @dns.zones.create(
+      :name => Fog::Mock.random_letters(16),
+      :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+      :description => 'Fog test domain'
+    )
+
+    tests('#list_resource_record_sets').formats(@list_resource_record_sets_format) do
+      @dns.list_resource_record_sets(@zone.identity).body
+    end
+
+    @zone.destroy
+  end
+
+  tests('failure') do
+
+    tests('#list_resource_record_sets').raises(Fog::Errors::NotFound) do
+      @dns.list_resource_record_sets(generate_unique_domain).body
+    end
+
+  end
+
+end