fog-google 0.6.0 → 1.0.0

data/lib/fog/storage/google_json/requests/put_object_acl.rb

@@ -3,27 +3,29 @@ module Fog
     class GoogleJSON
       class Real
         # Change access control list for an Google Storage object
-        # https://cloud.google.com/storage/docs/json_api/v1/objectAccessControls/insert
         #
-        # ==== Parameters
-        # * bucket_name<~String> - name of bucket object is in
-        # * object_name<~String> - name of object to add ACL to
-        # * acl<~Hash> - ACL hash to add to bucket, see GCS documentation above
-        #    * entity
-        #    * role
+        # @param bucket_name [String] name of bucket object is in
+        # @param object_name [String] name of object to add ACL to
+        # @param acl [Hash] ACL hash to add to bucket, see GCS documentation.
+        #
+        # @see https://cloud.google.com/storage/docs/json_api/v1/objectAccessControls/insert
+        # @return [Google::Apis::StorageV1::ObjectAccessControl]
         def put_object_acl(bucket_name, object_name, acl)
           raise ArgumentError.new("bucket_name is required") unless bucket_name
           raise ArgumentError.new("object_name is required") unless object_name
           raise ArgumentError.new("acl is required") unless acl
 
-          api_method = @storage_json.object_access_controls.insert
-          parameters = {
-            "bucket" => bucket_name,
-            "object" => object_name
-          }
-          body_object = acl
+          acl_object = ::Google::Apis::StorageV1::ObjectAccessControl.new(acl)
+
+          @storage_json.insert_object_access_control(
+            bucket_name, object_name, acl_object
+          )
+        end
+      end
 
-          request(api_method, parameters, body_object = body_object)
+      class Mock
+        def put_object_acl(_bucket_name, _object_name, _acl)
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/storage/google_json/requests/put_object_url.rb

@@ -3,22 +3,16 @@ module Fog
     class GoogleJSON
       class Real
         # Get an expiring object url from Google Storage for putting an object
-        #
-        # ==== Parameters
-        # * bucket_name<~String> - Name of bucket containing object
-        # * object_name<~String> - Name of object to get expiring url for
-        # * expires<~Time> - An expiry time for this url
-        # * If you want a file to be public you should to add { 'x-goog-acl' => 'public-read' } to headers
-        #   And then call for example: curl -H "x-goog-acl:public-read" "signed url"
-        #
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~String> - url for object
-        #
-        # ==== See Also
         # https://cloud.google.com/storage/docs/access-control#Signed-URLs
         #
+        # @param bucket_name [String] Name of bucket containing object
+        # @param object_name [String] Name of object to get expiring url for
+        # @param expires [Time] Expiry time for this URL
+        # @param headers [Hash] Optional hash of headers to include
+        # @option options [String] "x-goog-acl" Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read'].
+        #     If you want a file to be public you should to add { 'x-goog-acl' => 'public-read' } to headers
+        #     and then call for example: curl -H "x-goog-acl:public-read" "signed url"
+        # @return [String] Expiring object https URL
         def put_object_url(bucket_name, object_name, expires, headers = {})
           raise ArgumentError.new("bucket_name is required") unless bucket_name
           raise ArgumentError.new("object_name is required") unless object_name

data/lib/fog/storage/google_json/utils.rb

@@ -19,9 +19,9 @@ module Fog
 
         def host_path_query(params, expires)
           params[:headers]["Date"] = expires.to_i
-          params[:path] = CGI.escape(params[:path]).gsub("%2F", "/")
+          params[:path] = URI.encode(params[:path]).gsub("%2F", "/")
           query = [params[:query]].compact
-          query << "GoogleAccessId=#{@client.authorization.issuer}"
+          query << "GoogleAccessId=#{@client.issuer}"
           query << "Signature=#{CGI.escape(signature(params))}"
           query << "Expires=#{params[:headers]['Date']}"
           "#{params[:host]}/#{params[:path]}?#{query.join('&')}"

