amaze_sns 1.3.0 → 2.0.0

data/spec/amaze_sns_spec.rb

@@ -1,14 +1,17 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+#require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'em-http'
 
 describe AmazeSNS do
-  
-  before(:each) do
-    EventMachine::MockHttpRequest.reset_counts!
+  before :each do
     EventMachine::MockHttpRequest.reset_registry!
+    EventMachine::MockHttpRequest.reset_counts!
+    EventMachine::MockHttpRequest.pass_through_requests = false
   end
   
-  describe 'in its initial state' do
   
+  describe 'in its initial state' do 
     it "should return the preconfigured host endpoint" do
       AmazeSNS.host.should == 'sns.us-east-1.amazonaws.com'
     end
@@ -17,18 +20,35 @@ describe AmazeSNS do
       AmazeSNS.topics.should == {}
     end
     
+    it "should return a blank Subscriptions hash" do
+      AmazeSNS.subscriptions.should == {}
+    end
+    
+    it 'should have the logger instantiated' do
+      AmazeSNS.logger.debug('some message')
+      AmazeSNS.logger.should be_kind_of(Logger)
+    end
+    
+    it 'should be able to accept any kind of logger' do
+      a_logger = mock("MyLogger")
+      a_logger.should_receive(:debug).with('some data')
+      AmazeSNS.logger = a_logger
+      AmazeSNS.logger.debug('some data')
+      AmazeSNS.logger = nil
+    end
   end
   
   describe 'without the keys' do
     it 'should raise an ArgumentError if no keys are present' do
+      AmazeSNS.skey=''
+      AmazeSNS.akey=''
       lambda{
         AmazeSNS['test']
       }.should raise_error(AmazeSNS::CredentialError)
     end
   end
   
-  describe 'with the keys configured' do
-    
+  describe 'with the keys configured' do   
     before do
       AmazeSNS.akey = '123456'
       AmazeSNS.skey = '123456'
@@ -39,97 +59,123 @@ describe AmazeSNS 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
+  
+  describe 'making the api calls' do
+    before :each do
+      @url = 'http://sns.us-east-1.amazonaws.com:80/?Action=ListTopics&Signature=ItTAjeexIPC43pHMZLCL7utnpK8j8AbTUZ3KGUSMzNc%3D&AWSAccessKeyId=123456&Timestamp=123&SignatureVersion=2&SignatureMethod=HmacSHA256'
+      EventMachine::MockHttpRequest.reset_registry!
+      EventMachine::MockHttpRequest.reset_counts!
+      EventMachine::MockHttpRequest.pass_through_requests = false #set to false to not hit the actual API endpoint
+      
+      @time_stub = stub("A")
     end
     
-    before :each do
-      EM::HttpRequest = EM::MockHttpRequest
-      EM::HttpRequest.reset_registry!
-      EM::HttpRequest.reset_counts!
-      EM::HttpRequest.pass_through_requests = false
+    it 'should be able to access the API endpoint' do
+      @time_stub.should_receive(:iso8601).and_return(123)
+      Time.stub(:now).and_return(@time_stub)
       
