bobes-textmagic 0.2.3 → 0.3.0

data/lib/error.rb

@@ -6,8 +6,8 @@ module TextMagic
 
       attr_reader :code, :message
 
-      # Creates an instance of TextMagic::API::Error. Error code and message
-      # can be supplied as arguments or as a response hash.
+      # Creates an instance of TextMagic::API::Error. Error code and error message
+      # can be supplied as arguments or in a hash.
       #
       #  TextMagic::API::Error.new(code, message)
       #  TextMagic::API::Error.new('error_code' => code, 'error_message' => message)

data/lib/response.rb

@@ -1,141 +1,64 @@
+require 'ostruct'
+
 module TextMagic
 
   class API
 
-    # Used to cleanup response hash and extend it with custom reader methods.
-    #
-    # === Account response hash
-    #
-    # When extended, it
-    # * converts the +balance+ value to +float+ and
-    # * adds a reader method +balance+.
-    #
-    # === Send response hash
-    #
-    # When extended, it
-    # * inverts the +message_id+ hash and puts it in +message_id_hash+,
-    # * adds an array of ids to +message_ids+,
-    # * adds reader methods +message_id_hash+, +message_ids+, +sent_text+ and
-    #   +parts_count+ to the hash.
-    # * adds a reader method +message_id+, which returns a +message_id+ for
-    #   a given phone number, or the first message_id if no phone number
-    #   is specified.
-    #
-    # === Message status response hash
-    #
-    # When extended, it
-    # * converts the +credits_cost+ value to +float+,
-    # * converts the +created_time+ and +completed_time+ values to +Time+,
-    # * adds reader methods +text+, +status+, +reply_number+, +credits_cost+,
-    #   +created_time+ and +completed_time+ to all values of the hash.
-    #
-    # === Receive status response hash
-    #
-    # When extended, it
-    # * converts the +timestamp+ value to +Time+,
-    # * adds reader methods +messages+ and +unread+ to the hash
-    # * adds reader methods +message_id+, +timestamp+, +text+ and +from+
-    #   to all members of the +messages+ array.
-    #
-    # === Delete reply response hash
-    #
-    # When extended, it
-    # * adds a reader method +deleted+.
-    module Response
-
-      module Account #:nodoc: all
-
-        def self.extended(base)
-          return unless base.is_a?(Hash)
-          base['balance'] = base['balance'].to_f if base['balance']
-        end
-
-        def balance
-          self['balance']
-        end
-      end
-
-      module Send #:nodoc: all
-
-        def self.extended(base)
-          return unless base.is_a?(Hash) && base['message_id']
-          base['message_ids'] = base['message_id'].keys.sort
-          base.merge! base.delete('message_id').invert
-        end
-
-        %w(message_ids sent_text parts_count).each do |method|
-          module_eval <<-EOS
-          def #{method}
-            self['#{method}']
-          end
-          EOS
-        end
+    class Response
 
-        def message_id(phone = nil)
-          phone ? self[phone] : self['message_ids'].first
-        end
+      def self.account(hash)
+        response = OpenStruct.new(hash)
+        response.balance = response.balance.to_f
+        response
       end
 
-      module MessageStatus #:nodoc: all
-
-        def self.extended(base)
-          return unless base.is_a?(Hash)
-          base.values.each do |status|
-            status['credits_cost'] = status['credits_cost'].to_f if status['credits_cost']
-            status['created_time'] = Time.at(status['created_time'].to_i) if status['created_time']
-            status['completed_time'] = Time.at(status['completed_time'].to_i) if status['completed_time']
-            status.extend Status
-          end
-        end
-
-        module Status
-
-          %w(text status reply_number credits_cost created_time completed_time).each do |method|
-            module_eval <<-EOS
-            def #{method}
-              self['#{method}']
-            end
-            EOS
-          end
+      def self.send(hash, single)
+        response = nil
+        if single
+          response = hash['message_id'].keys.first.dup
+        else
+          response = hash['message_id'].invert
         end