data/lib/fog/storage/google_xml/models/file.rb

@@ -36,7 +36,7 @@ module Fog
         end
 
         def body
-          attributes[:body] ||= last_modified && (file = collection.get(identity)) ? file.body : ""
+          last_modified && (file = collection.get(identity)) ? attributes[:body] ||= file.body : attributes[:body] ||= ""
         end
 
         def body=(new_body)
@@ -62,7 +62,7 @@ module Fog
 
         remove_method :metadata
         def metadata
-          attributes.reject { |key, _value| !(key.to_s =~ /^x-goog-meta-/) }
+          attributes.reject { |key, _value| key.to_s =~ /^x-goog-meta-/ }
         end
 
         remove_method :metadata=

data/lib/fog/storage/google_xml/models/files.rb

@@ -59,8 +59,8 @@ module Fog
           data.headers.each do |k, v|
             file_data[k] = v
           end
-          file_data.merge!(:body => data.body,
-                           :key  => key)
+          file_data[:body] = data.body
+          file_data[:key] = key
           new(file_data)
         rescue Excon::Errors::NotFound
           nil

data/lib/fog/storage/google_xml/real.rb

@@ -51,7 +51,7 @@ DATA
             google_headers[key] = value if key[0..6] == "x-goog-"
           end
 
-          google_headers = google_headers.sort { |x, y| x[0] <=> y[0] }
+          google_headers = google_headers.sort_by { |a| a[0] }
           google_headers.each do |key, value|
             canonical_google_headers << "#{key}:#{value}\n"
           end

data/lib/fog/storage/google_xml/requests/copy_object.rb

@@ -43,7 +43,7 @@ module Fog
           if source_object && target_bucket
             response.status = 200
             target_object = source_object.dup