-      @params = {
-        'Action' => 'ListTopics',
-        'SignatureMethod' => 'HmacSHA256',
-        'SignatureVersion' => 2,
-        'Timestamp' => Time.now.iso8601,
-        'AWSAccessKeyId' => AmazeSNS.akey
-      }
+      EventMachine::MockHttpRequest.use {
+        data = <<-RESPONSE.gsub(/^ +/, '')
+          HTTP/1.0 200 OK
+          Date: Mon, 16 Nov 2009 20:39:15 GMT
+          Expires: -1
+          Cache-Control: private, max-age=0
+          Content-Type: text/html; charset=ISO-8859-1
+          Via: 1.0 .:80 (squid)
+          Connection: close
 
-      @query_string = canonical_querystring(@params)
+          This is my awesome content
+        RESPONSE
+        
+        EventMachine::MockHttpRequest.register(@url,:get,{},data)
+        
+        EM.run{
+          d = AmazeSNS.list_topics
+          d.callback{
+            EM::HttpRequest.count(@url, :get).should == 1
+            EM.stop
+          }
+          d.errback{|error|
+            EM.stop
+          }
+        }
 
-string_to_sign = "GET
-#{AmazeSNS.host}
-/
-#{@query_string}"
+      } #end EM:MockHttpRequest block
+    end
+    
+    it 'should return a deferrable on fail' do
+      @time_stub.should_receive(:iso8601).and_return(123)
+      Time.stub(:now).and_return(@time_stub)
+      
+      EventMachine::MockHttpRequest.use {
+        data = <<-RESPONSE.gsub(/^ +/, '')
+          HTTP/1.0 403 Unauthorized
+          Date: Mon, 16 Nov 2009 20:39:15 GMT
+          Expires: -1
+          Cache-Control: private, max-age=0
+          Content-Type: text/html; charset=ISO-8859-1
+          Via: 1.0 .:80 (squid)
+          Connection: close
 
-      hmac = HMAC::SHA256.new(AmazeSNS.skey)
-      hmac.update( string_to_sign )
-      signature = Base64.encode64(hmac.digest).chomp
+          403 UNAUTHORIZED: Some error
+        RESPONSE
 
-      @params['Signature'] = signature
-      @querystring2 = @params.collect { |key, value| [url_encode(key), url_encode(value)].join("=") }.join('&')
-      
+        EventMachine::MockHttpRequest.register(@url,:get,{},data)
+        
+        EM.run{
+           d= AmazeSNS.list_topics
+           d.callback{
+             fail
+           }
+           d.errback{|error|
+             EM::HttpRequest.count(@url, :get).should == 1
+             error.should be_kind_of(AuthorizationError)
+             EM.stop
+           }
+          
+        } 
+        
+      } #end EM:MockHttpRequest block
     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
+    it 'should call method_missing and process_query' do
+      @time_stub.should_receive(:iso8601).and_return(123)
+      Time.stub(:now).and_return(@time_stub)
       
-      url = "http://#{AmazeSNS.host}/?#{@querystring2}"
+      #rspec expectations matchers
+      AmazeSNS.should respond_to(:method_missing)
+      AmazeSNS.should respond_to(:process_query).with(1).argument
       
-      EM::HttpRequest.register(url, :get, data)
+      data = <<-RESPONSE.gsub(/^ +/, '')
+        HTTP/1.0 200 OK
+        Date: Mon, 16 Nov 2009 20:39:15 GMT
+        Expires: -1
+        Cache-Control: private, max-age=0
+        Content-Type: text/html; charset=ISO-8859-1
+        Via: 1.0 .:80 (squid)
+        Connection: close
+
+        This is my awesome content
+      RESPONSE
       
-      EM.run {
-        d = AmazeSNS.list_topics
-        d.callback{
-            @raw_resp = Crack::XML.parse(resp.response)
-            AmazeSNS.process_response(@raw_resp)
+      EventMachine::MockHttpRequest.use{
+        EventMachine::MockHttpRequest.register(@url,:get,{},data)
+          
+          EM.run{
+            AmazeSNS.list_topics
             EM.stop
-        }
-      }
-      
-      
+          }
+
+      } #end EM:MockHttpRequest block
     end
     
     
   end
   
-  
-  
-  
   after do
     AmazeSNS.topics={}
+    AmazeSNS.subscriptions={}
   end
   
  

data/spec/em_http_request_spec_helper.rb