+        metaclass = class << response; self; end
+        metaclass.send :attr_accessor, :sent_text, :parts_count, :message_id
+        response.sent_text = hash['sent_text']
+        response.parts_count = hash['parts_count']
+        response.message_id = hash['message_id']
+        response
       end
 
-      module Receive #:nodoc: all
-
-        def self.extended(base)
-          return unless base.is_a?(Hash) && base['messages']
-          base['message_ids'] = base['messages'].collect { |message| message['message_id'] }.sort
-          base['messages'].each do |message|
-            message['timestamp'] = Time.at(message['timestamp'].to_i) if message['timestamp']
-            message.extend Message
-          end
-        end
-
-        %w(messages message_ids unread).each do |method|
-          module_eval <<-EOS, __FILE__, __LINE__ + 1
-          def #{method}
-            self['#{method}']
-          end
-          EOS
-        end
-
-        module Message
-
-          %w(message_id timestamp text from).each do |method|
-            module_eval <<-EOS
-            def #{method}
-              self['#{method}']
-            end
-            EOS
-          end
+      def self.message_status(hash, single)
+        response = {}
+        hash.each do |message_id, message_hash|
+          status = message_hash['status'].dup
+          metaclass = class << status; self; end
+          metaclass.send :attr_accessor, :text, :credits_cost, :reply_number, :message_status, :created_time, :completed_time
+          status.text = message_hash['text']
+          status.credits_cost = message_hash['credits_cost']
+          status.reply_number = message_hash['reply_number']
+          status.message_status = message_hash['message_status']
+          status.created_time = Time.at(message_hash['created_time'].to_i) if message_hash['created_time']
+          status.completed_time = Time.at(message_hash['completed_time'].to_i) if message_hash['completed_time']
+          response[message_id] = status
         end
+        single ? response.values.first : response
       end
 
-      module DeleteReply #:nodoc: all
-
-        def deleted
-          self['deleted']
+      def self.receive(hash)
+        response = hash['messages'].collect do |message_hash|
+          message = "#{message_hash['from']}: #{message_hash['text']}"
+          metaclass = class << message; self; end
+          metaclass.send :attr_accessor, :timestamp, :message_id, :text, :from
+          message.text = message_hash['text']
+          message.from = message_hash['from']
+          message.message_id = message_hash['message_id']
+          message.timestamp = Time.at(message_hash['timestamp'].to_i)
+          message
         end
+        metaclass = class << response; self; end
+        metaclass.send :attr_accessor, :unread
+        response.unread = hash['unread']
+        response
       end
     end
   end

data/test/test_api.rb

@@ -13,27 +13,23 @@ class APITest < Test::Unit::TestCase
   context 'Account command' do
 
     setup do
-      @balance = 0.01 * rand(1e4)
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
+      @response = random_string
+      @processed_response = random_string
+      TextMagic::API::Executor.stubs(:execute).returns(@response)
+      TextMagic::API::Response.stubs(:account).returns(@processed_response)
     end
 
     should 'call Executor execute with correct arguments' do
-      TextMagic::API::Executor.expects(:execute).with('account', @username, @password).returns({})
+      TextMagic::API::Executor.expects(:execute).with('account', @username, @password).returns(@response)
       @api.account
     end
 
-    should 'return a hash extended with TextMagic::API::Response::Account' do
-      TextMagic::API::Executor.expects(:execute).returns({ 'balance' => @balance.to_s })
-      response = @api.account
-      response.class.should == Hash
-      response.is_a?(TextMagic::API::Response::Account).should == true
-    end
-
-    should 'return a hash with balance value' do
-      TextMagic::API::Executor.expects(:execute).returns({ 'balance' => @balance.to_s })
-      response = @api.account
-      response['balance'].should be_close(@balance, 1e-10)
+    should 'call Response.account method to process the response hash' do
+      processed_response = rand
+      TextMagic::API::Response.expects(:account).with(@response).returns(processed_response)
+      @api.account.should == processed_response
     end
   end
 
