sparqcode-urbanairship 2.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011 Groupon, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,132 @@
+Urbanairship is a Ruby library for interacting with the [Urban Airship API](http://urbanairship.com).
+
+Installation
+============
+    gem install urbanairship
+
+Note: if you are using Ruby 1.8, you should also install the ```system_timer``` gem for more reliable timeout behaviour. See http://ph7spot.com/musings/system-timer for more information.
+
+Configuration
+=============
+```ruby
+Urbanairship.application_key = 'application-key'
+Urbanairship.application_secret = 'application-secret'
+Urbanairship.master_secret = 'master-secret'
+Urbanairship.logger = Rails.logger
+Urbanairship.request_timeout = 5 # default
+```
+
+Usage
+=====
+
+Registering a device token
+--------------------------
+```ruby
+Urbanairship.register_device('DEVICE-TOKEN')
+```
+
+Unregistering a device token
+----------------------------
+```ruby
+Urbanairship.unregister_device('DEVICE-TOKEN')
+```
+
+Sending a push notification
+---------------------------
+```ruby
+notification = {
+  :schedule_for => [1.hour.from_now],
+  :device_tokens => ['DEVICE-TOKEN-ONE', 'DEVICE-TOKEN-TWO'],
+  :aps => {:alert => 'You have a new message!', :badge => 1}
+}
+
+Urbanairship.push(notification) # =>
+# {
+#   "scheduled_notifications" => ["https://go.urbanairship.com/api/push/scheduled/123456"]
+# }
+```
+
+Batching push notification sends
+--------------------------------
+```ruby
+notifications = [
+  {
+    :schedule_for => [{ :alias => 'deadbeef', :scheduled_time => 1.hour.from_now }],
+    :device_tokens => ['DEVICE-TOKEN-ONE', 'DEVICE-TOKEN-TWO'],
+    :aps => {:alert => 'You have a new message!', :badge => 1}
+  },
+  {
+    :schedule_for => [3.hours.from_now],
+    :device_tokens => ['DEVICE-TOKEN-THREE'],
+    :aps => {:alert => 'You have a new message!', :badge => 1}
+  }
+]
+
+Urbanairship.batch_push(notifications)
+```
+
+
+Sending broadcast notifications
+-------------------------------
+Urban Airship allows you to send a broadcast notification to all active registered device tokens for your app.
+
+```ruby
+notification = {
+  :schedule_for => [1.hour.from_now],
+  :aps => {:alert => 'Important announcement!', :badge => 1}
+}
+
+Urbanairship.broadcast_push(notification)
+```
+
+Polling the feedback API
+------------------------
+The first time you attempt to send a push notification to a device that has uninstalled your app (or has opted-out of notifications), both Apple and Urban Airship will register that token in their feedback API. Urban Airship will prevent further attempted notification sends to that device, but it's a good practice to periodically poll Urban Airship's feedback API and mark those tokens as inactive in your own system as well.
+
+```ruby
+# find all device tokens deactivated in the past 24 hours
+Urbanairship.feedback(24.hours.ago) # =>
+# [
+#   {
+#     "marked_inactive_on"=>"2011-06-03 22:53:23",
+#     "alias"=>nil,
+#     "device_token"=>"DEVICE-TOKEN-ONE"
+#   },
+#   {
+#     "marked_inactive_on"=>"2011-06-03 22:53:23",
+#     "alias"=>nil,
+#     "device_token"=>"DEVICE-TOKEN-TWO"
+#   }
+# ]
+```
+
+Deleting scheduled notifications
+--------------------------------
+
+If you know the alias or id of a scheduled push notification then you can delete it from Urban Airship's queue and it will not be delivered.
+
+```ruby
+Urbanairship.delete_scheduled_push("123456789")
+Urbanairship.delete_scheduled_push(123456789)
+Urbanairship.delete_scheduled_push(:alias => "deadbeef")
+```
+
+-----------------------------
+
+Note: all public library methods will return either an array or a hash, depending on the response from the Urban Airship API. In addition, you can inspect these objects to find out if they were successful or not, and what the http response code from Urban Airship was.
+
+```ruby
+response = Urbanairship.push(payload)
+response.success? # => true
+response.code # => '200'
+response.inspect # => "{\"scheduled_notifications\"=>[\"https://go.urbanairship.com/api/push/scheduled/123456\"]}"
+```
+
+If the call to Urban Airship times out, you'll get a response object with a '503' code.
+
+```ruby
+response = Urbanairship.feedback(1.year.ago)
+response.success? # => false
+response.code # => '503'
+response.inspect # => "{\"error\"=>\"Request timeout\"}"
+```

data/Rakefile

@@ -0,0 +1,8 @@
+desc 'Run all the tests'
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['-c', '-f progress', '-r ./spec/spec_helper.rb']
+  t.pattern = 'spec/**/*_spec.rb'
+end

data/lib/urbanairship.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'urbanairship/service')