-            target_object.merge!("Name" => target_object_name)
+            target_object["Name"] = target_object_name
             target_bucket[:objects][target_object_name] = target_object
             response.body = {
               "ETag"          => target_object["ETag"],

data/lib/fog/storage/google_xml/requests/get_bucket.rb

@@ -53,11 +53,11 @@ module Fog
           name = /(\w+\.?)*/.match(bucket_name)
           if bucket_name == name.to_s
             if bucket = data[:buckets][bucket_name]
-              contents = bucket[:objects].values.sort { |x, y| x["Key"] <=> y["Key"] }.reject do |object|
+              contents = bucket[:objects].values.sort_by { |a| a["Key"] }.reject do |object|
                 (options["prefix"] && object["Key"][0...options["prefix"].length] != options["prefix"]) ||
-                (options["marker"] && object["Key"] <= options["marker"])
+                  (options["marker"] && object["Key"] <= options["marker"])
               end.map do |object|
-                data = object.reject { |key, _value| !%w(ETag Key).include?(key) }
+                data = object.select { |key, _value| %w(ETag Key).include?(key) }
                 data.merge!("LastModified" => Time.parse(object["Last-Modified"]),
                             "Owner"        => bucket["Owner"],
                             "Size"         => object["Content-Length"].to_i)

data/lib/fog/storage/google_xml/requests/get_object.rb

@@ -51,7 +51,7 @@ module Fog
       end
 
       class Mock
-        def get_object(bucket_name, object_name, options = {}, &block)
+        def get_object(bucket_name, object_name, options = {})
           raise ArgumentError.new("bucket_name is required") unless bucket_name
           raise ArgumentError.new("object_name is required") unless object_name
           response = Excon::Response.new
@@ -72,16 +72,16 @@ module Fog
                   response.headers[key] = value
                 end
               end
-              unless block_given?
-                response.body = object[:body]
-              else
+              if block_given?
                 data = StringIO.new(object[:body])
                 remaining = data.length
                 while remaining > 0
                   chunk = data.read([remaining, Excon::CHUNK_SIZE].min)
-                  block.call(chunk)
+                  yield(chunk)
                   remaining -= Excon::CHUNK_SIZE
                 end
+              else
+                response.body = object[:body]
               end
             end
           else

data/lib/fog/storage/google_xml/requests/get_service.rb

@@ -28,8 +28,8 @@ module Fog
           response = Excon::Response.new
           response.headers["Status"] = 200
           buckets = data[:buckets].values.map do |bucket|
-            bucket.reject do |key, _value|
-              !%w(CreationDate Name).include?(key)
+            bucket.select do |key, _value|
+              %w(CreationDate Name).include?(key)
             end
           end
           response.body = {

data/lib/fog/storage/google_xml/requests/put_bucket_acl.rb

@@ -40,7 +40,7 @@ DATA
             "<Scope type='#{scope['type']}'/>"
           else
             "<Scope type='#{scope['type']}'>" +
-              scope.to_a.select { |pair| pair[0] != "type" }.map { |pair| tag(pair[0], pair[1]) }.join("\n") +
+              scope.to_a.reject { |pair| pair[0] == "type" }.map { |pair| tag(pair[0], pair[1]) }.join("\n") +
               "</Scope>"
           end
         end

data/lib/fog/storage/google_xml/requests/put_object_acl.rb

@@ -12,7 +12,7 @@ module Fog
             "<Scope type='#{scope['type']}'/>"
           else
             "<Scope type='#{scope['type']}'>" +
-              scope.to_a.select { |pair| pair[0] != "type" }.map { |pair| tag(pair[0], pair[1]) }.join("\n") +
+              scope.to_a.reject { |pair| pair[0] == "type" }.map { |pair| tag(pair[0], pair[1]) }.join("\n") +
               "</Scope>"
           end
         end

data/test/helpers/client_helper.rb

@@ -3,33 +3,61 @@
 # client in use via the #client method to use.
 
 module ClientHelper
-  # Check to see if an operation is finished.
+  # Check to see if an compute operation is finished.
   #
-  # @param op [Excon::Response] the operation object returned from an api call
-  # @return [Boolean] true if the operation is no longer executing, false
+  # @param op [Google::Apis::ComputeV1::Operation] the operation object returned from an api call
+  # @return [Bolean] true if the operation is no longer executing, false
   #   otherwise
   def operation_finished?(op)
-    # TODO: support both zone and region operations
-    region = op[:body]["region"]
-    name = op[:body]["name"]
+    region = op.region
+    zone = op.zone
+    name = op.name
 
-    result = client.get_region_operation(region, name)
-    !%w(PENDING RUNNING).include?(result[:body]["status"])
+    if zone.nil?
+      result = client.get_region_operation(region, name)
+    else
+      result = client.get_zone_operation(zone, name)
+    end
+    !%w(PENDING RUNNING).include?(result.status)
   end
 
-  # Pause execution until an operation returned from a passed block is finished.
+  # Check to see if an SQL operation is finished.
+  #
+  # @param op [Google::Apis::SqladminV1beta4::Operation] the operation object
+  #   returned from an SQL Admin api call
+  # @return [Boolean] true if the operation is no longer executing, false
+  #   otherwise
+  def sql_operation_finished?(op)
+    result = client.get_operation(op.name)
+    !%w(PENDING RUNNING).include?(result.status)
+  end
+
+  # Pause execution until an operation (compute or sql) returned
+  # from a passed block is finished.
   #
   # @example Pause until server is provisioned
   #   @result = wait_until_complete { client.insert_server(name, zone, opts) }
-  # @yieldreturn [Excon::Response] the resulting operation object from a block.
-  # @return [Excon::Response] the final completed operation object
+  # @yieldreturn The resulting operation object from a block.
+  # @return the result of the operation
+
   def wait_until_complete
     result = yield
-    return result unless result[:body]["kind"] == "compute#operation"
 
-    # TODO: support both zone and region operations
-    region = result[:body]["region"]
-    Fog.wait_for { operation_finished?(result) }
-    client.get_region_operation(region, result[:body]["name"])
+    case result.kind
+    when "compute#operation"
+      region = result.region
+      zone = result.zone
+      Fog.wait_for { operation_finished?(result) }
+      if zone.nil?
+        client.get_region_operation(region, result.name)
+      else
+        client.get_zone_operation(zone, result.name)
+      end
+    when "sql#operation"
+      Fog.wait_for { sql_operation_finished?(result) }
+      client.get_operation(result.name)
+    else
+      result
+    end
   end
 end

data/test/helpers/integration_test_helper.rb

@@ -7,13 +7,19 @@ Fog.credential = :test
 
 # Helpers
 
-TEST_ZONE = "us-central1-f"
-TEST_REGION = "us-central1"
+TEST_ZONE = "us-central1-f".freeze
+TEST_REGION = "us-central1".freeze
 TEST_SIZE_GB = 10
-TEST_MACHINE_TYPE = "n1-standard-1"
+TEST_MACHINE_TYPE = "n1-standard-1".freeze
 # XXX This depends on a public image in gs://fog-test-bucket; there may be a better way to do this
 # The image was created like so: https://cloud.google.com/compute/docs/images#export_an_image_to_google_cloud_storage
-TEST_RAW_DISK_SOURCE = "http://storage.googleapis.com/fog-test-bucket/fog-test-raw-disk-source.image.tar.gz"
+TEST_RAW_DISK_SOURCE = "http://storage.googleapis.com/fog-test-bucket/fog-test-raw-disk-source.image.tar.gz".freeze
+
+TEST_SQL_TIER_FIRST = "D1".freeze
+TEST_SQL_REGION_FIRST = "us-central".freeze
+
+TEST_SQL_TIER_SECOND = "db-f1-micro".freeze
+TEST_SQL_REGION_SECOND = TEST_REGION
 
 class FogIntegrationTest < MiniTest::Test
   def namespaced_name

data/test/helpers/test_collection.rb

@@ -13,8 +13,8 @@ module TestCollection
     assert_includes @subject.all.map(&:identity), one.identity
     assert_includes @subject.all.map(&:identity), two.identity
 
-    assert_equal one.identity, @subject.get(one.identity).identity
-    assert_equal two.identity, @subject.get(two.identity).identity
+    assert_equal one.identity, @factory.get(one.identity).identity
+    assert_equal two.identity, @factory.get(two.identity).identity
 
     one.destroy
     two.destroy
@@ -24,7 +24,7 @@ module TestCollection
   end
 
   def test_get_returns_nil_if_resource_does_not_exist
-    assert_nil @subject.get("fog-test-fake-identity")
+    assert_nil @factory.get("fog-test-fake-identity")
   end
 
   def test_enumerable

data/test/integration/compute/addresses/addresses_shared.rb

@@ -0,0 +1,59 @@
+require "helpers/integration_test_helper"
+require "helpers/client_helper"
+require "securerandom"
+
+class TestComputeAddressShared < FogIntegrationTest
+  DEFAULT_REGION = "us-central1".freeze
+  ADDRESS_RESOURCE_PREFIX = "fog-test-address".freeze
+
+  include ClientHelper
+
+  def delete_test_resources
+    client = Fog::Compute::Google.new
+    addresses = client.addresses.all(:region => DEFAULT_REGION)
+    unless addresses.nil?
+      addresses
+        .select { |a| a.name.start_with?(ADDRESS_RESOURCE_PREFIX) }
+        .each do |a|
+          Fog.wait_for do
+            unless a.ready?
+              false
+            end
+
+            begin
+              client.delete_address(a.name, DEFAULT_REGION)
+            rescue ::Google::Apis::ClientError => e
+              if e.status_code == 400 || e.status_code == 404
+                return e.status_code == 404
+              end
+              raise e
+            else
+              true
+            end
+          end
+        end
+    end
+  end
+
+  attr_reader :client
+
+  def setup
+    @client = Fog::Compute::Google.new
+  end
+
+  def teardown
+    delete_test_resources
+  end
+
+  def new_address_name
+    "#{ADDRESS_RESOURCE_PREFIX}-#{SecureRandom.uuid}"
+  end
+
+  def some_address_name
+    # created lazily to speed tests up
+    @some_address ||= new_address_name.tap do |a|
+      result = @client.insert_address(a, DEFAULT_REGION)
+      Fog.wait_for { operation_finished?(result) }
+    end
+  end
+end

data/test/integration/compute/addresses/test_compute_address_models.rb

@@ -0,0 +1,105 @@
+require "helpers/integration_test_helper"
+require "integration/compute/addresses/addresses_shared"
+require "helpers/client_helper"
+require "securerandom"
+
+class TestComputeAddressModels < TestComputeAddressShared
+  def test_addresses_create
+    address_name = new_address_name
+    address = @client.addresses.create(
+      :name => address_name,
+      :region => DEFAULT_REGION
+    )
+    assert_equal(address_name, address.name, "address should have same name")
+    assert_nil(address.users, "new address should have no users")
+  end
+
+  def test_addresses_get
+    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
+
+    assert_equal(some_address_name, address.name, "address should have same name")
+  end
+
+  def test_addresses_get_address_by_ip
+    # Fetch a preexisting address to learn its IP
+    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
+
+    found = @client.addresses.get_by_ip_address(address.address)
+
+    assert_equal(address.name, found.name, "address should have same name")
+    assert_equal(address.address, found.address, "addresses should match")
+  end
+
+  def test_addresses_get_address_by_name
+    # Fetch a preexisting address to learn its IP
+    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
+
+    found = @client.addresses.get_by_name(some_address_name)
+
+    assert_equal(address.name, found.name, "address should have same name")
+    assert_equal(address.address, found.address, "addresses should match")
+  end
+
+  def test_addresses_get_by_ip_address_or_name
+    # Fetch a preexisting address to learn its IP
+    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
+
+    # Ensure we find the same addresses through both codepaths
+    with_name = @client.addresses.get_by_ip_address_or_name(some_address_name)
+    with_ip = @client.addresses.get_by_ip_address_or_name(address.address)
+
+    assert_equal(address.name, with_name.name, "address should have same name")
+    assert_equal(address.address, with_name.address, "addresses should match")
+
+    assert_equal(with_name.name, with_ip.name, "address should have same name")
+    assert_equal(with_name.address, with_ip.address, "addresses should match")
+  end
+
+  def test_addresses_all
+    # Fetch a preexisting address to learn its IP
+    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
+
+    found = @client.addresses.all
+
+    assert_operator(found.size, :>, 0, "address count should be positive")
+    assert_includes(found.map(&:name), address.name, "pre-existing address should be present")
+  end
+
+  def test_addresses_destroy
+    # Make a existing address to delete
+    address_name = new_address_name
+    address = @client.addresses.create(
+      :name => address_name,
+      :region => DEFAULT_REGION
+    )
+
+    # Force synchronous for easier testing
+    address.destroy(false)
+
+    assert_raises(Google::Apis::ClientError) do
+      @client.get_address(address_name, DEFAULT_REGION)
+    end
+  end
+
+  def test_addresses_in_use
+    # Make a existing address to delete
+    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
+
+    assert_equal(false, address.in_use?, "address should not be in use")
+  end
+
+  def test_address_associate
+    # TODO: implement when servers are implemented @everlag
+    skip
+  end
+
+  def test_address_disassociate
+    # TODO: implement when servers are implemented @everlag
+    skip
+  end
+
+  def test_address_server_set
+    # TODO: implement when servers are implemented @everlag
+    skip
+  end
+end