@@ -43,33 +39,36 @@ class APITest < Test::Unit::TestCase
       @username, @password = random_string, random_string
       @text, @phone = random_string, random_phone
       @api = TextMagic::API.new(@username, @password)
-      TextMagic::API::Executor.stubs(:execute)
+      @response = random_string
+      @processed_response = random_string
+      TextMagic::API::Executor.stubs(:execute).returns(@response)
+      TextMagic::API::Response.stubs(:send).returns(@processed_response)
     end
 
     should 'call Executor execute with correct arguments' do
-      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 0)
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 0).returns(@response)
       @api.send(@text, @phone)
     end
 
     should 'join multiple phone numbers supplied as an array' do
       phones = Array.new(3) { random_phone }
-      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => phones.join(','), :unicode => 0)
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => phones.join(','), :unicode => 0).returns(@response)
       @api.send(@text, phones)
     end
 
     should 'join multiple phone numbers supplied as arguments' do
       phones = Array.new(3) { random_phone }
-      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => phones.join(','), :unicode => 0)
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => phones.join(','), :unicode => 0).returns(@response)
       @api.send(@text, *phones)
     end
 
     should 'replace true with 1 for unicode' do
-      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 1)
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 1).returns(@response)
       @api.send(@text, @phone, :unicode => true)
     end
 
     should 'set unicode value to 0 if it is not set to by user and text contains only characters from GSM 03.38 charset' do
-      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 0).times(2)
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 0).returns(@response).times(2)
       @api.send(@text, @phone)
       @api.send(@text, @phone, :unicode => false)
     end
@@ -103,21 +102,17 @@ class APITest < Test::Unit::TestCase
       lambda { @api.send(@text, @phone) }.should raise_error(TextMagic::API::Error)
     end
 
-    should 'return a hash extended with TextMagic::API::Response::Send' do
-      message_id = random_string
-      TextMagic::API::Executor.expects(:execute).returns({ 'message_id' => { message_id => @phone }, 'sent_text' => @text, 'parts_count' => 1 })
-      response = @api.send(@text, @phone)
-      response.class.should == Hash
-      response.is_a?(TextMagic::API::Response::Send).should == true
+    should 'call Response.send method to process the response hash (single phone)' do
+      processed_response = rand
+      TextMagic::API::Response.expects(:send).with(@response, true).returns(processed_response)
+      @api.send(@text, random_phone).should == processed_response
     end
 
-    should 'return a hash with message_ids, sent_text and parts_count values' do
-      message_id = random_string
-      TextMagic::API::Executor.expects(:execute).returns({ 'message_id' => { message_id => @phone }, 'sent_text' => @text, 'parts_count' => 1 })
-      response = @api.send(@text, @phone)
-      response['message_ids'].should == [message_id]
-      response['sent_text'].should == @text
-      response['parts_count'].should == 1
+    should 'call Response.send method to process the response hash (multiple phones)' do
+      processed_response = rand
+      TextMagic::API::Response.expects(:send).with(@response, false).returns(processed_response).twice
+      @api.send(@text, [random_phone]).should == processed_response
+      @api.send(@text, random_phone, random_phone).should == processed_response
     end
   end
 
@@ -126,15 +121,16 @@ class APITest < Test::Unit::TestCase
     setup do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
-      @id = random_string
-      @status = { 'text' => 'Hi Vilma', 'status' => 'd' , 'created_time' => Time.now.to_i, 'reply_number' => '447624800500', 'completed_time' => nil, 'credits_cost' => 0.5 }
-      @response = { @id => @status }
-      TextMagic::API::Executor.stubs(:execute)
+      @response = random_string
+      @processed_response = random_string
+      TextMagic::API::Executor.stubs(:execute).returns(@response)
+      TextMagic::API::Response.stubs(:message_status).returns(@processed_response)
     end
 
     should 'call Executor execute with correct arguments' do