data/lib/urbanairship/base.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'service')
+
+module Urbanairship
+  class Base
+    include Service
+    
+    def initialize(application_key, application_secret, master_secret)
+      self.application_key = application_key
+      self.application_secret = application_secret
+      self.master_secret = master_secret
+    end
+  end
+  
+  private
+  
+  @@applications = { }
+  
+  def self.[](application_id)
+    @@applications[application_id]
+  end
+    
+  def self.add_service(application_id, application_key, application_secret, master_secret)
+    new_service = Base.new(application_key, application_secret, master_secret)
+    yield new_service if block_given?
+    @@applications[application_id] = new_service
+  end
+  
+end

data/lib/urbanairship/response.rb

@@ -0,0 +1,33 @@
+module Urbanairship
+  module Response
+    module InstanceMethods
+      attr_accessor :ua_response, :ua_options
+
+      def code
+        (ua_options[:code] || ua_response.code).to_s
+      end
+
+      def success?
+        !!(code =~ /^2/)
+      end
+    end
+
+    def self.wrap(response, options = {})
+      if options[:body]
+        output = options[:body]
+      else
+        begin
+          output = JSON.parse(response.body || '{}')
+        rescue JSON::ParserError
+          output = {}
+        end
+      end
+
+      output.extend(Urbanairship::Response::InstanceMethods)
+      output.ua_response = response
+      output.ua_options = options
+
+      return output
+    end
+  end
+end

data/lib/urbanairship/service.rb

