amaze_sns 1.0.1

data/README.md

@@ -0,0 +1,38 @@
+Amazon SNS gem
+==============
+
+Introduction
+---------
+A Ruby gem for use with the Amazon Simple Notification service (http://aws.amazon.com/sns/).
+
+Usage
+---------------
+
+AmazeSNS.skey = <your amazon aws secret key>
+
+AmazeSNS.akey = <your amazon aws access key>
+
+AmazeSNS['your_topic_name'] # creates a new Topic Object but not yet published
+AmazeSNS['your_topic_name'].create # add new topic to local hash and to SNS
+AmazeSNS['your_topic_name'].delete # removes it from both SNS and local hash
+
+AmazeSNS.logger = my_logger # set a logger for the response
+
+Dependencies
+---------------
+Require the CrackXML gem for parsing XML responses back from SNS; EventMachine
+and EM-Http request gem for the requests; and ruby hmac gem for authenticating with Amazon Web Services
+
+
+Tests
+---------------
+The specs are not fully working at the moment as the gem is undergoing a serious revamp.
+
+The gem itself has been tested on systems running ruby 1.8.6 and ruby 1.8.7
+
+
+
+Copyright
+---------
+
+Copyright (c) 2010 29 Steps UK. See LICENSE for details.

data/lib/amaze/exceptions.rb

@@ -0,0 +1,34 @@
+class AmazeSNSRuntimeError < RuntimeError; end
+class AmazeSNSError < StandardError; end
+class AuthenticationError < AmazeSNSRuntimeError; end
+
+class InvalidOptions < AmazeSNSError
+  def message
+    'Please supply valid options'
+  end
+end
+
+class AuthorizationError < AmazeSNSError
+  def message
+    'You do not have permission to access the resource'
+  end
+end
+
+class InternalError < AmazeSNSError
+  def message
+    'An internal service error has occured on the Simple Notification Service'
+  end
+end
+
+class InvalidParameterError < AmazeSNSError
+  def message
+    'An invalid parameter is in the request'
+  end
+end
+
+
+class NotFoundError < AmazeSNSError
+  def message
+    'The requested resource is not found'
+  end
+end

data/lib/amaze/helpers.rb

@@ -0,0 +1,31 @@
+
+require "hmac"
+require "hmac-sha2"
+require "cgi"
+require "time"
+require "base64"
+
+
+# HELPER METHODS
+def url_encode(string)
+  string = string.to_s
+  # It's kinda like CGI.escape, except CGI.escape is encoding a tilde when
+  # it ought not to be, so we turn it back. Also space NEEDS to be %20 not +.
+  return CGI.escape(string).gsub("%7E", "~").gsub("+", "%20")
+end
+  
+def canonical_querystring(params)
+  # I hope this built-in sort sorts by byte order, that's what's required. 
+  values = params.keys.sort.collect {|key|  [url_encode(key), url_encode(params[key])].join("=") }
+
+  return values.join("&")
+end
+
+
+def hash_to_query(hash)
+  hash.collect do |key, value|
+
+    url_encode(key) + "=" + url_encode(value)
+
+  end.join("&")
+end

data/lib/amaze/request.rb

@@ -0,0 +1,94 @@
+
+require 'crack/xml'
+
+require File.dirname(__FILE__) + "/helpers"
+require File.dirname(__FILE__) + "/exceptions"
+
+require 'em-http'
+
+
+class Request
+  
+  attr_accessor :params, :options, :httpresponse
+  
+  def initialize(params, options={})
+    @params = params
+    @options = options
+  end
+  
+  def process2
+    query_string = canonical_querystring(@params)
+string_to_sign = "GET
+#{AmazeSNS.host}
+/
+#{query_string}"
+     
+     hmac = HMAC::SHA256.new(AmazeSNS.skey)
+     hmac.update( string_to_sign )
+     signature = Base64.encode64(hmac.digest).chomp
+
+     params['Signature'] = signature
+     querystring2 = params.collect { |key, value| [url_encode(key), url_encode(value)].join("=") }.join('&') # order doesn't matter for the actual request
+     response = HttpClient.get "#{AmazeSNS.host}?#{querystring2}"
+     parsed_response = Crack::XML.parse(response)
+     return parsed_response
+  end
+  
+  def process
+    query_string = canonical_querystring(@params)
+
+string_to_sign = "GET
+#{AmazeSNS.host}
+/
+#{query_string}"
+                
+      hmac = HMAC::SHA256.new(AmazeSNS.skey)
+      hmac.update( string_to_sign )
+      signature = Base64.encode64(hmac.digest).chomp
+      
+      params['Signature'] = signature
+      querystring2 = params.collect { |key, value| [url_encode(key), url_encode(value)].join("=") }.join('&') # order doesn't matter for the actual request
+      
+      unless defined?(EventMachine) && EventMachine.reactor_running?
+        raise AmazeSNSRuntimeError, "In order to use this you must be running inside an eventmachine loop"
+      end
+      
+      require 'em-http' unless defined?(EventMachine::HttpRequest)
+      
+      @httpresponse ||=  http_class.new("http://#{AmazeSNS.host}/?#{querystring2}").send(:get)
+      @httpresponse.callback{ success_callback }
+      @httpresponse.errback{ error_callback }
+      nil
+  end
+  
+  def http_class
+    EventMachine::HttpRequest
+  end
+  
+  
+  def success_callback
+    case @httpresponse.response_header.status
+     when 403
+       raise AuthorizationError
+     when 500
+       raise InternalError
+     when 400
+       raise InvalidParameterError
+     when 404
+       raise NotFoundError
+     else
+       call_user_success_handler
+     end #end case
+  end
+  
+  def call_user_success_handler
+    @options[:on_success].call(httpresponse) if options[:on_success].respond_to?(:call)
+  end
+  
+  def error_callback
+    EventMachine.stop
+    raise AmazeSNSRuntimeError.new("A runtime error has occured: status code: #{@httpresponse.response_header.status}")
+  end
+  
+  
+end

data/lib/amaze/subscription.rb

@@ -0,0 +1,17 @@
+class Subscription
+  
+  attr_accessor :owner, :protocol, :topicarn, :endpoint, :subarn
+  
+  def initialize(args)
+    @owner = args["Owner"]
+    @protocol = args["Protocol"]
+    @topicarn = args["TopicArn"]
+    @endpoint = args["Endpoint"]
+    @subarn = args["SubscriptionArn"]
+  end
+  
+  def to_s
+    "Subscription: Owner - #{@owner} : Protocol - #{@protocol} : TopicARN - #{@topicarn} : EndPoint - #{@endpoint} : SubscriptionARN - #{@subarn}"
+  end
+  
+end

data/lib/amaze/topic.rb

@@ -0,0 +1,342 @@
+require File.dirname(__FILE__) + "/request"
+require File.dirname(__FILE__) + "/exceptions"
+require "eventmachine"
+require "json"
+
+class Topic
+  
+  attr_accessor :topic, :arn, :attrs
+
+  def initialize(topic, arn='')
+    @topic = topic
+    @arn = arn
+    @attrs ||= {}
+  end
+  
+  def generate_request(params,&blk)
+    req_options={}
+    req_options[:on_success] = blk if blk
+    Request.new(params, req_options).process
+  end
+  
+  # for running th EM loop w/o repetitions
+  def reactor(&blk)
+    EM.run do
+      instance_eval(&blk)
+    end
+  end
+  
+  def create
+    params = {
+      'Name' => "#{@topic}",
+      'Action' => 'CreateTopic',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+     }
+     
+     reactor{
+       generate_request(params) do |response|
+         parsed_response = Crack::XML.parse(response.response)
+         @arn = parsed_response["CreateTopicResponse"]["CreateTopicResult"]["TopicArn"]
+         AmazeSNS.topics[@topic.to_s] = self # add to hash
+         AmazeSNS.topics.rehash
+         EM.stop
+       end
+     }
+    @arn
+  end
+  
+  # delete topic
+  def delete
+    parsed_response = ''
+    params = {
+      'TopicArn' => "#{arn}",
+      'Action' => 'DeleteTopic',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+     }
+    
+     reactor{
+       generate_request(params) do |response|
+         parsed_response = Crack::XML.parse(response.response)
+         AmazeSNS.topics.delete("#{@topic}")
+         AmazeSNS.topics.rehash
+         EM.stop
+        end
+      }
+    parsed_response
+  end
+  
+  # get attributes for topic from remote sns server
+  # TopicArn -- the topic's ARN 
+  # Owner -- the AWS account ID of the topic's owner 
+  # Policy -- the JSON serialization of the topic's access control policy 
+  # DisplayName -- the human-readable name used in the "From" field for notifications to email and email-json endpoints 
+  
+  def attrs
+    outcome = nil
+    params = {
+      'TopicArn' => "#{arn}",
+      'Action' => 'GetTopicAttributes',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+     }
+ 
+     reactor{
+       generate_request(params) do |response|
+         parsed_response = Crack::XML.parse(response.response) 
+         res = parsed_response['GetTopicAttributesResponse']['GetTopicAttributesResult']['Attributes']["entry"]
+         outcome = make_hash(res) #res["entry"] is an array of hashes - need to turn it into hash with key value
+         EM.stop
+        end
+     }
+     return outcome
+  end
+  
+  # The SetTopicAttributes action allows a topic owner to set an attribute of the topic to a new value.
+  # only following attributes can be set:
+  # TopicArn -- the topic's ARN 
+  # Owner -- the AWS account ID of the topic's owner 
+  # Policy -- the JSON serialization of the topic's access control policy 
+  # DisplayName -- the human-readable name used in the "From" field for notifications to email and email-json endpoints
+  
+  def set_attrs(opts)
+    outcome = nil
+    params = {
+      'AttributeName' => "#{opts[:name]}",
+      'AttributeValue' => "#{opts[:value]}",
+      'TopicArn' => "#{arn}",
+      'Action' => 'SetTopicAttributes',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+     }
+     
+     reactor{
+      generate_request(params) do |response|
+        parsed_response = Crack::XML.parse(response.response) 
+        outcome = parsed_response['SetTopicAttributesResponse']['ResponseMetadata']['RequestId']
+        EM.stop
+      end
+    }
+    return outcome
+  end
+  
+  # subscribe method
+  def subscribe(opts)
+    raise InvalidOptions unless ( !(opts.empty?) && opts.instance_of?(Hash) )
+    res=''
+    params = {
+      'TopicArn' => "#{arn}",
+      'Endpoint' => "#{opts[:endpoint]}",
+      'Protocol' => "#{opts[:protocol]}",
+      'Action' => 'Subscribe',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+    }
+    
+    reactor{
+      generate_request(params) do |response|
+        parsed_response = Crack::XML.parse(response.response)
+        res = parsed_response['SubscribeResponse']['SubscribeResult']['SubscriptionArn']
+        return res
+        EM.stop
+      end
+    }
+    res
+  end
+  
+  def unsubscribe(id)
+    raise InvalidOptions unless ( !(id.empty?) && id.instance_of?(String) )
+    res=''
+    params = {
+      'SubscriptionArn' => "#{id}",
+      'Action' => 'Unsubscribe',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+    }
+    
+    reactor{
+      generate_request(params) do |response|
+        parsed_response = Crack::XML.parse(response.response)
+        res = parsed_response['UnsubscribeResponse']['ResponseMetadata']['RequestId']
+        return res
+        EM.stop
+      end
+    }
+    res
+  end
+  
+  
+  # grabs list of subscriptions for this topic only
+  def subscriptions
+    nh={}
+    params = {
+      'TopicArn' => "#{arn}",
+      'Action' => 'ListSubscriptionsByTopic',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+    }
+    
+    reactor{
+       generate_request(params) do |response|
+         parsed_response = Crack::XML.parse(response.response)
+         arr = parsed_response['ListSubscriptionsByTopicResponse']['ListSubscriptionsByTopicResult']['Subscriptions']['member'] unless (parsed_response['ListSubscriptionsByTopicResponse']['ListSubscriptionsByTopicResult']['Subscriptions'].nil?)
+
+         if !(arr.nil?) && (arr.instance_of?(Array))
+           #temp fix for now
+           nh = arr.inject({}) do |h,v|
+             key = v["SubscriptionArn"].to_s
+             value = v
+             h[key.to_s] = value
+             h
+           end
+         elsif !(arr.nil?) && (arr.instance_of?(Hash))
+           # to deal with one subscription issue
+           key = arr["SubscriptionArn"]
+           arr.delete("SubscriptionArn")
+           nh[key.to_s] = arr
+         end
+         return nh
+         EM.stop
+       end
+    }
+    nh
+  end
+  
+  # The AddPermission action adds a statement to a topic's access control policy, granting access for the 
+  # specified AWS accounts to the specified actions.
+  
+  def add_permission(opts)
+    raise InvalidOptions unless ( !(opts.empty?) && opts.instance_of?(Hash) )
+    res=''
+    params = {
+      'TopicArn' => "#{arn}",
+      'Label' => "#{opts[:label]}",
+      'ActionName.member.1' => "#{opts[:action_name]}",
+      'AWSAccountId.member.1' => "#{opts[:account_id]}",
+      'Action' => 'AddPermission',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+    }
+    
+    reactor{
+      generate_request(params) do |response|
+        parsed_response = Crack::XML.parse(response.response)
+        res = parsed_response['AddPermissionResponse']['ResponseMetadata']['RequestId']
+        return res
+        EM.stop
+      end
+    }
+    res
+  end
+  
+  # The RemovePermission action removes a statement from a topic's access control policy. 
+  def remove_permission(label)
+    raise InvalidOptions unless ( !(label.empty?) && label.instance_of?(String) )
+    res=''
+    params = {
+      'TopicArn' => "#{arn}",
+      'Label' => "#{label}",
+      'Action' => 'RemovePermission',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+    }
+    
+    reactor{
+      generate_request(params) do |response|
+        parsed_response = Crack::XML.parse(response.response)
+        res = parsed_response['RemovePermissionResponse']['ResponseMetadata']['RequestId']
+        return res
+        EM.stop
+      end
+    }
+    res
+  end
+  
+  
+  def publish!(msg, subject='')
+    raise InvalidOptions unless ( !(msg.empty?) && msg.instance_of?(String) )
+    res=''
+    params = {
+      'Subject' => "My First Message",
+      'TopicArn' => "#{arn}",
+      "Message" => "#{msg}",
+      'Action' => 'Publish',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+    }
+    
+    reactor{
+      generate_request(params) do |response|
+        parsed_response = Crack::XML.parse(response.response)
+        res = parsed_response['PublishResponse']['PublishResult']['MessageId']
+        return res
+        EM.stop
+      end
+    }
+    res
+  end
+  
+  def confirm_subscription(token)
+    raise InvalidOptions unless ( !(token.empty?) && token.instance_of?(String) )
+    arr=[]
+    params = {
+      'TopicArn' => "#{arn}",
+      'Token' => "#{token}",
+      'Action' => 'ConfirmSubscription',
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => AmazeSNS.akey
+    }
+    
+    reactor{
+      generate_request(params) do |response|
+        parsed_response = Crack::XML.parse(response.response)
+        resp = parsed_response['ConfirmSubscriptionResponse']['ConfirmSubscriptionResult']['SubscriptionArn']
+        id = parsed_response['ConfirmSubscriptionResponse']['ResponseMetadata']['RequestId']
+        arr = [resp,id]
+        return arr
+        EM.stop
+      end
+    }
+    arr
+  end
+  
+  
+  
+    
+  def make_hash(arr)
+    hash = arr.inject({}) do |h, v|
+      (v["key"] == "Policy")? value = JSON.parse(v["value"]) : value = v["value"]
+      key = v["key"].to_s
+      h[key] = value
+      h
+    end
+    
+    hash
+  end
+  
+  
+  
+end

data/lib/amaze_sns.rb

@@ -0,0 +1,147 @@
+autoload 'Logger', 'logger'
+
+
+require File.dirname(__FILE__) + "/amaze/topic"
+require File.dirname(__FILE__) + "/amaze/subscription"
+require File.dirname(__FILE__) + "/amaze/helpers"
+require File.dirname(__FILE__) + "/amaze/request"
+require File.dirname(__FILE__) + "/amaze/exceptions"
+require "eventmachine"
+require 'crack/xml'
+
+class AmazeSNS
+  
+  class CredentialError < ::ArgumentError
+    def message
+      'Please provide your Amazon keys to use the service'
+    end
+  end
+  
+  class << self
+    attr_accessor :host, :logger, :topics, :skey, :akey, :subscriptions
+    #attr_writer :skey, :akey
+  end
+
+  
+  self.host = 'sns.us-east-1.amazonaws.com'
+  self.logger = Logger.new($STDOUT)
+  self.skey = ''
+  self.akey=''
+  self.topics ||= {}
+  self.subscriptions ||= {}
+  
+  def self.[](topic)
+    raise CredentialError unless (!(@skey.empty?) && !(@akey.empty?))
+    @topics[topic.to_s] = Topic.new(topic) unless @topics.has_key?(topic)
+    @topics[topic.to_s]
+  end
+  
+  
+  def self.method_missing(id, *args, &blk)
+    case(id.to_s)
+    when /^list_(.*)/
+      send(:process_query, $1, &blk)
+    when /^refresh_(.*)/
+      send(:process_query, $1, &blk)
+    else
+      #super
+      raise NoMethodError
+    end
+  end
+  
+  def self.process_query(type, &blk)
+   # p "INSIDE PROCESS query"
+    type = type.capitalize
+    params = {
+      'Action' => "List#{type}",
+      'SignatureMethod' => 'HmacSHA256',
+      'SignatureVersion' => 2,
+      'Timestamp' => Time.now.iso8601,
+      'AWSAccessKeyId' => @akey
+    }
+    
+    req_options={}
+    
+    if (blk)
+      prc = blk
+    else
+      prc = default_prc
+    end
+    
+    req_options[:on_success] = prc
+    #req = Request.new(params, req_options).process
+    
+    EM.run{
+      Request.new(params, req_options).process
+    }
+    
+  end
+  
+  def self.default_prc
+    prc = Proc.new do |resp|
+      parsed_response = Crack::XML.parse(resp.response)
+      #p "SUB RESPONSE: #{parsed_response.inspect}"
+      self.process_response(parsed_response)
+      EM.stop
+    end
+  end
+  
+  def self.process_response(resp)
+    kind = (resp.has_key?("ListTopicsResponse"))? "Topics" : "Subscriptions"
+    cla = (resp.has_key?("ListTopicsResponse"))? "Topic" : "Subscription"
+    #p "KIND IS #{kind}"
+    
+    result = resp["List#{kind}Response"]["List#{kind}Result"]["#{kind}"]
+    if result.nil?
+      p "NO DATA FOUND"
+      return nil
+    else
+      results = result["member"]
+    end
+    
+    @collection = self.send(kind.downcase)
+    
+    if !(results.nil?) 
+      if (results.instance_of?(Array))
+        results.each do |t|
+          label = t["TopicArn"].split(':').last.to_s
+          unless @collection.has_key?(label)
+            case cla
+            when "Topic"
+              @collection[label] = Topic.new(label,t["TopicArn"])
+            when "Subscription"
+              @collection[label] = Array.new
+              @collection[label] << Subscription.new(t)
+            end
+            
+            #@collection[label] = Kernel.const_get("#{cla}").new(t) # t is a hash
+          else
+            case cla
+            when "Topic"
+              @collection[label].arn = t["TopicArn"]
+            when "Subscription"
+              #@collection[label] = t["TopicArn"]
+              sub = Subscription.new(t)
+              @collection[label] << sub unless  @collection[label].detect{|x| x.subarn == sub.subarn}
+            end
+            #@collection[label].arn = t["TopicArn"]
+          end
+        end
+      elsif (results.instance_of?(Hash))
+         # lone entry results in a hash so parse it that way ...
+         label = results["TopicArn"].split(':').last.to_s
+         case cla
+         when "Topic"
+           @collection[label] = Topic.new(label, results["TopicArn"])
+         when "Subscription"
+           @collection[label] = Subscription.new(results)
+         end
+         
+         #@collection[label] = Kernel.const_get("#{cla}").new(results)
+      end
+    else
+      return nil
+    end # end outer if
+  end
+  
+end

data/spec/amaze_sns_spec.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe AmazeSNS do
+  
+  before(:each) do
+    EventMachine::MockHttpRequest.reset_counts!
+    EventMachine::MockHttpRequest.reset_registry!
+  end
+  
+  describe 'in its initial state' do
+  
+    it "should return the preconfigured host endpoint" do
+      AmazeSNS.host.should == 'sns.us-east-1.amazonaws.com'
+    end
+    
+    it "should return a blank Topics hash" do
+      AmazeSNS.topics.should == {}
+    end
+    
+  end
+  
+  describe 'without the keys' do
+    it 'should raise an ArgumentError if no keys are present' do
+      lambda{
+        AmazeSNS['test']
+      }.should raise_error(AmazeSNS::CredentialError)
+    end
+  end
+  
+  describe 'with the keys configured' do
+    
+    before do
+      AmazeSNS.akey = '123456'
+      AmazeSNS.skey = '123456'
+      @topic = AmazeSNS['Test']
+    end
+    
+    it 'should return a new topic object' do
+      @topic.should be_kind_of(Topic)
+      @topic.topic.should == 'Test'
+    end
+    
+  end
+ 
+
+  describe 'Request#process' do
+    module EventMachine
+      module HttpEncoding
+                def encode_query(path, query, uri_query)
+          encoded_query = if query.kind_of?(Hash)
+            query.sort{|a, b| a.to_s <=> b.to_s}.
+            map { |k, v| encode_param(k, v) }.
+            join('&')
+          else
+            query.to_s
+          end
+          if !uri_query.to_s.empty?
+            encoded_query = [encoded_query, uri_query].reject {|part| part.empty?}.join("&")
+          end
+          return path if encoded_query.to_s.empty?
+          "#{path}?#{encoded_query}"
+        end
+      end
+    end
+    
+    before :each do
+      EM::HttpRequest = EM::MockHttpRequest
+      EM::HttpRequest.reset_registry!
+      EM::HttpRequest.reset_counts!
+      EM::HttpRequest.pass_through_requests = false
+      
+      @params = {
+        'Action' => 'ListTopics',
+        'SignatureMethod' => 'HmacSHA256',
+        'SignatureVersion' => 2,
+        'Timestamp' => Time.now.iso8601,
+        'AWSAccessKeyId' => AmazeSNS.akey
+      }
+
+      @query_string = canonical_querystring(@params)
+
+string_to_sign = "GET
+#{AmazeSNS.host}
+/
+#{@query_string}"
+
+      hmac = HMAC::SHA256.new(AmazeSNS.skey)
+      hmac.update( string_to_sign )
+      signature = Base64.encode64(hmac.digest).chomp
+
+      @params['Signature'] = signature
+      @querystring2 = @params.collect { |key, value| [url_encode(key), url_encode(value)].join("=") }.join('&')
+      
+    end
+    
+    it "should return a deferrable which succeeds in success case" do
+      #Time.stub(:now).and_return(123)
+    
+      data = <<-RESPONSE.gsub(/^ +/, '')
+                   HTTP/1.1 202 Accepted
+                   Content-Type: text/html
+                   Content-Length: 13
+                   Connection: keep-alive
+                   Server: thin 1.2.7 codename No Hup
+           
+                   202 ACCEPTED
+      RESPONSE
+      
+      url = "http://#{AmazeSNS.host}/?#{@querystring2}"
+      
+      EM::HttpRequest.register(url, :get, data)
+      
+      EM.run {
+        d = AmazeSNS.list_topics
+        d.callback{
+            @raw_resp = Crack::XML.parse(resp.response)
+            AmazeSNS.process_response(@raw_resp)
+            EM.stop
+        }
+      }
+      
+      
+    end
+    
+    
+  end
+  
+  
+  
+  
+  after do
+    AmazeSNS.topics={}
+  end
+  
+ 
+end # end outer describe
+
+

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'spec'
+require 'spec/autorun'
+require 'request'
+require 'amaze_sns'
+require 'eventmachine'
+require 'em-http'
+require 'em-http/mock'
+
+Spec::Runner.configure do |config|
+  # EventMachine.instance_eval do
+  #         # Switching out EM's defer since it makes tests just a tad more unreliable
+  #         alias :defer_original :defer
+  #         def defer
+  #           yield
+  #         end
+  #       end unless EM.respond_to?(:defer_original)
+  #       
+  #   
+  #   def run_in_em_loop
+  #     EM.run {
+  #       yield
+  #     }
+  #   end
+  #   
+  #   class Request
+  #         self.module_eval do
+  #           def http_class
+  #             EventMachine::MockHttpRequest
+  #           end
+  #         end
+  #       end
+
+
+def fake_response
+  <<-HEREDOC
+<ListTopicsResponse xmlns=\"http://sns.amazonaws.com/doc/2010-03-31/\">\n<ListTopicsResult>\n<Topics>\n<member>\n<TopicArn>arn:aws:sns:us-east-1:365155214602:cars</TopicArn>\n</member>\n<member>\n<TopicArn>arn:aws:sns:us-east-1:365155214602:luckypooz</TopicArn>\n</member>\n<member>\n<TopicArn>arn:aws:sns:us-east-1:365155214602:29steps_products</TopicArn>\n</member>\n</Topics>\n</ListTopicsResult>\n <ResponseMetadata>\n<RequestId>d4a2ff9b-56dc-11df-b6e7-a7864eff589e</RequestId>\n</ResponseMetadata>\n</ListTopicsResponse>
+HEREDOC
+end
+  
+  
+
+  
+end #end configure
+
+
+

data/spec/topic_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Topic do
+  before do
+    @topic = Topic.new('my_test_topic', 'arn:123456')
+  end
+  
+  describe 'in its initial state' do
+    it 'should be an instance of Topic class' do
+      @topic.should be_kind_of(Topic)
+    end
+    
+    it 'should return the topic name and arn when requested' do
+      @topic.topic.should == 'my_test_topic'
+      @topic.arn.should == 'arn:123456'
+    end
+    
+  end
+  
+  describe 'when creating a topic' do
+  end
+  
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification 
+name: amaze_sns
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- Chee Yeo
+- 29 Steps UK
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 12
+        - 9
+        version: 0.12.9
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 8
+        version: 0.2.8
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: crack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 6
+        version: 0.1.6
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: ruby-hmac
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 3
+        version: 1.4.3
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id006
+description: Ruby gem to interface with the Amazon Simple Notification Service
+email: info@29steps.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/amaze/exceptions.rb
+- lib/amaze/helpers.rb
+- lib/amaze/request.rb
+- lib/amaze/subscription.rb
+- lib/amaze/topic.rb
+- lib/amaze_sns.rb
+- README.md
+has_rdoc: true
+homepage: http://29steps.co.uk
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Ruby gem for Amazon Simple Notification Service SNS
+test_files: 
+- spec/amaze_sns_spec.rb
+- spec/spec_helper.rb
+- spec/topic_spec.rb
+- spec/spec.opts