-      TextMagic::API::Executor.expects(:execute).with('message_status', @username, @password, :ids => @id).returns(@response)
-      @api.message_status(@id)
+      id = random_string
+      TextMagic::API::Executor.expects(:execute).with('message_status', @username, @password, :ids => id).returns(@response)
+      @api.message_status(id)
     end
 
     should 'join ids supplied as array' do
@@ -154,43 +150,15 @@ class APITest < Test::Unit::TestCase
       lambda { @api.message_status }.should raise_error(TextMagic::API::Error)
     end
 
-    should 'return a hash extended with TextMagic::API::Response::MessageStatus for an array of ids' do
-      TextMagic::API::Executor.expects(:execute).returns(@response)
-      response = @api.message_status([@id])
-      response.class.should == Hash
-      response.is_a?(TextMagic::API::Response::MessageStatus).should == true
-    end
-
-    should 'return a hash with message ids as keys for an array of ids' do
-      TextMagic::API::Executor.expects(:execute).returns(@response)
-      response = @api.message_status([@id])
-      response[@id].should == @status
-    end
-
-    should 'return a hash extended with TextMagic::API::Response::MessageStatus for a list of ids' do
-      TextMagic::API::Executor.expects(:execute).returns(@response)
-      response = @api.message_status(@id, random_string)
-      response.class.should == Hash
-      response.is_a?(TextMagic::API::Response::MessageStatus).should == true
-    end
-
-    should 'return a hash with message ids as keys for a list of ids' do
-      TextMagic::API::Executor.expects(:execute).returns(@response)
-      response = @api.message_status(@id, random_string)
-      response[@id].should == @status
+    should 'call Response.message_status method to process the response hash (single id)' do
+      TextMagic::API::Response.expects(:message_status).with(@response, true).returns(@processed_response)
+      @api.message_status(random_string).should == @processed_response
     end
 
-    should 'return a hash extended with TextMagic::API::Response::MessageStatus::Status for a single id' do
-      TextMagic::API::Executor.expects(:execute).returns(@response)
-      response = @api.message_status(@id)
-      response.class.should == Hash
-      response.is_a?(TextMagic::API::Response::MessageStatus::Status).should == true
-    end
-
-    should 'return a hash with message ids as keys for a single id' do
-      TextMagic::API::Executor.expects(:execute).returns(@response)
-      response = @api.message_status(@id)
-      response.should == @status
+    should 'call Response.message_status method to process the response hash (multiple ids)' do
+      TextMagic::API::Response.expects(:message_status).with(@response, false).returns(@processed_response).twice
+      @api.message_status([random_string]).should == @processed_response
+      @api.message_status(random_string, random_string).should == @processed_response
     end
   end
 
@@ -199,6 +167,10 @@ class APITest < Test::Unit::TestCase
     setup do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
+      @response = random_string
+      @processed_response = random_string
+      TextMagic::API::Executor.stubs(:execute).returns(@response)
+      TextMagic::API::Response.stubs(:receive).returns(@processed_response)
     end
 
     should 'call Executor execute with correct arguments' do
@@ -212,18 +184,9 @@ class APITest < Test::Unit::TestCase
       @api.receive(last_retrieved_id)
     end
 
-    should 'return a hash extended with TextMagic::API::Response::Receive' do
-      TextMagic::API::Executor.expects(:execute).returns({ 'messages' => [], 'unread' => 0 })
-      response = @api.receive
-      response.class.should == Hash
-      response.is_a?(TextMagic::API::Response::Receive).should == true
-    end
-
-    should 'return a hash with unread and messages values' do
-      TextMagic::API::Executor.expects(:execute).returns({ 'messages' => [], 'unread' => 0 })
-      response = @api.receive
-      response['unread'].should == 0
-      response['messages'].should == []
+    should 'call Response.receive method to process the response hash' do
+      TextMagic::API::Response.expects(:receive).with(@response).returns(@processed_response)
+      @api.receive(random_string).should == @processed_response
     end
   end
 