@@ -0,0 +1,124 @@
+require 'json'
+require 'net/https'
+require 'time'
+
+require File.join(File.dirname(__FILE__), 'response')
+
+module Urbanairship
+  begin
+    require 'system_timer'
+    Timer = SystemTimer
+  rescue LoadError
+    require 'timeout'
+    Timer = Timeout
+  end
+  
+  module Service
+    attr_accessor :application_key, :application_secret, :master_secret, :logger, :request_timeout
+    
+    def register_device(device_token, options = {})
+      body = parse_register_options(options).to_json
+      do_request(:put, "/api/device_tokens/#{device_token}", :body => body, :authenticate_with => :application_secret)
+    end
+    
+    def unregister_device(device_token)
+      do_request(:delete, "/api/device_tokens/#{device_token}", :authenticate_with => :application_secret)
+    end
+    
+    def delete_scheduled_push(param)
+      path = param.is_a?(Hash) ? "/api/push/scheduled/alias/#{param[:alias].to_s}" : "/api/push/scheduled/#{param.to_s}"
+      do_request(:delete, path, :authenticate_with => :master_secret)
+    end
+    
+    def push(options = {})
+      body = parse_push_options(options).to_json
+      do_request(:post, "/api/push/", :body => body, :authenticate_with => :master_secret)
+    end
+    
+    def batch_push(notifications = [])
+      body = notifications.map{|notification| parse_push_options(notification)}.to_json
+      do_request(:post, "/api/push/batch/", :body => body, :authenticate_with => :master_secret)
+    end
+    
+    def broadcast_push(options = {})
+      body = parse_push_options(options).to_json
+      do_request(:post, "/api/push/broadcast/", :body => body, :authenticate_with => :master_secret)
+    end
+    
+    def feedback(time)
+      do_request(:get, "/api/device_tokens/feedback/?since=#{format_time(time)}", :authenticate_with => :master_secret)
+    end
+    
+    private
+    
+    def do_request(http_method, path, options = {})
+      verify_configuration_values(:application_key, options[:authenticate_with])
+      
+      klass = Net::HTTP.const_get(http_method.to_s.capitalize)
+      
+      request = klass.new(path)
+      request.basic_auth @application_key, instance_variable_get("@#{options[:authenticate_with]}")
+      request.add_field "Content-Type", "application/json"
+      request.body = options[:body] if options[:body]
+      
+      Timer.timeout(request_timeout) do
+        start_time = Time.now
+        response = http_client.request(request)
+        log_request_and_response(request, response, Time.now - start_time)
+        Urbanairship::Response.wrap(response)
+      end
+    rescue Timeout::Error
+      logger.error "Urbanairship request timed out after #{request_timeout} seconds: [#{http_method} #{request.path} #{request.body}]"
+      Urbanairship::Response.wrap(nil, :body => {:error => 'Request timeout'}, :code => '503')
+    end
+    
+    def verify_configuration_values(*symbols)
+      absent_values = symbols.select{|symbol| instance_variable_get("@#{symbol}").nil? }
+      raise("Must configure #{absent_values.join(", ")} before making this request.") unless absent_values.empty?
+    end
+    
+    def http_client
+      Net::HTTP.new("go.urbanairship.com", 443).tap{|http| http.use_ssl = true}
+    end
+    
+    def parse_register_options(hash = {})
+      hash[:alias] = hash[:alias].to_s unless hash[:alias].nil?
+      hash
+    end
+    
+    def parse_push_options(hash = {})
+      hash[:schedule_for] = hash[:schedule_for].map{|elem| process_scheduled_elem(elem)} unless hash[:schedule_for].nil?
+      hash
+    end
+    
+    def log_request_and_response(request, response, time)
+      return if logger.nil?
+      
+      time = (time * 1000).to_i
+      http_method = request.class.to_s.split('::')[-1]
+      logger.info "Urbanairship (#{time}ms): [#{http_method} #{request.path}, #{request.body}], [#{response.code}, #{response.body}]"
+      logger.flush if logger.respond_to?(:flush)
+    end
+    
+    def format_time(time)
+      time = Time.parse(time) if time.is_a?(String)
+      time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+    end
+    
+    def process_scheduled_elem(elem)
+      if elem.class == Hash
+        elem.merge!(:scheduled_time => format_time(elem[:scheduled_time]))
+      else
+        format_time(elem)
+      end
+    end
+    
+    def request_timeout
+      @request_timeout || 5.0
+    end
+  end
+  
+  extend Service
+  
+end
+

data/spec/response_spec.rb