@@ -0,0 +1,74 @@
+module EMHttpRequestSpecHelper
+
+  def failed
+    EventMachine.stop
+    fail
+  end
+
+  def http_request(method, uri, options = {}, &block)
+    response = nil
+    error = nil
+    uri = Addressable::URI.heuristic_parse(uri)
+    EventMachine.run {
+      request = EventMachine::HttpRequest.new("#{uri.omit(:userinfo).normalize.to_s}")
+      http = request.send(:setup_request, method, {
+        :timeout => 10, 
+        :body => options[:body],
+        :query => options[:query],
+        'authorization' => [uri.user, uri.password],
+        :head => options[:headers]}, &block)
+      http.errback {
+        error = if http.respond_to?(:errors)
+          http.errors         
+        else
+          http.error
+        end  
+        failed 
+      }
+      http.callback {    
+        response = OpenStruct.new({
+          :body => http.response,
+          :headers => WebMock::Util::Headers.normalize_headers(extract_response_headers(http)),          
+          :message => http.response_header.http_reason,
+          :status => http.response_header.status.to_s
+        })
+        EventMachine.stop
+      }
+    }
+    raise error if error
+    response
+  end
+
+  def client_timeout_exception_class
+    "WebMock timeout error"
+  end
+
+  def connection_refused_exception_class
+    ""
+  end
+
+  def default_client_request_headers(request_method = nil, has_body = false)
+    nil
+  end
+
+  def setup_expectations_for_real_request(options = {})
+  end
+
+  def http_library
+    :em_http_request
+  end
+  
+  private
+  
+  def extract_response_headers(http)
+    headers = {}
+    if http.response_header
+      http.response_header.each do |k,v|
+        v = v.join(", ") if v.is_a?(Array)
+        headers[k] = v 
+      end
+    end
+    headers
+  end
+
+end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -1,47 +1,29 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'spec'
-require 'spec/autorun'
-require 'request'
-require 'amaze_sns'
-require 'eventmachine'
+require 'rubygems'
+
+require 'rspec'
+require 'rspec/autorun'
 require 'em-http'
-require 'em-http/mock'
+require 'webmock'
+require 'webmock/rspec'
+require 'vcr'
 
-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
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
+require 'amaze_sns'
+require 'eventmachine'
+#require 'support/vcr'
 
-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
+VCR.config do |c|
+    c.cassette_library_dir     = 'fixtures/cassette_library'
+    c.stub_with :webmock
+    c.ignore_localhost         = true
+    c.default_cassette_options = { :record => :none }
 end
-  
-  
-
-  
-end #end configure
 
+RSpec.configure do |config|
+  config.include WebMock::API
+  config.extend VCR::RSpec::Macros
 
+end
 

data/spec/topic_spec.rb

@@ -1,11 +1,28 @@
 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
+    before :each do
+      @attrs_hash = { "SubscriptionsConfirmed"=>"2", 
+                        "SubscriptionsPending"=>"0", 
+                        "Owner"=>"365155214602", 
+                        "TopicArn"=>"arn:aws:sns:us-east-1:365155214602:my_test_topic", 
+                        "SubscriptionsDeleted"=>"0", 
+                        "Policy"=>{"Version"=>"2008-10-17", 
+                                   "Id"=>"us-east-1/365155214602/cars55__default_policy_ID", 
+                                   "Statement"=>[{"Action"=>["SNS:GetTopicAttributes", "SNS:SetTopicAttributes", "SNS:AddPermission", "SNS:RemovePermission", "SNS:DeleteTopic", "SNS:Subscribe", "SNS:ListSubscriptionsByTopic", "SNS:Publish", "SNS:Receive"], 
+                                                  "Sid"=>"us-east-1/365155214602/my_test_topic__default_statement_ID", 
+                                                  "Resource"=>"arn:aws:sns:us-east-1:365155214602:my_test_topic", 
+                                                  "Principal"=>{"AWS"=>"*"}, 
+                                                  "Condition"=>{"StringLike"=>{"AWS:SourceArn"=>"arn:aws:*:*:365155214602:*"}}, "Effect"=>"Allow"}]
+                                    }# end policy hash
+                        } # end outer hash
+    
+      @topic = Topic.new('my_test_topic', 'arn:123456')
+      @topic.attributes = @attrs_hash
+      @topic.stub!(:attrs).and_return(@attrs_hash)
+    end
+    
     it 'should be an instance of Topic class' do
       @topic.should be_kind_of(Topic)
     end