@@ -232,6 +195,10 @@ class APITest < Test::Unit::TestCase
     setup do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
+      @response = random_string
+      @processed_response = random_string
+      TextMagic::API::Executor.stubs(:execute).returns(@response)
+      TextMagic::API::Response.stubs(:delete_reply).returns(@processed_response)
     end
 
     should 'call Executor execute with correct arguments' do
@@ -257,19 +224,8 @@ class APITest < Test::Unit::TestCase
       lambda { @api.delete_reply }.should raise_error(TextMagic::API::Error)
     end
 
-    should 'return a hash extended with TextMagic::API::Response::DeleteReply' do
-      ids = Array.new(3) { random_string }
-      TextMagic::API::Executor.expects(:execute).returns({ 'deleted' => ids })
-      response = @api.delete_reply(ids)
-      response.class.should == Hash
-      response.is_a?(TextMagic::API::Response::DeleteReply).should == true
-    end
-
-    should 'return a hash with deleted value' do
-      ids = Array.new(3) { random_string }
-      TextMagic::API::Executor.expects(:execute).returns({ 'deleted' => ids })
-      response = @api.delete_reply(ids)
-      response.deleted.should == ids
+    should 'return true' do
+      @api.delete_reply(random_string).should == true
     end
   end
 end

data/test/test_response.rb

@@ -2,175 +2,223 @@ require 'test_helper'
 
 class ResponseTest < Test::Unit::TestCase
 
-  context 'Account response' do
+  context 'Response to account command' do
 
     setup do
       @balance = 0.1 * rand(1e4)
-      @response = { 'balance' => @balance.to_s }
-      @response.extend TextMagic::API::Response::Account
+      @hash = { 'balance' => @balance.to_s }
+      @response = TextMagic::API::Response.account(@hash)
     end
 
-    should 'allow access to balance' do
+    should 'be an OpenStruct instance' do
+      @response.class.should == OpenStruct
+    end
+
+    should 'have balance' do
       @response.balance.should be_close(@balance, 1e-10)
     end
   end
 
-  context 'Send response' do
+  context 'Response to send command with single phone number' do
 
     setup do
-      @message_id = {
-        '141421' => '999314159265',
-        '173205' => '999271828182'
-      }
+      @message_id, @phone = random_string, random_phone
       @text = random_string
-      @parts_count = rand(10)
-      @response = {
-        'message_id' => @message_id,
-        'sent_text' => @text,
-        'parts_count' => @parts_count
-      }
-      @response.extend TextMagic::API::Response::Send
+      @parts_count = 1 + rand(3)
+      @hash = { 'message_id' => { @message_id => @phone }, 'sent_text' => @text, 'parts_count' => @parts_count }
+      @response = TextMagic::API::Response.send(@hash, true)
+    end
+
+    should 'equal to the message_id' do
+      @response.should == @message_id
+    end
+
+    should 'have sent_text' do
+      @response.sent_text.should == @text
+    end
+
+    should 'have parts_count' do
+      @response.parts_count.should == @parts_count
+    end
+  end
+
+  context 'Response to send command with multiple phone numbers' do
+
+    setup do
+      @message_id1, @phone1 = random_string, random_phone
+      @message_id2, @phone2 = random_string, random_phone
+      @text = random_string
+      @parts_count = 1 + rand(3)
+      @hash = { 'message_id' => { @message_id1 => @phone1, @message_id2 => @phone2 }, 'sent_text' => @text, 'parts_count' => @parts_count }
+      @response = TextMagic::API::Response.send(@hash, false)
+    end
+
+    should 'be a hash' do
+      @response.class.should == Hash
     end
 