@@ -0,0 +1,77 @@
+describe Urbanairship::Response do
+
+  before do
+    FakeWeb.allow_net_connect = false
+  end
+
+  context "#code" do
+    subject { Urbanairship.register_device("new_device_token") }
+
+    before do
+      FakeWeb.register_uri(:put, "https://my_app_key:my_app_secret@go.urbanairship.com/api/device_tokens/new_device_token", :status => ["201", "Created"])
+      FakeWeb.register_uri(:put, /bad_key\:my_app_secret\@go\.urbanairship\.com/, :status => ["401", "Unauthorized"])
+      Urbanairship.application_secret = "my_app_secret"
+    end
+
+    it "should be set correctly on new registraion token" do
+      Urbanairship.application_key = "my_app_key"
+      subject.code.should eql '201'
+    end
+
+    it "should set correctly on unauthhorized" do
+      Urbanairship.application_key = "bad_key"
+      subject.code.should eql '401'
+    end
+ end
+
+  context "#success?" do
+    subject { Urbanairship.register_device("new_device_token") }
+
+    before do
+      FakeWeb.register_uri(:put, "https://my_app_key:my_app_secret@go.urbanairship.com/api/device_tokens/new_device_token", :status => ["201", "Created"])
+      FakeWeb.register_uri(:put, /bad_key\:my_app_secret\@go\.urbanairship\.com/, :status => ["401", "Unauthorized"])
+      Urbanairship.application_secret = "my_app_secret"
+    end
+
+    it "should be true with good key" do
+      Urbanairship.application_key = "my_app_key"
+      subject.success?.should == true
+    end
+
+    it "should be false with bad key" do
+      Urbanairship.application_key = "bad_key"
+      subject.success?.should == false
+    end
+  end
+
+  context "body array accessor" do
+    subject { Urbanairship.feedback(Time.now) }
+
+    before do
+      FakeWeb.register_uri(:get, /my_app_key\:my_master_secret\@go\.urbanairship.com\/api\/device_tokens\/feedback/, :status => ["200", "OK"], :body => "[{\"device_token\":\"token\",\"marked_inactive_on\":\"2010-10-14T19:15:13Z\",\"alias\":\"my_alias\"},{\"device_token\":\"token2\",\"marked_inactive_on\":\"2010-10-14T19:15:13Z\",\"alias\":\"my_alias\"}]")
+      Urbanairship.application_secret = "my_app_secret"
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.master_secret = "my_master_secret"
+    end
+
+    it "should set up correct indexes" do
+      subject[0]['device_token'].should eql "token"
+      subject[1]['device_token'].should eql "token2"
+    end
+  end
+
+  context "non array response" do
+    subject { Urbanairship.feedback(Time.now) }
+
+    before do
+      FakeWeb.register_uri(:get, /my_app_key\:my_master_secret\@go\.urbanairship.com\/api\/device_tokens\/feedback/, :status => ["200", "OK"], :body => "{\"device_token\":\"token\",\"marked_inactive_on\":\"2010-10-14T19:15:13Z\",\"alias\":\"my_alias\"}")
+      Urbanairship.application_secret = "my_app_secret"
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.master_secret = "my_master_secret"
+    end
+
+    it "should set up correct keys" do
+      subject['device_token'].should eql "token"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'base64'
+require 'fakeweb'
+
+require File.join(File.dirname(__FILE__), '/../lib/urbanairship')
+
+
+RSpec.configure do |config|
+  config.after(:each) do
+    # reset configuration
+    Urbanairship.application_key = nil
+    Urbanairship.application_secret = nil
+    Urbanairship.master_secret = nil
+    Urbanairship.logger = nil
+
+    FakeWeb.instance_variable_set("@last_request", nil)
+  end
+end

data/spec/urbanairship_spec.rb

