class Fog::Storage::GoogleXML::Mock

Public Class Methods

acls(type) click to toggle source
# File lib/fog/storage/google_xml/mock.rb, line 7
def self.acls(type)
  case type
  when "private"
    {
      "AccessControlList" => [
        {
          "Permission" => "FULL_CONTROL",
          "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
        }
      ],
      "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
    }
  when "public-read"
    {
      "AccessControlList" => [
        {
          "Permission" => "FULL_CONTROL",
          "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
        },
        {
          "Permission" => "READ",
          "Scope" => { "type" => "AllUsers" }
        }
      ],
      "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
    }
  when "public-read-write"
    {
      "AccessControlList" => [
        {
          "Permission" => "FULL_CONTROL",
          "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
        },
        {
          "Permission" => "READ",
          "Scope" => { "type" => "AllUsers" }
        },
        {
          "Permission" => "WRITE",
          "Scope" => { "type" => "AllUsers" }
        }
      ],
      "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
    }
  when "authenticated-read"
    {
      "AccessControlList" => [
        {
          "Permission" => "FULL_CONTROL",
          "Scope" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0", "type" => "UserById" }
        },
        {
          "Permission" => "READ",
          "Scope" => { "type" => "AllAuthenticatedUsers" }
        }
      ],
      "Owner" => { "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0" }
    }
  end
end
data() click to toggle source
# File lib/fog/storage/google_xml/mock.rb, line 68
def self.data
  @data ||= Hash.new do |hash, key|
    hash[key] = {
      :acls => {
        :bucket => {},
        :object => {}
      },
      :buckets => {}
    }
  end
end
new(options = {}) click to toggle source
# File lib/fog/storage/google_xml/mock.rb, line 84
def initialize(options = {})
  @google_storage_access_key_id = options[:google_storage_access_key_id]
end
reset() click to toggle source
# File lib/fog/storage/google_xml/mock.rb, line 80
def self.reset
  @data = nil
end

Public Instance Methods

copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, _options = {}) click to toggle source
# File lib/fog/storage/google_xml/requests/copy_object.rb, line 37
def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, _options = {})
  response = Excon::Response.new
  source_bucket = data[:buckets][source_bucket_name]
  source_object = source_bucket && source_bucket[:objects][source_object_name]
  target_bucket = data[:buckets][target_bucket_name]

  if source_object && target_bucket
    response.status = 200
    target_object = source_object.dup
    target_object["Name"] = target_object_name
    target_bucket[:objects][target_object_name] = target_object
    response.body = {
      "ETag"          => target_object["ETag"],
      "LastModified"  => Time.parse(target_object["Last-Modified"])
    }
  else
    response.status = 404
    raise(Excon::Errors.status_error({ :expects => 200 }, response))
  end

  response
end
data() click to toggle source
# File lib/fog/storage/google_xml/mock.rb, line 88
def data
  self.class.data[@google_storage_access_key_id]
end
delete_bucket(bucket_name) click to toggle source
# File lib/fog/storage/google_xml/requests/delete_bucket.rb, line 22
def delete_bucket(bucket_name)
  response = Excon::Response.new
  if data[:buckets][bucket_name].nil?
    response.status = 404
    raise(Excon::Errors.status_error({ :expects => 204 }, response))
  elsif data[:buckets][bucket_name] && !data[:buckets][bucket_name][:objects].empty?
    response.status = 409
    raise(Excon::Errors.status_error({ :expects => 204 }, response))
  else
    data[:buckets].delete(bucket_name)
    response.status = 204
  end
  response
end
delete_object(bucket_name, object_name) click to toggle source
# File lib/fog/storage/google_xml/requests/delete_object.rb, line 25
def delete_object(bucket_name, object_name)
  response = Excon::Response.new
  if bucket = data[:buckets][bucket_name]
    if object = bucket[:objects][object_name]
      response.status = 204
      bucket[:objects].delete(object_name)
    else
      response.status = 404
      raise(Excon::Errors.status_error({ :expects => 204 }, response))
    end
  else
    response.status = 404
    raise(Excon::Errors.status_error({ :expects => 204 }, response))
  end
  response
