class Fog::AWS::SQS::Mock

Public Class Methods

data() click to toggle source
# File lib/fog/aws/sqs.rb, line 21
def self.data
  @data ||= Hash.new do |hash, region|
    hash[region] = Hash.new do |region_hash, key|
      region_hash[key] = {
        :owner_id => Fog::AWS::Mock.owner_id,
        :queues   => {}
      }
    end
  end
end
new(options={}) click to toggle source
# File lib/fog/aws/sqs.rb, line 36
def initialize(options={})
  @use_iam_profile = options[:use_iam_profile]
  setup_credentials(options)
  @region = options[:region] || 'us-east-1'

  Fog::AWS.validate_region!(@region)
end
reset() click to toggle source
# File lib/fog/aws/sqs.rb, line 32
def self.reset
  @data = nil
end

Public Instance Methods

change_message_visibility(queue_url, receipt_handle, visibility_timeout) click to toggle source
# File lib/fog/aws/requests/sqs/change_message_visibility.rb, line 30
def change_message_visibility(queue_url, receipt_handle, visibility_timeout)
  Excon::Response.new.tap do |response|
    if (queue = data[:queues][queue_url])
      message_id, _ = queue[:receipt_handles].find { |message_id, receipts|
        receipts.key?(receipt_handle)
      }

      if message_id
        queue[:messages][message_id]['Attributes']['VisibilityTimeout'] = visibility_timeout
        response.body = {
          'ResponseMetadata' => {
            'RequestId' => Fog::AWS::Mock.request_id
          }
        }
        response.status = 200
      else
        response.status = 404
        raise(Excon::Errors.status_error({:expects => 200}, response))
      end
    else
      response.status = 404
      raise(Excon::Errors.status_error({:expects => 200}, response))
    end
  end
end
create_queue(name, options = {}) click to toggle source
# File lib/fog/aws/requests/sqs/create_queue.rb, line 28
def create_queue(name, options = {})
  Excon::Response.new.tap do |response|
    response.status = 200

    now = Time.now
    queue_url = "https://queue.amazonaws.com/#{data[:owner_id]}/#{name}"
    queue = {
      'QueueName'      => name,
      'Attributes'     => {
        'VisibilityTimeout'                     => 30,
        'ApproximateNumberOfMessages'           => 0,
        'ApproximateNumberOfMessagesNotVisible' => 0,
        'CreatedTimestamp'                      => now,
        'LastModifiedTimestamp'                 => now,
        'QueueArn'                              => Fog::AWS::Mock.arn('sqs', 'us-east-1', data[:owner_id], name),
        'MaximumMessageSize'                    => 8192,
        'MessageRetentionPeriod'                => 345600
      },
      :messages        => {},
      :receipt_handles => {}
    }
    data[:queues][queue_url] = queue unless data[:queues][queue_url]

    response.body = {
      'ResponseMetadata' => {
        'RequestId' => Fog::AWS::Mock.request_id
      },
      'QueueUrl' => queue_url
    }
  end
end
data() click to toggle source
# File lib/fog/aws/sqs.rb, line 44
def data
  self.class.data[@region][@aws_access_key_id]
end
delete_message(queue_url, receipt_handle) click to toggle source
# File lib/fog/aws/requests/sqs/delete_message.rb, line 28
def delete_message(queue_url, receipt_handle)
  Excon::Response.new.tap do |response|
    if (queue = data[:queues][queue_url])
      message_id, _ = queue[:receipt_handles].find { |msg_id, receipts|
        receipts.key?(receipt_handle)
      }

      if message_id
        queue[:receipt_handles].delete(message_id)
        queue[:messages].delete(message_id)
        queue['Attributes']['LastModifiedTimestamp'] = Time.now
      end

      response.body = {
        'ResponseMetadata' => {
          'RequestId' => Fog::AWS::Mock.request_id
        }
      }
      response.status = 200
    else
      response.status = 404
      raise(Excon::Errors.status_error({:expects => 200}, response))
    end
  end
end
delete_queue(queue_url) click to toggle source
# File lib/fog/aws/requests/sqs/delete_queue.rb, line 26
def delete_queue(queue_url)
  Excon::Response.new.tap do |response|
    if (queue = data[:queues][queue_url])
      response.status = 200

      data[:queues].delete(queue_url)

      response.body = {
        'ResponseMetadata' => {
          'RequestId' => Fog::AWS::Mock.request_id
        }
      }
    else
      response.status = 404
      raise(Excon::Errors.status_error({:expects => 200}, response))
    end
  end