@@ -15,9 +32,482 @@ describe Topic do
       @topic.arn.should == 'arn:123456'
     end
     
+    it 'should return the attributes when requested' do
+      @topic.attrs.should be_kind_of(Hash)
+      @topic.attrs["SubscriptionsConfirmed"].should == "2"
+      @topic.attrs["Owner"].should == "365155214602"
+
+      @topic.attributes.should == @topic.attrs
+    end
+  end
+  
+  describe 'making requests to SNS API' do
+    
+    before :each do
+      AmazeSNS.akey = '123456'
+      AmazeSNS.skey = '123456'
+      @time_stub = stub("Time")
+
+      @data = <<-RESPONSE.gsub(/^ +/, '')
+        <CreateTopicResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+          <CreateTopicResult>
+            <TopicArn>arn:aws:sns:us-east-1:365155214602:MyTopic</TopicArn>
+          </CreateTopicResult>
+          <ResponseMetadata>
+            <RequestId>0a7225aa-e9cb-11df-a5a1-293a0b8d0fcb</RequestId>
+          </ResponseMetadata>
+        </CreateTopicResponse>
+      RESPONSE
+
+      WebMock.reset!
+      WebMock.disable_net_connect!
+
+      @regexp = %r{/?Action=CreateTopic&Name=MyTopic}
+    end
+
+    it 'should send data to the API' do
+      @time_stub.should_receive(:iso8601).and_return(123)
+      Time.stub(:now).and_return(@time_stub)
+
+      stub_http_request(:get, @regexp).to_return(:body => @data,
+                                                  :status => 200,
+                                                  :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close'})
+
+      @arn = AmazeSNS["MyTopic"].create
+      @arn.should == "arn:aws:sns:us-east-1:365155214602:MyTopic"
+      WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80})
+    end
+
+    it 'should return a deferrable' do
+      t = Topic.new('MyTopic')
+
+      @time_stub.should_receive(:iso8601).and_return(123)
+      Time.stub(:now).and_return(@time_stub)
+
+      stub_http_request(:get, @regexp).to_return(:body => @data, :status => 200)
+
+      params = {
+        'Name' => "MyTopic",
+        'Action' => 'CreateTopic',
+        'SignatureMethod' => 'HmacSHA256',
+        'SignatureVersion' => 2,
+        'Timestamp' => Time.now.iso8601,
+        'AWSAccessKeyId' => AmazeSNS.akey
+       }
+
+      EM.run{
+        d = t.generate_request(params)
+        d.callback{
+          WebMock.should have_requested(:get, @regexp)
+          EM.stop
+        }
+        d.errback{
+          fail
+          EM.stop
+        }
+      }
+    end
+
+    it 'should return a deferrable which fails if exception occurs' do
+      t = Topic.new('MyTopic')
+
+      @time_stub.should_receive(:iso8601).and_return(123)
+      Time.stub(:now).and_return(@time_stub)
+      AmazeSNS.akey = ''
+
+      stub_http_request(:get, @regexp).to_return(:body => @data, :status => 403)
+
+      params = {
+        'Name' => "MyTopic",
+        'Action' => 'CreateTopic',
+        'SignatureMethod' => 'HmacSHA256',
+        'SignatureVersion' => 2,
+        'Timestamp' => Time.now.iso8601,
+        'AWSAccessKeyId' => AmazeSNS.akey
+       }
+
+      EM.run{
+        d = t.generate_request(params)
+        d.callback{
+          fail
+        }
+        d.errback{|error|
+          WebMock.should have_requested(:get, @regexp)
+          error.should be_kind_of(AuthorizationError)
+          EM.stop
+        }
+      }
+    end
+      
   end