end
delete_object_url(bucket_name, object_name, expires) click to toggle source
# File lib/fog/storage/google_xml/requests/delete_object_url.rb, line 29
def delete_object_url(bucket_name, object_name, expires)
  raise ArgumentError.new("bucket_name is required") unless bucket_name
  raise ArgumentError.new("object_name is required") unless object_name
  https_url({
              :headers  => {},
              :host     => @host,
              :method   => "DELETE",
              :path     => "#{bucket_name}/#{object_name}"
            }, expires)
end
get_bucket(bucket_name, options = {}) click to toggle source
# File lib/fog/storage/google_xml/requests/get_bucket.rb, line 50
def get_bucket(bucket_name, options = {})
  raise ArgumentError.new("bucket_name is required") unless bucket_name
  response = Excon::Response.new
  name = /(\w+\.?)*/.match(bucket_name)
  if bucket_name == name.to_s
    if bucket = data[:buckets][bucket_name]
      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"])
      end.map do |object|
        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
      end
      max_keys = options["max-keys"] || 1000
      size = [max_keys, 1000].min
      truncated_contents = contents[0...size]

      response.status = 200
      response.body = {
        "CommonPrefixes"  => [],
        "Contents"        => truncated_contents,
        "IsTruncated"     => truncated_contents.size != contents.size,
        "Marker"          => options["marker"],
        "Name"            => bucket["Name"],
        "Prefix"          => options["prefix"]
      }
      if options["max-keys"] && options["max-keys"] < response.body["Contents"].length
        response.body["IsTruncated"] = true
        response.body["Contents"] = response.body["Contents"][0...options["max-keys"]]
      end
    else
      response.status = 404
      raise(Excon::Errors.status_error({ :expects => 200 }, response))
    end
  else
    response.status = 400
    raise(Excon::Errors.status_error({ :expects => 200 }, response))
  end
  response
end
get_bucket_acl(bucket_name) click to toggle source
# File lib/fog/storage/google_xml/requests/get_bucket_acl.rb, line 39
def get_bucket_acl(bucket_name)
  response = Excon::Response.new
  if acl = data[:acls][:bucket][bucket_name]
    response.status = 200
    response.body = acl
  else
    response.status = 404
    raise(Excon::Errors.status_error({ :expects => 200 }, response))
  end
  response
end
get_object(bucket_name, object_name, options = {}) { |chunk| ... } click to toggle source
# File lib/fog/storage/google_xml/requests/get_object.rb, line 54
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
  if (bucket = data[:buckets][bucket_name]) && (object = bucket[:objects][object_name])
    if options["If-Match"] && options["If-Match"] != object["ETag"]
      response.status = 412
    elsif options["If-Modified-Since"] && options["If-Modified-Since"] >= Time.parse(object["Last-Modified"])
      response.status = 304
    elsif options["If-None-Match"] && options["If-None-Match"] == object["ETag"]
      response.status = 304
    elsif options["If-Unmodified-Since"] && options["If-Unmodified-Since"] < Time.parse(object["Last-Modified"])
      response.status = 412
    else
      response.status = 200
      for key, value in object
        case key
        when "Cache-Control", "Content-Disposition", "Content-Encoding", "Content-Length", "Content-MD5", "Content-Type", "ETag", "Expires", "Last-Modified", /^x-goog-meta-/
          response.headers[key] = value
        end
      end
      if block_given?
        data = StringIO.new(object[:body])
        remaining = data.length
        while remaining > 0
          chunk = data.read([remaining, Excon::CHUNK_SIZE].min)
          yield(chunk)
          remaining -= Excon::CHUNK_SIZE
        end
      else
        response.body = object[:body]
      end
    end
  else
    response.status = 404
    raise(Excon::Errors.status_error({ :expects => 200 }, response))
  end
  response
end
get_object_acl(bucket_name, object_name) click to toggle source
# File lib/fog/storage/google_xml/requests/get_object_acl.rb, line 48
def get_object_acl(bucket_name, object_name)
  response = Excon::Response.new
  if acl = data[:acls][:object][bucket_name] && data[:acls][:object][bucket_name][object_name]
    response.status = 200
    response.body = acl
  else
    response.status = 404
    raise(Excon::Errors.status_error({ :expects => 200 }, response))
  end
  response