end
get_queue_attributes(queue_url, attribute_name) click to toggle source
# File lib/fog/aws/requests/sqs/get_queue_attributes.rb, line 28
def get_queue_attributes(queue_url, attribute_name)
  Excon::Response.new.tap do |response|
    if (queue = data[:queues][queue_url])
      response.status = 200

      response.body = {
        'ResponseMetadata' => {
          'RequestId' => Fog::AWS::Mock.request_id
        },
        'Attributes' => queue['Attributes']
      }
    else
      response.status = 404
      raise(Excon::Errors.status_error({:expects => 200}, response))
    end
  end
end
list_queues(options = {}) click to toggle source
# File lib/fog/aws/requests/sqs/list_queues.rb, line 26
def list_queues(options = {})
  Excon::Response.new.tap do |response|
    response.status = 200

    response.body = {
      'ResponseMetadata' => {
        'RequestId' => Fog::AWS::Mock.request_id
      },
      'QueueUrls' => data[:queues].keys
    }
  end
end
receive_message(queue_url, options = {}) click to toggle source
# File lib/fog/aws/requests/sqs/receive_message.rb, line 31
def receive_message(queue_url, options = {})
  Excon::Response.new.tap do |response|
    if (queue = data[:queues][queue_url])
      max_number_of_messages = options['MaxNumberOfMessages'] || 1
      now = Time.now

      messages = []

      queue[:messages].values.each do |m|
        message_id = m['MessageId']

        invisible = if (received_handles = queue[:receipt_handles][message_id])
          visibility_timeout = m['Attributes']['VisibilityTimeout'] || queue['Attributes']['VisibilityTimeout']
          received_handles.any? { |handle, time| now < time + visibility_timeout }
        else
          false
        end

        unless invisible
          receipt_handle = Fog::Mock.random_base64(300)

          queue[:receipt_handles][message_id] ||= {}
          queue[:receipt_handles][message_id][receipt_handle] = now

          m['Attributes'].tap do |attrs|
            attrs['ApproximateFirstReceiveTimestamp'] ||= now
            attrs['ApproximateReceiveCount'] = (attrs['ApproximateReceiveCount'] || 0) + 1
          end

          messages << m.merge({
            'ReceiptHandle' => receipt_handle
          })
          break if messages.size >= max_number_of_messages
        end
      end

      response.body = {
        'ResponseMetadata' => {
          'RequestId' => Fog::AWS::Mock.request_id
        },
        'Message' => messages
      }
      response.status = 200
    else
      response.status = 404
      raise(Excon::Errors.status_error({:expects => 200}, response))
    end
  end
end
reset_data() click to toggle source
# File lib/fog/aws/sqs.rb, line 48
def reset_data
  self.class.data[@region].delete(@aws_access_key_id)
end
send_message(queue_url, message) click to toggle source
# File lib/fog/aws/requests/sqs/send_message.rb, line 28
def send_message(queue_url, message)
  Excon::Response.new.tap do |response|
    if (queue = data[:queues][queue_url])
      response.status = 200

      now        = Time.now
      message_id = Fog::AWS::Mock.sqs_message_id
      md5        = OpenSSL::Digest::MD5.hexdigest(message)

      queue[:messages][message_id] = {
        'MessageId'  => message_id,
        'Body'       => message,
        'MD5OfBody'  => md5,
        'Attributes' => {
          'SenderId'      => Fog::AWS::Mock.sqs_message_id,
          'SentTimestamp' => now
        }
      }

      queue['Attributes']['LastModifiedTimestamp'] = now

      response.body = {
        'ResponseMetadata' => {
          'RequestId' => Fog::AWS::Mock.request_id
        },
        'MessageId'        => message_id,
        'MD5OfMessageBody' => md5
      }
    else
      response.status = 404
      raise(Excon::Errors.status_error({:expects => 200}, response))
    end
  end
end
set_queue_attributes(queue_url, attribute_name, attribute_value) click to toggle source
# File lib/fog/aws/requests/sqs/set_queue_attributes.rb, line 30
def set_queue_attributes(queue_url, attribute_name, attribute_value)
  Excon::Response.new.tap do |response|
    if (queue = data[:queues][queue_url])
      response.status = 200
      queue['Attributes'][attribute_name] = attribute_value
      response.body = {
        'ResponseMetadata' => {
          'RequestId' => Fog::AWS::Mock.request_id
        }
      }
    else
      response.status = 404
      raise(Excon::Errors.status_error({:expects => 200}, response))
    end
  end
end
setup_credentials(options) click to toggle source
# File lib/fog/aws/sqs.rb, line 52
def setup_credentials(options)
  @aws_access_key_id = options[:aws_access_key_id]
end