@@ -0,0 +1,456 @@
+describe Urbanairship do
+  before(:all) do
+    FakeWeb.allow_net_connect = false
+
+    # register_device
+    FakeWeb.register_uri(:put, "https://my_app_key:my_app_secret@go.urbanairship.com/api/device_tokens/new_device_token", :status => ["201", "Created"])
+    FakeWeb.register_uri(:put, "https://my_app_key:my_app_secret@go.urbanairship.com/api/device_tokens/existing_device_token", :status => ["200", "OK"])
+    FakeWeb.register_uri(:put, "https://my_app_key:my_app_secret@go.urbanairship.com/api/device_tokens/device_token_one", :status => ["201", "Created"])
+    FakeWeb.register_uri(:put, /bad_key\:my_app_secret\@go\.urbanairship\.com/, :status => ["401", "Unauthorized"])
+
+    # unregister_device
+    FakeWeb.register_uri(:delete, /my_app_key\:my_app_secret\@go\.urbanairship.com\/api\/device_tokens\/.+/, :status => ["204", "No Content"])
+    FakeWeb.register_uri(:delete, /bad_key\:my_app_secret\@go\.urbanairship.com\/api\/device_tokens\/.+/, :status => ["401", "Unauthorized"])
+
+    # push
+    FakeWeb.register_uri(:post, "https://my_app_key:my_master_secret@go.urbanairship.com/api/push/", :status => ["200", "OK"])
+    FakeWeb.register_uri(:post, "https://my_app_key2:my_master_secret2@go.urbanairship.com/api/push/", :status => ["400", "Bad Request"])
+    FakeWeb.register_uri(:post, /bad_key\:my_master_secret\@go\.urbanairship\.com/, :status => ["401", "Unauthorized"])
+
+    # batch_push
+    FakeWeb.register_uri(:post, "https://my_app_key:my_master_secret@go.urbanairship.com/api/push/batch/", :status => ["200", "OK"])
+    FakeWeb.register_uri(:post, "https://my_app_key2:my_master_secret2@go.urbanairship.com/api/push/batch/", :status => ["400", "Bad Request"])
+
+    # broadcast push
+    FakeWeb.register_uri(:post, "https://my_app_key:my_master_secret@go.urbanairship.com/api/push/broadcast/", :status => ["200", "OK"])
+    FakeWeb.register_uri(:post, "https://my_app_key2:my_master_secret2@go.urbanairship.com/api/push/broadcast/", :status => ["400", "Bad Request"])
+
+    # delete_scheduled_push
+    FakeWeb.register_uri(:delete, /my_app_key\:my_master_secret\@go\.urbanairship.com\/api\/push\/scheduled\/[0-9]+/, :status => ["204", "No Content"])
+    FakeWeb.register_uri(:delete, /my_app_key\:my_master_secret\@go\.urbanairship.com\/api\/push\/scheduled\/alias\/.+/, :status => ["204", "No Content"])
+    FakeWeb.register_uri(:delete, /bad_key\:my_master_secret\@go\.urbanairship.com\/api\/push\/scheduled\/[0-9]+/, :status => ["401", "Unauthorized"])
+
+    # feedback
+    FakeWeb.register_uri(:get, /my_app_key\:my_master_secret\@go\.urbanairship.com\/api\/device_tokens\/feedback/, :status => ["200", "OK"], :body => "[{\"device_token\":\"token\",\"marked_inactive_on\":\"2010-10-14T19:15:13Z\",\"alias\":\"my_alias\"}]")
+    FakeWeb.register_uri(:get, /my_app_key2\:my_master_secret2\@go\.urbanairship.com\/api\/device_tokens\/feedback/, :status => ["500", "Internal Server Error"])
+  end
+
+  describe "configuration" do
+    it "enables you to configure the application key" do
+      Urbanairship.application_key.should be_nil
+      Urbanairship.application_key = "asdf1234"
+      Urbanairship.application_key.should == "asdf1234"
+    end
+
+    it "enables you to configure the application secret" do
+      Urbanairship.application_secret.should be_nil
+      Urbanairship.application_secret = "asdf1234"
+      Urbanairship.application_secret.should == "asdf1234"
+    end
+
+    it "enables you to configure the master secret" do
+      Urbanairship.master_secret.should be_nil
+      Urbanairship.master_secret = "asdf1234"
+      Urbanairship.master_secret.should == "asdf1234"
+    end
+  end
+
+  describe "::register_device" do
+    before(:each) do
+      @valid_params = {:alias => 'one'}
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.application_secret = "my_app_secret"
+    end
+
+    it "raises an error if call is made without an app key and secret configured" do
+      Urbanairship.application_key = nil
+      Urbanairship.application_secret = nil
+
+      lambda {
+        Urbanairship.register_device("asdf1234")
+      }.should raise_error(RuntimeError, "Must configure application_key, application_secret before making this request.")
+    end
+
+    it "uses app key and secret to sign the request" do
+      Urbanairship.register_device("new_device_token")
+      FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_app_secret').chomp}"
+    end
+
+    it "takes and sends a device token" do
+      Urbanairship.register_device("new_device_token")
+      FakeWeb.last_request.path.should == "/api/device_tokens/new_device_token"
+    end
+
+    it "returns true when the device is registered for the first time" do
+      Urbanairship.register_device("new_device_token").success?.should == true
+    end
+
+    it "returns true when the device is registered again" do
+      Urbanairship.register_device("existing_device_token").success?.should == true
+    end
+
+    it "returns false when the authorization is invalid" do
+      Urbanairship.application_key = "bad_key"
+      Urbanairship.register_device("new_device_token").success?.should == false
+    end
+
+    it "accepts an alias" do
+      Urbanairship.register_device("device_token_one", @valid_params).success?.should == true
+    end
+
+    it "adds alias to the JSON payload" do
+      Urbanairship.register_device("device_token_one", @valid_params)
+      request_json['alias'].should == "one"
+    end
+
+    it "converts alias param to string" do
+      Urbanairship.register_device("device_token_one", :alias => 11)
+      request_json['alias'].should be_a_kind_of String
+    end
+  end
+
+  describe "::unregister_device" do
+    before(:each) do
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.application_secret = "my_app_secret"
+    end
+
+    it "raises an error if call is made without an app key and secret configured" do
+      Urbanairship.application_key = nil
+      Urbanairship.application_secret = nil
+
+      lambda {
+        Urbanairship.unregister_device("asdf1234")
+      }.should raise_error(RuntimeError, "Must configure application_key, application_secret before making this request.")
+    end
+
+    it "uses app key and secret to sign the request" do
+      Urbanairship.unregister_device("key_to_delete")
+      FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_app_secret').chomp}"
+    end
+
+    it "sends the key that needs to be deleted" do
+      Urbanairship.unregister_device("key_to_delete")
+      FakeWeb.last_request.path.should == "/api/device_tokens/key_to_delete"
+    end
+
+    it "returns true when the device is successfully unregistered" do
+      Urbanairship.unregister_device("key_to_delete").success?.should == true
+      FakeWeb.last_request.body.should be_nil
+    end
+
+    it "returns false when the authorization is invalid" do
+      Urbanairship.application_key = "bad_key"
+      Urbanairship.unregister_device("key_to_delete").success?.should == false
+    end
+  end
+
+  describe "::delete_scheduled_push" do
+    before(:each) do
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.master_secret = "my_master_secret"
+    end
+
+    it "raises an error if call is made without an app key and master secret configured" do
+      Urbanairship.application_key = nil
+      Urbanairship.master_secret = nil
+
+      lambda {
+        Urbanairship.delete_scheduled_push("123456789")
+      }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
+    end
+
+    it "uses app key and secret to sign the request" do
+      Urbanairship.delete_scheduled_push("123456789")
+      FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
+    end
+
+    it "sends the key that needs to be deleted" do
+      Urbanairship.delete_scheduled_push("123456789")
+      FakeWeb.last_request.path.should == "/api/push/scheduled/123456789"
+    end
+
+    it "sends the key that needs to be deleted" do
+      Urbanairship.delete_scheduled_push(123456789)
+      FakeWeb.last_request.path.should == "/api/push/scheduled/123456789"
+    end
+
+    it "sends the alias that needs to be deleted" do
+      Urbanairship.delete_scheduled_push(:alias => "alias_to_delete")
+      FakeWeb.last_request.path.should == "/api/push/scheduled/alias/alias_to_delete"
+    end
+
+    it "returns true when the push notification is successfully deleted" do
+      Urbanairship.delete_scheduled_push("123456789").success?.should == true
+      FakeWeb.last_request.body.should be_nil
+    end
+
+    it "returns false when the authorization is invalid" do
+      Urbanairship.application_key = "bad_key"
+      Urbanairship.delete_scheduled_push("123456789").success?.should == false
+    end
+  end
+
+  describe "::push" do
+    before(:each) do
+      @valid_params = {:device_tokens => ['device_token_one', 'device_token_two'], :aps => {:alert => 'foo'}}
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.master_secret = "my_master_secret"
+    end
+
+    it "raises an error if call is made without an app key and master secret configured" do
+      Urbanairship.application_key = nil
+      Urbanairship.master_secret = nil
+
+      lambda {
+        Urbanairship.push(@valid_params)
+      }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
+    end
+
+    it "uses app key and secret to sign the request" do
+      Urbanairship.push(@valid_params)
+      FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
+    end
+
+    it "returns true when it successfully pushes a notification" do
+      Urbanairship.push(@valid_params).success?.should == true
+    end
+
+    it "returns false when the authorization is invalid" do
+      Urbanairship.application_key = "bad_key"
+      Urbanairship.push(@valid_params).success?.should == false
+    end
+
+    it "adds schedule_for to the JSON payload" do
+      time = Time.parse("Oct 17th, 2010, 8:00 PM UTC")
+      Urbanairship.push(@valid_params.merge(:schedule_for => [time]))
+      request_json['schedule_for'].should == ['2010-10-17T20:00:00Z']
+    end
+
+    it "only attempts to format schedule_for if it is a time object" do
+      Urbanairship.push(@valid_params.merge(:schedule_for => ["2010-10-10 09:09:09 UTC"]))
+      request_json['schedule_for'].should == ['2010-10-10T09:09:09Z']
+    end
+
+    it "returns false if urbanairship responds with a non-200 response" do
+      Urbanairship.application_key = "my_app_key2"
+      Urbanairship.master_secret = "my_master_secret2"
+      Urbanairship.push.success?.should == false
+    end
+  end
+
+  describe "::batch_push" do
+    before(:each) do
+      @valid_params = [
+        {:device_tokens => ['device_token_one', 'device_token_two'], :aps => {:alert => 'foo'}},
+        {:device_tokens => ['device_token_three', 'device_token_four'], :aps => {:alert => 'bar'}}
+      ]
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.master_secret = "my_master_secret"
+    end
+
+    it "raises an error if call is made without an app key and master secret configured" do
+      Urbanairship.application_key = nil
+      Urbanairship.master_secret = nil
+
+      lambda {
+        Urbanairship.batch_push(@valid_params)
+      }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
+    end
+
+    it "uses app key and secret to sign the request" do
+      Urbanairship.batch_push(@valid_params)
+      FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
+    end
+
+    it "returns true when it successfully pushes a notification" do
+      Urbanairship.batch_push(@valid_params).success?.should == true
+    end
+
+    it "returns false when the authorization is invalid" do
+      Urbanairship.application_key = "bad_key"
+      Urbanairship.batch_push(@valid_params).success?.should == false
+    end
+
+    it "adds schedule_for to the JSON payload" do
+      time = Time.parse("Oct 17th, 2010, 8:00 PM UTC")
+      @valid_params[0].merge!(:schedule_for => [time])
+      Urbanairship.batch_push(@valid_params)
+      request_json[0]['schedule_for'].should == ['2010-10-17T20:00:00Z']
+    end
+
+    it "accepts strings as schedule_for values" do
+      @valid_params[0].merge!(:schedule_for => ["2010-10-10 09:09:09 UTC"])
+      Urbanairship.batch_push(@valid_params)
+      request_json[0]['schedule_for'].should == ['2010-10-10T09:09:09Z']
+    end
+
+    it "returns false if urbanairship responds with a non-200 response" do
+      Urbanairship.application_key = "my_app_key2"
+      Urbanairship.master_secret = "my_master_secret2"
+      Urbanairship.batch_push.success?.should == false
+    end
+  end
+
+  describe "::broadcast_push" do
+    before(:each) do
+      @valid_params = {:aps => {:alert => 'foo'}}
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.master_secret = "my_master_secret"
+    end
+
+    it "raises an error if call is made without an app key and master secret configured" do
+      Urbanairship.application_key = nil
+      Urbanairship.master_secret = nil
+
+      lambda {
+        Urbanairship.broadcast_push(@valid_params)
+      }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
+    end
+
+    it "uses app key and secret to sign the request" do
+      Urbanairship.broadcast_push(@valid_params)
+      FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
+    end
+
+    it "returns true when it successfully pushes a notification" do
+      Urbanairship.broadcast_push(@valid_params).success?.should == true
+    end
+
+    it "returns false when the authorization is invalid" do
+      Urbanairship.application_key = "bad_key"
+      Urbanairship.broadcast_push(@valid_params).success?.should == false
+    end
+
+    it "adds schedule_for to the JSON payload" do
+      time = Time.parse("Oct 17th, 2010, 8:00 PM UTC")
+      @valid_params[:schedule_for] = [time]
+      Urbanairship.broadcast_push(@valid_params)
+      request_json['schedule_for'].should == ['2010-10-17T20:00:00Z']
+    end
+
+    it "accepts strings as schedule_for values" do
+      @valid_params[:schedule_for] = ["2010-10-10 09:09:09 UTC"]
+      Urbanairship.broadcast_push(@valid_params)
+      request_json['schedule_for'].should == ['2010-10-10T09:09:09Z']
+    end
+
+    it "returns false if urbanairship responds with a non-200 response" do
+      Urbanairship.application_key = "my_app_key2"
+      Urbanairship.master_secret = "my_master_secret2"
+      Urbanairship.broadcast_push.success?.should == false
+    end
+  end
+
+  describe "::feedback" do
+    before(:each) do
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.master_secret = "my_master_secret"
+    end
+
+    it "raises an error if call is made without an app key and master secret configured" do
+      Urbanairship.application_key = nil
+      Urbanairship.master_secret = nil
+
+      lambda {
+        Urbanairship.feedback(Time.now)
+      }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
+    end
+
+    it "uses app key and secret to sign the request" do
+      Urbanairship.feedback(Time.now)
+      FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
+    end
+
+    it "encodes the time argument in UTC, ISO 8601 format" do
+      time = Time.parse("October 10, 2010, 8:00pm")
+      formatted_time = time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      Urbanairship.feedback(time)
+      FakeWeb.last_request.path.should include(formatted_time)
+    end
+
+    it "accepts a string as the time argument" do
+      Urbanairship.feedback("Oct 07, 2010 8:00AM UTC")
+      FakeWeb.last_request.path.should include("2010-10-07T08:00:00Z")
+    end
+
+    it "returns an array of responses from the feedback API" do
+      response = Urbanairship.feedback(Time.now)
+      response[0].should include("device_token")
+      response[0].should include("marked_inactive_on")
+      response[0].should include("alias")
+    end
+
+    it "success? is false when the call doesn't return 200" do
+      Urbanairship.application_key = "my_app_key2"
+      Urbanairship.master_secret = "my_master_secret2"
+      Urbanairship.feedback(Time.now).success?.should == false
+    end
+  end
+
+  describe "logging" do
+
+    before(:each) do
+      @logger = mock("logger", :info => true)
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.application_secret = "my_app_secret"
+      Urbanairship.master_secret = "my_master_secret"
+      Urbanairship.logger = @logger
+    end
+
+    it "logs request and response information when registering a device" do
+      @logger.should_receive(:info).with(/\/api\/device_tokens\/new_device_token/)
+      Urbanairship.register_device('new_device_token')
+    end
+
+    it "logs request and response information when sending push notifications" do
+      @logger.should_receive(:info).with(/\/api\/push/)
+      Urbanairship.push(:device_tokens => ["device_token"], :aps => {:alert => "foo"})
+    end
+
+    it "logs request and response information when sending batch push notifications" do
+      @logger.should_receive(:info).with(/\/api\/push\/batch/)
+      Urbanairship.batch_push([:device_tokens => ["device_token"], :aps => {:alert => "foo"}])
+    end
+
+    it "logs request and response information when sending feedback requests" do
+      @logger.should_receive(:info).with(/\/api\/device_tokens\/feedback/)
+      Urbanairship.feedback(Time.now)
+    end
+
+    it "flushes the logger buffer if it's an ActiveSupport::BufferedLogger (Default Rails logger)" do
+      @logger.stub(:flush).and_return("message in the buffer\n")
+      @logger.should_receive(:flush)
+      Urbanairship.feedback(Time.now)
+    end
+  end
+
+  describe "request timeout" do
+    before(:each) do
+      @logger = mock("logger", :info => true)
+      Urbanairship.application_key = "my_app_key"
+      Urbanairship.application_secret = "my_app_secret"
+      Urbanairship.master_secret = "my_master_secret"
+      Urbanairship.logger = @logger
+    end
+
+    it "uses a default request_timeout value of five seconds" do
+      Urbanairship::Timer.should_receive(:timeout).with(5.0).and_raise(Timeout::Error)
+      @logger.should_receive(:error).with(/Urbanairship request timed out/)
+
+      Urbanairship.register_device('new_device_token')
+    end
+
+    it "accepts a configured request_timeout value" do
+      Urbanairship::Timer.should_receive(:timeout).with(1.23).and_raise(Timeout::Error)
+      @logger.should_receive(:error).with(/Urbanairship request timed out/)
+
+      Urbanairship.request_timeout = 1.23
+      Urbanairship.register_device('new_device_token')
+    end
+  end
+end
+
+def request_json
+  JSON.parse FakeWeb.last_request.body
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: sparqcode-urbanairship
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 2
+  - 0
+  - 0
+  version: 2.0.0
+platform: ruby
+authors: 
+- Groupon, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Urbanairship is a Ruby library for interacting with the Urban Airship (http://urbanairship.com) API.  Includes updates from ScoutMob.
+email: 
+- rubygems@groupon.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/urbanairship/base.rb
+- lib/urbanairship/response.rb
+- lib/urbanairship/service.rb
+- lib/urbanairship.rb
+- README.markdown
+- LICENSE
+- Rakefile
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/urbanairship_spec.rb
+homepage: http://github.com/SPARQCode/urbanairship
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 59
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A Ruby wrapper for the Urban Airship API
+test_files: 
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/urbanairship_spec.rb