end
get_service() click to toggle source
# File lib/fog/storage/google_xml/requests/get_service.rb, line 27
def get_service
  response = Excon::Response.new
  response.headers["Status"] = 200
  buckets = data[:buckets].values.map do |bucket|
    bucket.select do |key, _value|
      %w(CreationDate Name).include?(key)
    end
  end
  response.body = {
    "Buckets" => buckets,
    "Owner"   => { "ID" => "some_id" }
  }
  response
end
head_object(bucket_name, object_name, options = {}) click to toggle source
# File lib/fog/storage/google_xml/requests/head_object.rb, line 46
def head_object(bucket_name, object_name, options = {})
  response = get_object(bucket_name, object_name, options)
  response.body = nil
  response
end
put_bucket(bucket_name, options = {}) click to toggle source
# File lib/fog/storage/google_xml/requests/put_bucket.rb, line 39
def put_bucket(bucket_name, options = {})
  acl = options["x-goog-acl"] || "private"
  if !Utils::VALID_ACLS.include?(acl)
    raise Excon::Errors::BadRequest.new("invalid x-goog-acl")
  else
    data[:acls][:bucket][bucket_name] = self.class.acls(options[acl])
  end
  response = Excon::Response.new
  response.status = 200
  bucket = {
    :objects        => {},
    "Name"          => bucket_name,
    "CreationDate"  => Time.now,
    "Owner"         => { "DisplayName" => "owner", "ID" => "some_id" },
    "Payer"         => "BucketOwner"
  }
  if options["LocationConstraint"]
    bucket["LocationConstraint"] = options["LocationConstraint"]
  else
    bucket["LocationConstraint"] = ""
  end
  if data[:buckets][bucket_name].nil?
    data[:buckets][bucket_name] = bucket
  else
    response.status = 409
    raise(Excon::Errors.status_error({ :expects => 200 }, response))
  end
  response
end
put_bucket_acl(_bucket_name, _acl) click to toggle source
# File lib/fog/storage/google_xml/requests/put_bucket_acl.rb, line 5
def put_bucket_acl(_bucket_name, _acl)
  Fog::Mock.not_implemented
end
put_object(bucket_name, object_name, data, options = {}) click to toggle source
# File lib/fog/storage/google_xml/requests/put_object.rb, line 39
def put_object(bucket_name, object_name, data, options = {})
  acl = options["x-goog-acl"] || "private"
  if !Utils::VALID_ACLS.include?(acl)
    raise Excon::Errors::BadRequest.new("invalid x-goog-acl")
  else
    self.data[:acls][:object][bucket_name] ||= {}
    self.data[:acls][:object][bucket_name][object_name] = self.class.acls(acl)
  end

  data = Fog::Storage.parse_data(data)
  data[:body] = data[:body].read unless data[:body].is_a?(String)
  response = Excon::Response.new
  if (bucket = self.data[:buckets][bucket_name])
    response.status = 200
    object = {
      :body             => data[:body],
      "Content-Type"    => options["Content-Type"] || data[:headers]["Content-Type"],
      "ETag"            => Fog::Google::Mock.etag,
      "Key"             => object_name,
      "Last-Modified"   => Fog::Time.now.to_date_header,
      "Content-Length"  => options["Content-Length"] || data[:headers]["Content-Length"]
    }

    for key, value in options
      case key
      when "Cache-Control", "Content-Disposition", "Content-Encoding", "Content-MD5", "Expires", /^x-goog-meta-/
        object[key] = value
      end
    end

    bucket[:objects][object_name] = object
    response.headers = {
      "Content-Length"  => object["Content-Length"],
      "Content-Type"    => object["Content-Type"],
      "ETag"            => object["ETag"],
      "Last-Modified"   => object["Last-Modified"]
    }
  else
    response.status = 404
    raise(Excon::Errors.status_error({ :expects => 200 }, response))
  end
  response
end
put_object_url(bucket_name, object_name, expires, headers = {}) click to toggle source
# File lib/fog/storage/google_xml/requests/put_object_url.rb, line 29
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
  https_url({
              :headers  => headers,
              :host     => @host,
              :method   => "PUT",
              :path     => "#{bucket_name}/#{object_name}"
            }, expires)
end
reset_data() click to toggle source
# File lib/fog/storage/google_xml/mock.rb, line 92
def reset_data
  self.class.data.delete(@google_storage_access_key_id)
end
signature(_params) click to toggle source
# File lib/fog/storage/google_xml/mock.rb, line 96
def signature(_params)
  "foo"
end