-    should 'allow access to message_ids array' do
-      @response.message_ids.should == ['141421', '173205']
+    should 'have phone numbers as keys' do
+      @response.keys.sort.should == [@phone1, @phone2].sort
     end
 
-    should 'allow access to message_id for a given phone number' do
-      @response['999314159265'].should == '141421'
-      @response['999271828182'].should == '173205'
+    should 'have message ids as values' do
+      @response[@phone1].should == @message_id1
+      @response[@phone2].should == @message_id2
     end
 
-    should 'allow access to sent_text' do
+    should 'have sent_text' do
       @response.sent_text.should == @text
     end
 
-    should 'allow access to parts_count' do
+    should 'have parts_count' do
       @response.parts_count.should == @parts_count
     end
   end
 
-  context 'MessageStatus response' do
+  context 'Response to message_status command with single id' do
 
     setup do
       @text = random_string
+      @status = random_string
       @reply_number = random_phone
       @created_time = (Time.now - 30).to_i
       @completed_time = (Time.now - 20).to_i
       @credits_cost = 0.01 * rand(300)
-      @response = {
+      @hash = {
         '141421' => {
           'text' => @text,
-          'status' => 'd',
-          'created_time' => @created_time,
+          'status' => @status,
+          'created_time' => @created_time.to_s,
           'reply_number' => @reply_number,
-          'completed_time' => @completed_time,
+          'completed_time' => @completed_time.to_s,
           'credits_cost' => @credits_cost
-        },
-        '173205' => {
-          'text' => 'test',
-          'status' => 'r',
-          'created_time' => '1242979839',
-          'reply_number' => '447624800500',
-          'completed_time' => nil,
-          'credits_cost' => 0.5
         }
       }
-      @response.extend TextMagic::API::Response::MessageStatus
+      @response = TextMagic::API::Response.message_status(@hash, true)
     end
 
-    should 'allow access to text for all statuses' do
-      @response['141421'].text.should == @text
-      @response['173205'].text.should == 'test'
+    should 'equal to the message status' do
+      @response.should == @status
     end
 
-    should 'allow access to status for a given message_id' do
-      @response['141421'].status.should == 'd'
-      @response['173205'].status.should == 'r'
+    should 'have text' do
+      @response.text.should == @text
     end
 
-    should 'allow access to reply_number for a given message_id' do
-      @response['141421'].reply_number.should == @reply_number
-      @response['173205'].reply_number.should == '447624800500'
+    should 'have created_time' do
+      @response.created_time.should == Time.at(@created_time)
     end
 
-    should 'allow access to created_time for a given message_id' do
-      @response['141421'].created_time.should == Time.at(@created_time)
-      @response['173205'].created_time.should == Time.at(1242979839)
+    should 'have completed_time' do
+      @response.completed_time.should == Time.at(@completed_time)
     end
 
-    should 'allow access to completed_time for a given message_id' do
-      @response['141421'].completed_time.should == Time.at(@completed_time)
-      @response['173205'].completed_time.should == nil
+    should 'have reply_number' do
+      @response.reply_number.should == @reply_number
     end
 
-    should 'allow access to credits_cost for a given message_id' do
-      @response['141421'].credits_cost.should be_close(@credits_cost, 1e-10)
-      @response['173205'].credits_cost.should be_close(0.5, 1e-10)
+    should 'have credits_cost' do
+      @response.credits_cost.should be_close(@credits_cost, 1e-10)
     end
   end
-
-  context 'Receive response' do
+  
+  context 'Response to message_status command with multiple ids' do
 
     setup do
-      @timestamp = (Time.now - 30).to_i
-      @message1 = {
-        'timestamp' => @timestamp,
-        'from' => '999314159265',
-        'text' => 'Hi Fred',
-        'message_id' => '141421'
-      }
-      @message2 = {
-        'timestamp' => 1243244148,
-        'from' => '999271828182',
-        'text' => 'Hello buddy',
-        'message_id' => '173205'
+      @text = random_string
+      @status = random_string
+      @reply_number = random_phone
+      @created_time = (Time.now - 30).to_i
+      @completed_time = (Time.now - 20).to_i
+      @credits_cost = 0.01 * rand(300)
+      @hash = {
+        '141421' => {
+          'text' => @text,
+          'status' => @status,
+          'created_time' => @created_time,
+          'reply_number' => @reply_number,
+          'completed_time' => @completed_time,
+          'credits_cost' => @credits_cost
+        }
       }
-      @messages = [@message1, @message2]
-      @unread = rand(1e4)
-      @response = { 'unread' => @unread, 'messages' => @messages }
-      @response.extend TextMagic::API::Response::Receive
+      @response = TextMagic::API::Response.message_status(@hash, false)
     end
 
-    should 'allow access to unread' do
-      @response.unread.should == @unread
+    should 'be a hash' do
+      @response.class.should == Hash
+    end
+
+    should 'have message_ids as keys' do
+      @response.keys.should == ['141421']
     end
 
-    should 'allow access to messages array' do
-      @response.messages.should == @messages
+    should 'contain statuses' do
+      @response.values.first.should == @status
     end
 
-    should 'allow access to message_ids array' do
-      @response.message_ids.should == ['141421', '173205']
+    should 'have text for all statuses' do
+      @response.values.first.text.should == @text
     end
 
-    should 'allow access to message_id for all messages' do
-      @response.messages.first.message_id.should == '141421'
+    should 'have created_time for all statuses' do
+      @response.values.first.created_time.should == Time.at(@created_time)
     end
 
-    should 'allow access to timestamp for all messages' do
-      @response.messages.first.timestamp.should == Time.at(@timestamp)
+    should 'have completed_time for all statuses' do
+      @response.values.first.completed_time.should == Time.at(@completed_time)
     end
 
-    should 'allow access to from for all messages' do
-      @response.messages.first.from.should == '999314159265'
+    should 'have reply_number for all statuses' do
+      @response.values.first.reply_number.should == @reply_number
     end
 
-    should 'allow access to text for all messages' do
-      @response.messages.first.text.should == 'Hi Fred'
+    should 'have credits_cost for all statuses' do
+      @response.values.first.credits_cost.should be_close(@credits_cost, 1e-10)
     end
   end
 
-  context 'DeleteReply response' do
+  context 'Response to receive command' do
 
     setup do
-      @ids = ['141421', '1780826']
-      @response = { 'deleted' => @ids }
-      @response.extend TextMagic::API::Response::DeleteReply
+      @timestamp = (Time.now - 30).to_i
+      @text, @phone, @message_id = random_string, random_phone, random_string
+      @message = {
+        'timestamp' => @timestamp,
+        'from' => @phone,
+        'text' => @text,
+        'message_id' => @message_id
+      }
+      @unread = rand(1e4)
+      @hash = { 'unread' => @unread, 'messages' => [@message] }
+      @response = TextMagic::API::Response.receive(@hash)
+    end
+
+    should 'have unread' do
+      @response.unread.should == @unread
+    end
+
+    should 'be an array' do
+      @response.class.should == Array
+    end
+
+    should 'contain strings with phones numbers and texts' do
+      @response.first.should == "#{@phone}: #{@text}"
+    end
+
+    should 'have timestamp for all messages' do
+      @response.first.timestamp.should == Time.at(@timestamp)
+    end
+
+    should 'have from for allmessages' do
+      @response.first.from.should == @phone
+    end
+
+    should 'have text for all messages' do
+      @response.first.text.should == @text
     end
 
-    should 'allow access to deleted' do
-      @response.deleted.should == @ids
+    should 'have message_id for all messages' do
+      @response.first.message_id.should == @message_id
     end
   end
 end