hashblue-api 0.0.8 → 0.1.1

data/Rakefile

@@ -17,7 +17,7 @@ spec = Dir.chdir(path) do
 
     # Change these as appropriate
     s.name              = "hashblue-api"
-    s.version           = "0.0.8"
+    s.version           = "0.1.1"
     s.summary           = "It's the Hashblue API, stupid!"
     s.author            = "FreeRange"
     s.email             = "lets@gofreerange.com"

data/hashblue-api.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hashblue-api}
-  s.version = "0.0.8"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["FreeRange"]
-  s.date = %q{2010-05-06}
+  s.date = %q{2010-05-19}
   s.email = %q{lets@gofreerange.com}
   s.extra_rdoc_files = [
     "README"

data/lib/hashblue/api.rb

@@ -58,22 +58,10 @@ module Hashblue
     autoload :Subscriber, 'hashblue/api/subscriber'
     autoload :Error, 'hashblue/api/error'
     autoload :TestHelper, 'hashblue/api/test_helper'
-
-    # Raised when the API fails to respond with a timeout. The timeout
-    # can be set using Hashblue::API.timeout
-    class NotRespondingError < StandardError; end
-    # Raised when the API responded in a way that we couldn't handle.
-    class BadResponseError < Hashblue::API::Error; end
-    # Raised when the object requested cannot be found.
-    class NotFoundError < Hashblue::API::Error; end
-    # Raised when the object requested is not available given the
-    # credentials used; most often is is because a Contact or Message
-    # belongs to a different Subscriber
-    class AccessDeniedError < Hashblue::API::Error
-      def status
-        :unauthorized
-      end
-    end
+    autoload :NotRespondingError, 'hashblue/api/error'
+    autoload :BadResponseError, 'hashblue/api/error'
+    autoload :NotFoundError, 'hashblue/api/error'
+    autoload :AccessDeniedError, 'hashblue/api/error'
 
     # Sets the timeout used before raising an error.
     def self.timeout(value)

data/lib/hashblue/api/error.rb

@@ -1,39 +1,77 @@
 # The base Hashblue Error class, which will be sent serialized
 # as JSON from the API itself.
-class Hashblue::API::Error < StandardError
-  def self.from_response(response)
-    if response.json? && response.keys == ["error"]
-      response["error"].keys.first.constantize.new(response["error"].values.first)
-    elsif response.code == 401
-      Hashblue::API::AccessDeniedError.new(response)
-    else
-      Hashblue::API::BadResponseError.new(response)
-    end
-  end
+module Hashblue
+  module API
+    class Error < StandardError
+      def self.status(return_status)
+        define_method(:status) { return_status }
+      end
 
-  def initialize(response)
-    if response.respond_to?(:body)
-      @body = response.body
-      @headers = response.headers
-    else
-      @response = response
-    end
-  end
+      def self.from_response(response)
+        if response.json? && response.keys == ["error"]
+          response["error"].keys.first.constantize.new(response["error"].values.first)
+        elsif response.code == 401
+          Hashblue::API::AccessDeniedError.new(response)
+        else
+          Hashblue::API::BadResponseError.new(response)
+        end
+      end
 
-  def status
-    :not_found
-  end
+      def initialize(response)
+        if response.respond_to?(:body)
+          @body = response.body
+          @headers = response.headers
+        else
+          @response = response
+        end
+      end
+
+      def status
+        :not_found
+      end
 
-  def to_s
-    str = "<##{self.class.name}:#{self.object_id}"
-    if @body && @headers
-      str + "@headers=#{@headers.inspect} @body=#{@body.inspect}>"
-    else
-      str + "@resposne=#{@response.inspect}>"
+      def to_s
+        str = "<##{self.class.name}:#{self.object_id}"
+        if @body && @headers
+          str + "@headers=#{@headers.inspect} @body=#{@body.inspect}>"
+        else
+          str + "@response=#{@response.inspect}>"
+        end
+      end
+
+      def to_json
+        {self.class.name => self.message}
+      end
     end
-  end
 
-  def to_json
-    {self.class.name => self.message}
+    # Raised when the API fails to respond with a timeout. The timeout
+    # can be set using Hashblue::API.timeout
+    class NotRespondingError < StandardError; end
+    # Raised when the API responded in a way that we couldn't handle.
+    class BadResponseError < Hashblue::API::Error; end
+    # Raised when the object requested cannot be found.
+    class NotFoundError < Hashblue::API::Error; end
+    # Raised when the object requested is not available given the
+    # credentials used; most often is is because a Contact or Message
+    # belongs to a different Subscriber
+    class AccessDeniedError < Hashblue::API::Error
+      status :unauthorized
+    end
+    # Raised when a subscriber has reached the limit of messages they
+    # can send.
+    class RateLimitError < Hashblue::API::Error
+      status :service_unavailable
+      def message
+        @response
+      end
+    end
+    # Raised when the request was malformed (e.g. bad parameters)
+    class BadRequestError < Hashblue::API::Error
+      status :bad_request
+    end
+    # Raised when the API is unable to fulfil a request
+    class ServiceUnavailableError < Hashblue::API::Error
+      status :service_unavailable
+    end
   end
 end

data/lib/hashblue/api/message.rb

@@ -1,7 +1,7 @@
 require 'hashblue/api'
 
 # A Message represents an SMS either sent or received by this Subscriber.
-# It should not be instantiated directly; Messages can be loaded either 
+# It should not be instantiated directly; Messages can be loaded either
 # using Subscriber#messages, or Contact#messages.
 class Hashblue::API::Message < Hashblue::API::Model
   # Deletes a specific message. Note that you must be authenticated as the
@@ -11,6 +11,18 @@ class Hashblue::API::Message < Hashblue::API::Model
     Hashblue::API.delete("/subscribers/#{subscriber_id}/messages/#{id}.json")
   end
 
+  # Favourites a specific message. You must be authenticated as the Subscriber
+  # in order to favourite a message; otherwise an AccessDeniedError will be
+  # raised.
+  def self.favourite(subscriber_id, id)
+    Hashblue::API.post("/subscribers/#{subscriber_id}/favourites.json", :query => {:id => id})
+  end
+
+  # Un Favourite a specific message. Once authenticated this will mark a message as not a favourite
+  def self.unfavourite(subscriber_id, id)
+    Hashblue::API.delete("/subscribers/#{subscriber_id}/favourites/#{id}.json")
+  end
+
   #:nodoc:
   def initialize(attributes = {})
     super

data/lib/hashblue/api/model.rb

@@ -18,11 +18,11 @@ class Hashblue::API::Model #:nodoc:all
       @partial_path = "#{@collection}/#{@element}".freeze
     end
   end
-  
+
   def self.model_name
     @_model_name ||= Name.new(self.name.from(15))
   end
-  
+
   def self.from_json(models)
     models.map do |attributes|
       new(attributes)
@@ -52,4 +52,8 @@ class Hashblue::API::Model #:nodoc:all
   def get(path, query_options={})
     Hashblue::API.get(path, :query => query_options)
   end
+
+  def post(path, query_options = {})
+    Hashblue::API.post(path, :query => query_options)
+  end
 end

data/lib/hashblue/api/request.rb

@@ -7,6 +7,10 @@ module Hashblue::API::Request #:nodoc:all
     _request { super }
   end
 
+  def post(path, options={})
+    _request { super }
+  end
+
   def _request
     _with_timeout do
       response = Response.new(yield)
@@ -26,7 +30,7 @@ module Hashblue::API::Request #:nodoc:all
 
   class Response < DelegateClass(HTTParty::Response)
     def success?
-      code == 200
+      code == 200 || code == 201
     end
 
     def json?

data/lib/hashblue/api/subscriber.rb

@@ -47,6 +47,15 @@ class Hashblue::API::Subscriber < Hashblue::API::Model
     Hashblue::API::Message.from_json(get("#{_path}/messages.json", options))
   end
 
+  # Returns an Array of Message objects for the subscriber that are marked as favourites
+  #
+  # All messages that are marked as favourites are included in the returned Array.
+  #
+  # See above for possible options this method takes.
+  def favourites(options={})
+    Hashblue::API::Message.from_json(get("#{_path}/favourites.json", options))
+  end
+
   # Returns an Array of Message objects for the Subscriber.
   #
   # All messages that have been deleted for all contacts are included in
@@ -57,6 +66,16 @@ class Hashblue::API::Subscriber < Hashblue::API::Model
     Hashblue::API::Message.from_json(get("#{_path}/messages/deleted.json", options))
   end
 
+  # Send a message from the Subscriber to the given number.
+  #
+  # The sent message will be returned if it was successfully sent. The contact_msisdn
+  # should be in the form "447#########".
+  def send_message(contact_msisdn, content)
+    result = post("#{_path}/messages.json", :message => {:content => content,
+                  :contact_msisdn => contact_msisdn} )
+    Hashblue::API::Message.new(result)
+  end
+
   private
 
   def _path

data/lib/hashblue/api/test_helper.rb

@@ -24,31 +24,35 @@ require 'json'
 # The test helper will ensure that the data you are passing to +stub_hashblue_api+
 # matches the data that will be returned to your application by the API.
 module Hashblue::API::TestHelper
-  API_KEYS = %w(contact_msisdn content timestamp id sent).map(&:to_sym)
+  API_KEYS = %w(contact_msisdn content timestamp id sent favourite).map(&:to_sym)
 
   def stub_hashblue_api(subscriber_id, options={})
-    options.reverse_merge!(:contacts => [], :messages => [])
+    options.reverse_merge!(:contacts => [], :messages => [], :favourites => [])
 
-    messages = options[:messages].map do |attributes|
-      {:id => __next_firehose_id, :content => "Hello", :contact_msisdn => "123",
-       :subscriber_id => subscriber_id, :sent => false,
-       :timestamp => Time.zone.now.to_json}.merge(prepare_and_check_attributes(attributes))
+    options[:messages] = options[:messages].map do |attributes|
+      build_hashblue_api_message(subscriber_id, attributes)
     end
 
-    messages.each do |message|
+    favourites = []
+    options[:messages].each do |message|
       Hashblue::API.stubs(:delete).with("/subscribers/#{subscriber_id}/messages/#{message[:id]}.json")
+      Hashblue::API.stubs(:post).with("/subscribers/#{subscriber_id}/favourites.json",
+        :query => {:id => message[:id]}).returns(message)
+      if message[:favourite] == true
+        Hashblue::API.stubs(:delete).with("/subscribers/#{subscriber_id}/favourites/#{message[:id]}.json")
+        favourites << message
+      end
     end
 
-    if options[:q]
-      search_results = messages.select { |message| message[:content][/#{options[:q]}/] }
-      Hashblue::API.stubs(:get).with("/subscribers/#{subscriber_id}/messages.json",
-        {:query => {:q => options[:q]}}).returns(search_results)
-      Hashblue::API.stubs(:get).with("/subscribers/#{subscriber_id}/messages.json", {:query => {}}).returns(messages)
-    else
-      Hashblue::API.stubs(:get).with("/subscribers/#{subscriber_id}/messages.json", anything).returns(messages)
-    end
+    Hashblue::API.stubs(:post).with("/subscribers/#{subscriber_id}/messages.json", anything).returns(
+      {:content => "sent message", :to=>"123", :sent => true}
+    )
+
+    Hashblue::API.stubs(:get).with("/subscribers/#{subscriber_id}/favourites.json", anything).returns(favourites)
 
-    contacts = messages.group_by { |m| m[:contact_msisdn] }.map do |msisdn, contact_messages|
+    Hashblue::API.stubs(:get).with("/subscribers/#{subscriber_id}/messages.json", anything).returns(options[:messages])
+
+    contacts = options[:messages].group_by { |m| m[:contact_msisdn] }.map do |msisdn, contact_messages|
       explicit_contact = options[:contacts].find { |c| c[:msisdn] == msisdn }
       id = explicit_contact ? explicit_contact[:id] : __next_firehose_id
 
@@ -59,7 +63,7 @@ module Hashblue::API::TestHelper
     end
 
     contacts_with_no_messages = options[:contacts].reject do |contact|
-      messages.find { |m| m[:contact_msisdn] == contact[:msisdn] }
+      options[:messages].find { |m| m[:contact_msisdn] == contact[:msisdn] }
     end.map do |contact|
       {:latest_message => nil, :id => __next_firehose_id}.merge(contact)
     end
@@ -69,8 +73,19 @@ module Hashblue::API::TestHelper
     Hashblue::API.stubs(:get).with("/subscribers/#{subscriber_id}/contacts.json", anything).returns(contacts)
   end
 
+  def stub_hashblue_api_message_search(subscriber_id, query, search_results)
+    Hashblue::API.stubs(:get).with("/subscribers/#{subscriber_id}/messages.json",
+      {:query => {:q => query}}).returns(search_results.map { |m| build_hashblue_api_message(subscriber_id, m) })
+  end
+
   private
 
+  def build_hashblue_api_message(subscriber_id, attributes = {})
+    {:id => __next_firehose_id, :content => "Hello", :contact_msisdn => "123",
+     :subscriber_id => subscriber_id, :sent => false, :favourite => false,
+     :timestamp => Time.zone.now.to_json}.merge(prepare_and_check_attributes(attributes))
+  end
+
   def prepare_and_check_attributes(message)
     unless (message.keys - API_KEYS).empty?
       raise "#{message.keys.inspect} doesn't match the current API (#{API_KEYS.inspect})"

data/test/helpers/test_helper_test.rb

@@ -40,9 +40,42 @@ class TestHelperTest < Test::Unit::TestCase
       end
     end
 
+    should "stub sending a message" do
+      stub_hashblue_api(@subscriber.id)
+
+      message = @subscriber.send_message("123", "Hey man post this shizzle")
+      assert_equal true, message.sent
+    end
+
+    should "stub favourite messages for a subscriber" do
+      messages = [{:content => "Blah", :contact_msisdn => "123", :timestamp => 1.day.ago, :favourite => true}]
+      stub_hashblue_api(@subscriber.id, :messages => messages)
+
+      messages = @subscriber.favourites
+      assert_equal 1, messages.length
+      assert_equal "Blah", messages.first.content
+    end
+
+    should "stub marking a message as a favourite" do
+      messages = [{:id=>"123"}]
+      stub_hashblue_api(@subscriber.id, :messages => messages)
+
+      assert_nothing_raised do
+        Hashblue::API::Message.favourite(@subscriber.id, "123")
+      end
+    end
+
+    should "stub marking a message as unfavourite when stubbing favourites" do
+      messages = [{:content => "Blah", :contact_msisdn => "123", :timestamp => 1.day.ago, :id=>"123", :favourite => true}]
+      stub_hashblue_api(@subscriber.id, :messages => messages)
+
+      assert_nothing_raised do
+        Hashblue::API::Message.unfavourite(@subscriber.id, "123")
+      end
+    end
+
     should "stub querying messages by keyword" do
-      stub_hashblue_api(@subscriber.id, :messages => [{:id => "123", :content => "I'll meet you at the office"},
-        {:id => "456", :content => "sure thing we'll do that"}], :q => "office")
+      stub_hashblue_api_message_search(@subscriber.id, "office", [{:id => "123", :content => "I'll meet you at the office"}])
       messages = @subscriber.messages(:q => "office")
       assert_equal 1, messages.length
       assert_equal "I'll meet you at the office", messages.first.content

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 8
-  version: 0.0.8
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - FreeRange
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-07 00:00:00 +01:00
+date: 2010-05-24 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency