fog-google 0.6.0 → 1.0.0

data/lib/fog/compute/google/requests/list_addresses.rb

@@ -2,20 +2,23 @@ module Fog
   module Compute
     class Google
       class Mock
-        def list_addresses(_region_name)
+        def list_addresses(_region_name, _opts = {})
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_addresses(region_name)
-          api_method = @compute.addresses.list
-          parameters = {
-            "project" => @project,
-            "region" => region_name
-          }
-
-          request(api_method, parameters)
+        # List address resources in the specified project
+        # @see https://cloud.google.com/compute/docs/reference/latest/addresses/list
+        def list_addresses(region_name, filter: nil, max_results: nil,
+                           order_by: nil, page_token: nil)
+          @compute.list_addresses(
+            @project, region_name,
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_addresses.rb

@@ -8,14 +8,12 @@ module Fog
       end
 
       class Real
+        # Retrieves an aggregated list of addresses
+        # https://cloud.google.com/compute/docs/reference/latest/addresses/aggregatedList
+        # @param options [Hash] Optional hash of options
+        # @option options [String] :filter Filter expression for filtering listed resources
         def list_aggregated_addresses(options = {})
-          api_method = @compute.addresses.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-          parameters["filter"] = options[:filter] if options[:filter]
-
-          request(api_method, parameters)
+          @compute.list_aggregated_addresses(@project, options)
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_disk_types.rb

@@ -2,35 +2,19 @@ module Fog
   module Compute
     class Google
       class Mock
-        def list_aggregated_disk_types(options = {})
-          disk_types_items = {}
-          if options[:filter]
-            disk_type = options[:filter].gsub(/name eq \.\*/, "")
-            data[:zones].keys.each do |zone|
-              disk_types = list_disk_types(zone).body["items"].select { |dt| dt["name"] == disk_type } || []
-              disk_types_items["zones/#{zone}"] = { "diskTypes" => disk_types } unless disk_types.empty?
-            end
-          else
-            data[:zones].keys.each do |zone|
-              disk_types = list_disk_types(zone).body["items"]
-              disk_types_items["zones/#{zone}"] = { "diskTypes" => disk_types }
-            end
-          end
-          build_excon_response("kind" => 'compute#diskTypeAggregatedList',
-                               "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/aggregated/diskTypes",
-                               "items" => disk_types_items)
+        def list_aggregated_disk_types(_options = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_aggregated_disk_types(options = {})
-          api_method = @compute.disk_types.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-          parameters["filter"] = options[:filter] if options[:filter]
-
-          request(api_method, parameters)
+        def list_aggregated_disk_types(filter: nil, max_results: nil,
+                                       order_by: nil, page_token: nil)
+          @compute.list_aggregated_disk_types(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_disks.rb

@@ -2,34 +2,27 @@ module Fog
   module Compute
     class Google
       class Mock
-        def list_aggregated_disks(options = {})
-          # Create a Hash of unique zones from the disks Array previously filled when disks are created
-          zones = Hash[data[:disks].values.map { |disk| ["zones/#{disk['zone'].split('/')[-1]}", { "disks" => [] }] }]
-          if options[:filter]
-            # Look up for the disk name
-            disk = data[:disks][options[:filter].gsub(/name eq \.\*/, "")]
-            # Fill the zones Hash with the disk (if it's found)
-            zones["zones/#{disk['zone'].split('/')[-1]}"]["disks"].concat([disk]) if disk
-          else
-            # Fill the zones Hash with the disks attached to each zone
-            data[:disks].values.each { |disk| zones["zones/#{disk['zone'].split('/')[-1]}"]["disks"].concat([disk]) }
-          end
-          build_excon_response("kind" => "compute#diskAggregatedList",
-                               "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/aggregated/disks",
-                               "id" => "projects/#{@project}/aggregated/disks",
-                               "items" => zones)
+        def list_aggregated_disks(_options = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_aggregated_disks(options = {})
-          api_method = @compute.disks.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-          parameters["filter"] = options[:filter] if options[:filter]
-
-          request(api_method, parameters)
+        # Retrieves an aggregated list of disks
+        # https://cloud.google.com/compute/docs/reference/latest/disks/aggregatedList
+        #
+        # @param options [Hash] Optional hash of options
+        # @option options [String] :filter Filter expression for filtering listed resources
+        # @option options [String] :max_results
+        # @option options [String] :order_by
+        # @option options [String] :page_token
+        def list_aggregated_disks(filter: nil, max_results: nil,
+                                  order_by: nil, page_token: nil)
+          @compute.list_aggregated_disk(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_forwarding_rules.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_forwarding_rules(_opts = {})
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        def list_aggregated_forwarding_rules(filter: nil, max_results: nil,
+                                             order_by: nil, page_token: nil)
+          @compute.list_aggregated_forwarding_rules(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/list_aggregated_instance_groups.rb

@@ -9,13 +9,8 @@ module Fog
 
       class Real
         def list_aggregated_instance_groups(options = {})
-          api_method = @compute.instance_groups.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-          parameters["filter"] = options[:filter] if options[:filter]
-
-          request(api_method, parameters)
+          @compute.list_aggregated_instance_groups(@project,
+                                                   :filter => options[:filter])
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_machine_types.rb

@@ -2,19 +2,19 @@ module Fog
   module Compute
     class Google
       class Mock
-        def list_aggregated_machine_types
+        def list_aggregated_machine_types(_opts = {})
           Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_aggregated_machine_types
-          api_method = @compute.machine_types.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-
-          request(api_method, parameters)
+        def list_aggregated_machine_types(filter: nil, max_results: nil,
+                                          page_token: nil, order_by: nil)
+          @compute.list_aggregated_machine_types(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :page_token => page_token, :order_by => order_by
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_servers.rb

@@ -2,34 +2,19 @@ module Fog
   module Compute
     class Google
       class Mock
-        def list_aggregated_servers(options = {})
-          # Create a Hash of unique zones from the servers Array previously filled when servers are created
-          zones = Hash[data[:servers].values.map { |server| ["zones/#{server['zone'].split('/')[-1]}", { "instances" => [] }] }]
-          if options[:filter]
-            # Look up for the server name
-            server = data[:servers][options[:filter].gsub(/name eq \.\*/, "")]
-            # Fill the zones Hash with the server (if it's found)
-            zones["zones/#{server['zone'].split('/')[-1]}"]["instances"].concat([server]) if server
-          else
-            # Fill the zones Hash with the servers attached to each zone
-            data[:servers].values.each { |server| zones["zones/#{server['zone'].split('/')[-1]}"]["instances"].concat([server]) }
-          end
-          build_excon_response("kind" => "compute#instanceAggregatedList",
-                               "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/aggregated/instances",
-                               "id" => "projects/#{@project}/aggregated/instances",
-                               "items" => zones)
+        def list_aggregated_servers(_opts = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_aggregated_servers(options = {})
-          api_method = @compute.instances.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-          parameters["filter"] = options[:filter] if options[:filter]
-
-          request(api_method, parameters)
+        def list_aggregated_servers(filter: nil, max_results: nil,
+                                    order_by: nil, page_token: nil)
+          @compute.list_aggregated_instances(
+            @project,
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_subnetworks.rb

@@ -3,30 +3,30 @@ module Fog
     class Google
       class Mock
         def list_aggregated_subnetworks(_options = {})
-          subnetworks_by_region = data[:subnetworks].each_with_object({}) do |(_, subnetwork), memo|
-            region = subnetwork["region"].split("/")[-2..-1].join("/")
-            memo[region] ||= { "subnetworks" => [] }
-            memo[region]["subnetworks"].push subnetwork
-          end
-
-          build_excon_response("kind" => "compute#subnetworkAggregatedList",
-                               "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/aggregated/subnetworks",
-                               "items" => subnetworks_by_region)
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_aggregated_subnetworks(options = {})
-          api_method = @compute.subnetworks.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-
-          parameters["filter"] = options[:filter] if options[:filter]
-          parameters["maxResults"] = options[:max_results] if options[:max_results]
-          parameters["pageToken"] = options[:page_token] if options[:page_token]
-
-          request(api_method, parameters)
+        ##
+        # Retrieves an aggregated list of subnetworks across a project.
+        #
+        # @param filter [String] A filter expression for filtering listed resources.
+        # @param max_results [Fixnum] Max number of results to return
+        # @param order_by [String] Sorts list results by a certain order
+        # @param page_token [String] specifies a page token to use
+        # @return [Google::Apis::ComputeV1::SubnetworkAggregatedList] list result
+        #
+        # @see https://cloud.google.com/compute/docs/reference/latest/subnetworks/aggregatedList
+        def list_aggregated_subnetworks(filter: nil, max_results: nil,
+                                        page_token: nil, order_by: nil)
+          @compute.aggregated_subnetwork_list(
+            @project,
+            :filter => filter,
+            :max_results => max_results,
+            :page_token => page_token,
+            :order_by => order_by
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_target_instances.rb

@@ -1,37 +1,22 @@
 module Fog
   module Compute
     class Google
-      # XXX @ihmccreery added this mock to get the Shindo tests to pass.  I don't really understand how mocks are supposed to work; I'm in the process of moving
-      # all testing over to Minitest, but in the meantime, the Shindo tests need to pass.  This Mock should be considered with a *lot* of skepticism.
       class Mock
-        def list_aggregated_target_instances(options = {})
-          # Create a Hash of unique zones from the target_instances Array previously filled when target_instances are created
-          zones = Hash[data[:target_instances].values.map { |target_instance| ["zones/#{target_instance['zone'].split('/')[-1]}", { "targetInstances" => [] }] }]
-          if options[:filter]
-            # Look up for the target_instance name
-            target_instance = data[:target_instances][options[:filter].gsub(/name eq \.\*/, "")]
-            # Fill the zones Hash with the target_instance (if it's found)
-            zones["zones/#{target_instance['zone'].split('/')[-1]}"]["targetInstances"].concat([target_instance]) if target_instance
-          else
-            # Fill the zones Hash with the target_instances attached to each zone
-            data[:target_instances].values.each { |target_instance| zones["zones/#{target_instance['zone'].split('/')[-1]}"]["targetInstances"].concat([target_instance]) }
-          end
-          build_excon_response("kind" => "compute#targetInstanceAggregatedList",
-                               "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/aggregated/targetInstances",
-                               "id" => "projects/#{@project}/aggregated/targetInstances",
-                               "items" => zones)
+        def list_aggregated_target_instances(_options = {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_aggregated_target_instances(options = {})
-          api_method = @compute.target_instances.aggregated_list
-          parameters = {
-            "project" => @project
-          }
-          parameters["filter"] = options[:filter] if options[:filter]
-
-          request(api_method, parameters)
+        def list_aggregated_target_instances(filter: nil, max_results: nil,
+                                             order_by: nil, page_token: nil)
+          @compute.list_aggregated_target_instance(
+            @project,
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          )
         end
       end
     end

data/lib/fog/compute/google/requests/list_aggregated_target_pools.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def list_aggregated_target_pools(_opts = {})
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        def list_aggregated_target_pools(filter: nil, max_results: nil,
+                                         order_by: nil, page_token: nil)
+          @compute.list_aggregated_target_pools(
+            @project,
+            :filter => filter,
+            :max_results => max_results,
+            :order_by => order_by,
+            :page_token => page_token
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/list_backend_services.rb

@@ -14,12 +14,7 @@ module Fog
 
       class Real
         def list_backend_services
-          api_method = @compute.backend_services.list
-          parameters = {
-            "project" => @project
-          }
-
-          request(api_method, parameters)
+          @compute.list_backend_services(@project)
         end
       end
     end

data/lib/fog/compute/google/requests/list_disk_types.rb

@@ -2,41 +2,19 @@ module Fog
   module Compute
     class Google
       class Mock
-        def list_disk_types(zone)
-          build_excon_response("kind" => 'compute#diskTypeList',
-                               "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/diskTypes",
-                               "items" => [
-                                 {
-                                   "kind" => 'compute#diskType',
-                                   "creationTimestamp" => "2014-06-02T18:07:28.530Z",
-                                   "name" => "pd-standard",
-                                   "description" => "Standard Persistent Disk",
-                                   "validDiskSize" => "10GB-10TB",
-                                   "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}",
-                                   "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/diskTypes/pd-standard"
-                                 },
-                                 {
-                                   "kind" => 'compute#diskType',
-                                   "creationTimestamp" => "2014-06-02T18:07:28.529Z",
-                                   "name" => "pd-ssd",
-                                   "description" => "SSD Persistent Disk",
-                                   "validDiskSize" => "10GB-1TB",
-                                   "zone" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}",
-                                   "selfLink" => "https://www.googleapis.com/compute/#{api_version}/projects/#{@project}/zones/#{zone}/diskTypes/pd-ssd"
-                                 }
-                               ])
+        def list_disk_types(_zone, _options: {})
+          Fog::Mock.not_implemented
         end
       end
 
       class Real
-        def list_disk_types(zone)
-          api_method = @compute.disk_types.list
-          parameters = {
-            "project" => @project,
-            "zone"    => zone.split("/")[-1]
-          }
-
-          request(api_method, parameters)
+        def list_disk_types(zone, filter: nil, max_results: nil,
+                            order_by: nil, page_token: nil)
+          @compute.list_disk_types(
+            @project, zone.split("/")[-1],
+            :filter => filter, :max_results => max_results,
+            :order_by => order_by, :page_token => page_token
+          )
         end
       end
     end