+
+  describe 'operations through the API' do
+    before :each do
+      AmazeSNS.akey = '123456'
+      AmazeSNS.skey = '123456'
+      @time_stub = stub("Time")
+      @subscriptions = {}
+      WebMock.reset!
+      WebMock.disable_net_connect!
+    end
+    
+    context 'listing topics' do
+
+      before :each do
+        # store the request and response in webmock's own blocks for comparisons
+        WebMock.after_request do |request, response|
+          @response = response
+          @request = request
+        end
+          
+        @list_data = <<-RESPONSE.gsub(/^ +/, '')
+          <ListTopicsResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/"> 
+            <ListTopicsResult>
+              <Topics> 
+                <member>
+                  <TopicArn>arn:aws:sns:us-east-1:123456789012:My-Topic</TopicArn> 
+                </member>
+              </Topics> 
+            </ListTopicsResult> 
+            <ResponseMetadata>
+              <RequestId>3f1478c7-33a9-11df-9540-99d0768312d3</RequestId> 
+            </ResponseMetadata>
+        </ListTopicsResponse>
+        RESPONSE
+
+        @regexp = %r{/?Action=ListTopics}
+      end
+      
+      use_vcr_cassette "topic/list", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should be able to get the data through the api' do
+        @time_stub.should_receive(:iso8601).and_return(123)
+        Time.stub(:now).and_return(@time_stub)
+        
+        stub_http_request(:get, @regexp).to_return(:body => @list_data,
+                                                    :status => 200,
+                                                    :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close'})
+        
+        EM.run{
+         AmazeSNS.list_topics
+         EM.stop
+        }
+        
+        WebMock.should have_requested(:get, %r{/?Action=ListTopics}).once
+        WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+
+        @request.to_s.split(" ")[1].should == "http://sns.us-east-1.amazonaws.com/?AWSAccessKeyId=123456&Action=ListTopics&Signature=ItTAjeexIPC43pHMZLCL7utnpK8j8AbTUZ3KGUSMzNc=&SignatureMethod=HmacSHA256&SignatureVersion=2&Timestamp=123"
+        @response.body.should == @list_data
+        @response.headers["Content-Type"].should == "text/xml"
+      end
+
+      it 'should populate the topics hash' do
+        AmazeSNS.topics.has_key?("My-Topic").should be_true
+      end
+      
+    end # end list topic spec
+    
+    context 'creating a topic' do
+      before :each do
+        
+        @data = <<-RESPONSE.gsub(/^ +/, '')
+          <CreateTopicResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+            <CreateTopicResult>
+              <TopicArn>arn:aws:sns:us-east-1:365155214602:MyTopic</TopicArn>
+            </CreateTopicResult>
+            <ResponseMetadata>
+              <RequestId>0a7225aa-e9cb-11df-a5a1-293a0b8d0fcb</RequestId>
+            </ResponseMetadata>
+          </CreateTopicResponse>
+        RESPONSE
+        
+        @regexp = %r{/?Action=CreateTopic&Name=MyTopic}
+      end
+      
+      use_vcr_cassette "topic/create", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should send data to the API' do
+        @time_stub.should_receive(:iso8601).and_return(123)
+        Time.stub(:now).and_return(@time_stub)
+
+        stub_http_request(:get, @regexp).to_return(:body => @data,
+                                                    :status => 200,
+                                                    :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close'})
+
+        @arn = AmazeSNS["MyTopic"].create
+        @arn.should == "arn:aws:sns:us-east-1:365155214602:MyTopic"
+        WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+      end
+      
+      it 'should add the new topic to the topics hash' do
+        AmazeSNS.topics.has_key?("MyTopic").should == true
+      end
+      
+    end # end create topic spec
+    
+    context 'getting a topic attrs' do
+      before :each do
+        @attrs_data = <<-RESPONSE.gsub(/^ +/, '')
+          <GetTopicAttributesResponse xmlns=\"http://sns.amazonaws.com/doc/2010-03-31/\">
+            <GetTopicAttributesResult>
+              <Attributes>
+                <entry>
+                  <key>Owner</key> 
+                  <value>365155214602</value>
+                </entry>
+                <entry>
+                  <key>SubscriptionsPending</key>
+                  <value>0</value>
+                </entry>
+                <entry>
+                  <key>Policy</key>
+                  <value>{   &quot;Version&quot;:&quot;2008-10-17&quot;,&quot;Id&quot;:&quot;us-east-1/365155214602/MyTopic__default_policy_ID&quot;,&quot;Statement&quot;:[{&quot;Sid&quot;:&quot;us-east-1/365155214602/MyTopic__default_statement_ID&quot;,&quot;Effect&quot;:&quot;Allow&quot;,&quot;Principal&quot;:{&quot;AWS&quot;:&quot;*&quot;},&quot;Action&quot;:[&quot;SNS:Publish&quot;,&quot;SNS:RemovePermission&quot;,&quot;SNS:SetTopicAttributes&quot;,&quot;SNS:DeleteTopic&quot;,&quot;SNS:ListSubscriptionsByTopic&quot;,&quot;SNS:GetTopicAttributes&quot;,&quot;SNS:Receive&quot;,&quot;SNS:AddPermission&quot;,&quot;SNS:Subscribe&quot;],&quot;Resource&quot;:&quot;arn:aws:sns:us-east-1:365155214602:MyTopic&quot;,&quot;Condition&quot;:{&quot;StringLike&quot;:{&quot;AWS:SourceArn&quot;:&quot;arn:aws:*:*:365155214602:*&quot;}}}]}</value>
+                  </entry>
+                  <entry>
+                    <key>SubscriptionsConfirmed</key>
+                    <value>2</value>
+                  </entry>
+                  <entry>
+                    <key>SubscriptionsDeleted</key>
+                    <value>0</value>
+                  </entry>
+                  <entry>
+                    <key>TopicArn</key>
+                    <value>arn:aws:sns:us-east-1:365155214602:MyTopic</value>
+                  </entry>
+                </Attributes>
+              </GetTopicAttributesResult>
+              <ResponseMetadata>
+                <RequestId>54c67339-0acd-11e0-8483-c91fbf41249a</RequestId>
+              </ResponseMetadata>
+          </GetTopicAttributesResponse>
+        RESPONSE
+        
+        @regexp = %r{/?Action=GetTopicAttributes}
+      end
+      
+      use_vcr_cassette "topic/attrs", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should make the API call' do
+        @time_stub.should_receive(:iso8601).and_return(123)
+        Time.stub(:now).and_return(@time_stub)
+
+        stub_http_request(:get, @regexp).to_return(:body => @attrs_data,
+                                                    :status => 200,
+                                                    :headers => {})
+        
+         AmazeSNS["MyTopic"].attrs
+         WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+         WebMock.should have_requested(:get, @regexp).once
+      end
+      
+      it 'should store its attributes into a hash' do
+        @outcome = AmazeSNS["MyTopic"].attributes
+        @outcome.should be_kind_of(Hash)
+        @outcome.has_key?("Owner").should be_true
+        @outcome.has_key?("TopicArn").should be_true
+        
+        @outcome["Owner"].should == "365155214602"
+        @outcome["TopicArn"].should == "arn:aws:sns:us-east-1:365155214602:MyTopic"
+        @outcome["Policy"]["Version"].should == "2008-10-17"
+        @outcome["Policy"]["Id"].should == "us-east-1/365155214602/MyTopic__default_policy_ID"
+        @outcome["Policy"]["Statement"][0]["Action"].should == ["SNS:Publish","SNS:RemovePermission","SNS:SetTopicAttributes","SNS:DeleteTopic","SNS:ListSubscriptionsByTopic","SNS:GetTopicAttributes","SNS:Receive","SNS:AddPermission","SNS:Subscribe"]
+        @outcome["Policy"]["Statement"][0]["Resource"].should == "arn:aws:sns:us-east-1:365155214602:MyTopic"
+      end
+      
+      
+    end # end of topic attrs
+    
+    context 'subscribing to a topic' do
+      before :each do
+         @sub_data = <<-RESPONSE.gsub(/^ +/, '')
+           <SubscribeResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/"> 
+             <SubscribeResult>
+               <SubscriptionArn>pending confirmation</SubscriptionArn> 
+              </SubscribeResult> 
+              <ResponseMetadata>
+                <RequestId>a169c740-3766-11df-8963-01868b7c937a</RequestId>
+              </ResponseMetadata>
+           </SubscribeResponse>
+          RESPONSE
+
+          @regexp = %r{/?Action=Subscribe}
+      end
+      
+      use_vcr_cassette "topic/subscribe", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should recive a pending confirmation on subscription' do
+        @time_stub.should_receive(:iso8601).and_return(123)
+        Time.stub(:now).and_return(@time_stub)
+        
+        stub_http_request(:get, @regexp).to_return(:body => @sub_data,
+                                                    :status => 200,
+                                                    :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close'})
+        
+        res = AmazeSNS["MyTopic"].subscribe(:endpoint => "example@amazon.com", :protocol => "email")
+        WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+        WebMock.should have_requested(:get, @regexp).once
+        res.should == "pending confirmation"
+      end
+    end
+    
+    context 'setting a topic attrs' do
+      before :each do
+        @data = <<-RESPONSE.gsub(/^ +/, '')
+          <SetTopicAttributesResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/"> 
+            <ResponseMetadata>
+              <RequestId>a8763b99-33a7-11df-a9b7-05d48da6f042</RequestId> 
+            </ResponseMetadata>
+          </SetTopicAttributesResponse>
+        RESPONSE
+        
+        @regexp = %r{/?Action=SetTopicAttributes}
+      end
+      
+      use_vcr_cassette "topic/set_attrs", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should set the topics attrs' do
+         @time_stub.should_receive(:iso8601).and_return(123)
+          Time.stub(:now).and_return(@time_stub)
+
+          stub_http_request(:get, @regexp).to_return(:body => @data,
+                                                      :status => 200,
+                                                      :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close','Status' => 200})
+          
+          AmazeSNS["MyTopic"].set_attrs({:name => "TopicArn", :value => 'lorem ipsum'})
+
+          WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+          WebMock.should have_requested(:get, @regexp).once
+      end
+      
+      it 'should update the attributes hash' do
+        AmazeSNS["MyTopic"].attributes["TopicArn"].should == 'lorem ipsum'
+      end
+    end
+    
+    context 'subscriptions to a topic' do
+      before :each do
+        @sub_data = <<-RESPONSE.gsub(/^ +/, '')
+          <ListSubscriptionsByTopicResponse xmlns="http://sns.amazonaws.com/ doc/2010-03-31/">
+            <ListSubscriptionsByTopicResult>
+              <Subscriptions>
+                <member> 
+                  <TopicArn>arn:aws:sns:us-east-1:123456789012:MyTopic</TopicArn> 
+                  <Protocol>email</Protocol> 
+                  <SubscriptionArn>arn:aws:sns:us-east-1:123456789012:MyTopic:80289ba6-0fd4-4079-afb4-ce8c8260f0ca</SubscriptionArn> 
+                  <Owner>123456789012</Owner>
+                  <Endpoint>example@amazon.com</Endpoint> 
+                </member>
+              </Subscriptions> 
+              </ListSubscriptionsByTopicResult> 
+              <ResponseMetadata>
+                <RequestId>b9275252-3774-11df-9540-99d0768312d3</RequestId> 
+              </ResponseMetadata>
+            </ListSubscriptionsByTopicResponse>
+        RESPONSE
+        
+        @regexp = %r{/?Action=ListSubscriptionsByTopic}
+      end
+      
+      use_vcr_cassette "topic/subscriptions", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should list the subscriptions for this topic' do
+        @time_stub.should_receive(:iso8601).and_return(123)
+        Time.stub(:now).and_return(@time_stub)
+        
+        stub_http_request(:get, @regexp).to_return(:body => @sub_data,
+                                                    :status => 200,
+                                                    :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close'})
+        
+        entry_hash = {
+                        "Owner" => "123456789012",
+                        "Endpoint" => "example@amazon.com",
+                        "Protocol" => "email",
+                        "TopicArn" => "arn:aws:sns:us-east-1:123456789012:MyTopic"
+                      }
+        subkey = "arn:aws:sns:us-east-1:123456789012:MyTopic:80289ba6-0fd4-4079-afb4-ce8c8260f0ca"
+        @subscriptions = AmazeSNS["MyTopic"].subscriptions
+        @subscriptions[subkey].should == entry_hash
+        @subscriptions[subkey]["Owner"].should == "123456789012"
+        @subscriptions[subkey]["Endpoint"].should == "example@amazon.com"
+        @subscriptions[subkey]["Protocol"].should == "email"
+        @subscriptions[subkey]["TopicArn"].should == "arn:aws:sns:us-east-1:123456789012:MyTopic"
+        
+        WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+        WebMock.should have_requested(:get, @regexp).once
+      end
+    end
+    
+    context 'unsubscribing from a topic' do
+      
+      before :each do
+        @data = <<-RESPONSE.gsub(/^ +/, '')
+          <UnsubscribeResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/"> 
+            <ResponseMetadata>
+              <RequestId>18e0ac39-3776-11df-84c0-b93cc1666b84</RequestId> 
+            </ResponseMetadata>
+          </UnsubscribeResponse>
+        RESPONSE
+        
+        @regexp = %r{/?Action=Unsubscribe}
+      end
+      
+      use_vcr_cassette "topic/unsubscribe", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should be able to remove the subscriber' do
+        @time_stub.should_receive(:iso8601).and_return(123)
+        Time.stub(:now).and_return(@time_stub)
+        
+        stub_http_request(:get, @regexp).to_return(:body => @data,
+                                                    :status => 200,
+                                                    :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close'})
+
+        
+        AmazeSNS["MyTopic"].unsubscribe('arn:aws:sns:us-east-1:123456789012:MyTopic:80289ba6-0fd4-4079-afb4-ce8c8260f0ca')
+        
+        WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+        WebMock.should have_requested(:get, @regexp).once
+      end
+      
+    end
+    
+    context 'deleting a topic' do
+      before :each do
+        @delete_data = <<-RESPONSE.gsub(/^ +/, '')
+          <DeleteTopicResponse xmlns="http://sns.amazonaws.com/doc/2010-03-31/">
+            <ResponseMetadata>
+              <RequestId>f3aa9ac9-3c3d-11df-8235-9dab105e9c32</RequestId>
+            </ResponseMetadata> 
+          </DeleteTopicResponse>
+        RESPONSE
+        
+        @regexp = %r{/?Action=DeleteTopic}
+      end
+      
+      use_vcr_cassette "topic/delete", {:record => :new_episodes, :match_requests_on => [:uri,:method,:body]}
+      
+      it 'should send data to the API' do
+        @time_stub.should_receive(:iso8601).and_return(123)
+        Time.stub(:now).and_return(@time_stub)
+        
+        stub_http_request(:get, @regexp).to_return(:body => @delete_data,
+                                                   :status => 200,
+                                                   :headers => {'Content-Type' => 'text/xml', 'Connection' => 'close'})
+        
+        @request_id = AmazeSNS["MyTopic"].delete
+        @request_id["DeleteTopicResponse"]["ResponseMetadata"]["RequestId"].should == "f3aa9ac9-3c3d-11df-8235-9dab105e9c32"
+        
+        WebMock.should have_requested(:get, @regexp).once
+        WebMock.should have_requested(:get, %r{http://sns.us-east-1.amazonaws.com:80}).once
+      end
+      
+      it 'should remove entry from the topics hash' do
+        AmazeSNS.topics.has_key?("MyTopic").should_not be_true
+      end
+      
+    end # end deleting a topic spec
   
-  describe 'when creating a topic' do
+    
   end
   
 end