rpush 1.0.0-java

data/spec/unit/daemon/adm/delivery_spec.rb

@@ -0,0 +1,243 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Adm::Delivery do
+  let(:app) { Rpush::Adm::App.new(:name => 'MyApp', :client_id => 'CLIENT_ID', :client_secret => 'CLIENT_SECRET') }
+  let(:notification) { Rpush::Adm::Notification.create!(:app => app, :registration_ids => ['xyz'], :deliver_after => Time.now, :data => {'message' => 'test'}) }
+  let(:logger) { double(:error => nil, :info => nil, :warn => nil) }
+  let(:response) { double(:code => 200, :header => {}) }
+  let(:http) { double(:shutdown => nil, :request => response)}
+  let(:now) { Time.parse('2012-10-14 00:00:00') }
+  let(:batch) { double(:mark_failed => nil, :mark_delivered => nil, :mark_retryable => nil) }
+  let(:delivery) { Rpush::Daemon::Adm::Delivery.new(app, http, notification, batch) }
+  let(:store) { double(:create_adm_notification => double(:id => 2)) }
+
+  def perform
+    delivery.perform
+  end
+
+  before do
+    app.access_token = 'ACCESS_TOKEN'
+    app.access_token_expiration = Time.now + 1.month
+
+    delivery.stub(:reflect => nil)
+    Rpush::Daemon.stub(:store => store)
+    Time.stub(:now => now)
+    Rpush.stub(:logger => logger)
+  end
+
+  describe 'unknown error response' do
+    before do
+      response.stub(:code => 408)
+    end
+
+    it 'marks the notification as failed because no successful delivery was made' do
+      response.stub(:body => JSON.dump({ 'reason' => 'InvalidData' }))
+      delivery.should_receive(:mark_failed).with(408, 'Request Timeout')
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 200 (Ok) response' do
+    before do
+      response.stub(:code => 200)
+    end
+
+    it 'marks the notification as delivered if delivered successfully to all devices' do
+      response.stub(:body => JSON.dump({ 'registrationID' => 'xyz' }))
+      delivery.should_receive(:mark_delivered)
+      perform
+    end
+
+    it 'logs that the notification was delivered' do
+      response.stub(:body => JSON.dump({ 'registrationID' => 'xyz' }))
+      logger.should_receive(:info).with("[MyApp] #{notification.id} sent to xyz")
+      perform
+    end
+
+    it 'reflects on canonical IDs' do
+      response.stub(:body => JSON.dump({'registrationID' => 'canonical123' }))
+      notification.stub(:registration_ids => ['1'])
+      delivery.should_receive(:reflect).with(:adm_canonical_id, '1', 'canonical123')
+      perform
+    end
+  end
+
+  describe 'a 400 (Bad Request) response' do
+    before do
+      response.stub(:code => 400)
+    end
+
+    it 'marks the notification as failed because no successful delivery was made' do
+      response.stub(:body => JSON.dump({ 'reason' => 'InvalidData' }))
+      delivery.should_receive(:mark_failed).with(nil, 'Failed to deliver to all recipients.')
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+
+    it 'logs that the notification was not delivered' do
+      response.stub(:body => JSON.dump({ 'reason' => 'InvalidRegistrationId' }))
+      logger.should_receive(:warn).with("[MyApp] bad_request: xyz (InvalidRegistrationId)")
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 401 (Unauthorized) response' do
+    let(:http) { double(:shutdown => nil)}
+    let(:token_response) { double(:code => 200, :header => {}, :body => JSON.dump({'access_token' => 'ACCESS_TOKEN', 'expires_in' => 60})) }
+
+    before do
+      response.stub(:code => 401, :header => { 'retry-after' => 10 })
+
+      # first request to deliver message that returns unauthorized response
+      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % [notification.registration_ids.first])
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+    end
+
+    it 'should retrieve a new access token and mark the notification for retry' do
+      # request for access token
+      http.should_receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+
+      store.should_receive(:update_app).with(notification.app)
+      delivery.should_receive(:mark_retryable).with(notification, now)
+
+      perform
+    end
+
+    it 'should update the app with the new access token' do
+      # request for access token
+      http.should_receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+
+      store.should_receive(:update_app).with do |app|
+        app.access_token.should eq 'ACCESS_TOKEN'
+        app.access_token_expiration.should eq now + 60.seconds
+      end
+      delivery.should_receive(:mark_retryable).with(notification, now)
+
+      perform
+    end
+
+    it 'should log the error and stop retrying if new access token can\'t be retrieved' do
+      token_response.stub(:code => 404, :body => "test")
+      # request for access token
+      http.should_receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+
+      store.should_not_receive(:update_app).with(notification.app)
+      delivery.should_not_receive(:mark_retryable)
+
+      logger.should_receive(:warn).with("[MyApp] Could not retrieve access token from ADM: test")
+
+      perform
+    end
+  end
+
+  describe 'a 429 (Too Many Request) response' do
+    let(:http) { double(:shutdown => nil) }
+    let(:notification) { Rpush::Adm::Notification.create!(:app => app, :registration_ids => ['abc','xyz'], :deliver_after => Time.now, :collapse_key => 'sync', :data => {'message' => 'test'}) }
+    let(:too_many_request_response) { double(:code => 429, :header => { 'retry-after' => 3600 }) }
+
+    it 'should retry the entire notification respecting the Retry-After header if none sent out yet' do
+      response.stub(:code => 429, :header => { 'retry-after' => 3600 })
+
+      # first request to deliver message that returns too many request response
+      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % [notification.registration_ids.first])
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+
+      delivery.should_receive(:mark_retryable).with(notification, now + 1.hour)
+      perform
+    end
+
+    it 'should retry the entire notification using exponential backoff' do
+      response.stub(:code => 429, :header => {})
+
+      # first request to deliver message that returns too many request response
+      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % [notification.registration_ids.first])
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+
+      delivery.should_receive(:mark_retryable).with(notification, Time.now + 2 ** (notification.retries + 1))
+      perform
+    end
+
+    it 'should keep sent reg ids in original notification and create new notification with remaining reg ids for retry' do
+      response.stub(:code => 200, :body => JSON.dump({ 'registrationID' => 'abc' }))
+
+      # first request to deliver message succeeds
+      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['abc'])
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+
+      # first request to deliver message that returns too many request response
+      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['xyz'])
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(too_many_request_response)
+
+      store.should_receive(:update_notification).with do |notif|
+        notif.registration_ids.include?('abc').should be_true
+        notif.registration_ids.include?('xyz').should be_false
+      end
+
+      store.should_receive(:create_adm_notification).with do |attrs, notification_data, reg_ids, deliver_after, notification_app|
+        attrs.has_key?('collapse_key').should be_true
+        attrs.has_key?('delay_while_idle').should be_true
+        attrs.has_key?('app_id').should be_true
+
+        reg_ids.should eq ['xyz']
+        deliver_after.should eq now + 1.hour
+        notification_app.should eq notification.app
+      end
+
+      delivery.should_receive(:mark_delivered)
+
+      perform
+    end
+  end
+
+  describe 'a 500 (Internal Server Error) response' do
+    before do
+      response.stub(:code => 500)
+    end
+
+    it 'marks the notification as failed because no successful delivery was made' do
+      delivery.should_receive(:mark_failed).with(nil, 'Failed to deliver to all recipients.')
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+
+    it 'logs that the notification was not delivered' do
+      logger.should_receive(:warn).with("[MyApp] internal_server_error: xyz (Internal Server Error)")
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 503 (Service Unavailable) response' do
+    before do
+      response.stub(:code => 503, :header => { 'retry-after' => 10 })
+    end
+
+    it 'should retry the notification respecting the Retry-After header' do
+      delivery.should_receive(:mark_retryable).with(notification, now + 10.seconds)
+      perform
+    end
+  end
+
+  describe 'some registration ids succeeding and some failing' do
+    let(:http) { double(:shutdown => nil) }
+    let(:notification) { Rpush::Adm::Notification.create!(:app => app, :registration_ids => ['abc','xyz'], :deliver_after => Time.now, :collapse_key => 'sync', :data => {'message' => 'test'}) }
+    let(:bad_request_response) { double(:code => 400, :body => JSON.dump({ 'reason' => 'InvalidData' })) }
+
+    it 'should keep sent reg ids in original notification and create new notification with remaining reg ids for retry' do
+      response.stub(:code => 200, :body => JSON.dump({ 'registrationID' => 'abc' }))
+
+      # first request to deliver message succeeds
+      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['abc'])
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+
+      # first request to deliver message that returns too many request response
+      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['xyz'])
+      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(bad_request_response)
+
+      store.should_receive(:update_notification).with do |notif|
+        notif.error_description.should eq "Failed to deliver to recipients: \nxyz: InvalidData"
+      end
+
+      delivery.should_receive(:mark_delivered)
+
+      perform
+    end
+  end
+end

data/spec/unit/daemon/apns/certificate_expired_error_spec.rb

@@ -0,0 +1,11 @@
+require 'unit_spec_helper'
+
+describe Rpush::Apns::CertificateExpiredError do
+  let(:app) { double(:name => 'test') }
+  let(:error) { Rpush::Apns::CertificateExpiredError.new(app, Time.now) }
+
+  it 'returns a message' do
+    error.message
+    error.to_s
+  end
+end

data/spec/unit/daemon/apns/delivery_spec.rb

@@ -0,0 +1,101 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Apns::Delivery do
+  let(:app) { double(:name => 'MyApp') }
+  let(:notification) { double.as_null_object }
+  let(:batch) { double(:mark_failed => nil, :mark_delivered => nil) }
+  let(:logger) { double(:error => nil, :info => nil) }
+  let(:config) { double(:check_for_errors => true) }
+  let(:connection) { double(:select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
+  let(:delivery) { Rpush::Daemon::Apns::Delivery.new(app, connection, notification, batch) }
+
+  def perform
+    begin
+      delivery.perform
+    rescue Rpush::DeliveryError, Rpush::Apns::DisconnectionError
+    end
+  end
+
+  before do
+    Rpush.stub(:config => config, :logger => logger)
+  end
+
+  it "sends the binary version of the notification" do
+    notification.stub(:to_binary => "hi mom")
+    connection.should_receive(:write).with("hi mom")
+    perform
+  end
+
+  it "logs the notification delivery" do
+    notification.stub(:id => 666, :device_token => 'abc123')
+    logger.should_receive(:info).with("[MyApp] 666 sent to abc123")
+    perform
+  end
+
+  it "marks the notification as delivered" do
+    delivery.should_receive(:mark_delivered)
+    perform
+  end
+
+  it 'does not check for errors if check_for_errors config option is false' do
+    config.stub(:check_for_errors => false)
+    delivery.should_not_receive(:check_for_error)
+    perform
+  end
+
+  describe "when delivery fails" do
+    before { connection.stub(:select => true, :read => [8, 4, 69].pack("ccN")) }
+
+    it "marks the notification as failed" do
+      delivery.should_receive(:mark_failed).with(4, "Missing payload")
+      perform
+    end
+
+    it "logs the delivery error" do
+      # checking for the doublebed error doesn't work in jruby, but checking
+      # for the exception by class does.
+
+      #error = Rpush::DeliveryError.new(4, 12, "Missing payload")
+      #Rpush::DeliveryError.stub(:new => error)
+      #expect { delivery.perform }.to raise_error(error)
+
+      expect { delivery.perform }.to raise_error(Rpush::DeliveryError)
+    end
+
+    it "reads 6 bytes from the socket" do
+      connection.should_receive(:read).with(6).and_return(nil)
+      perform
+    end
+
+    it "does not attempt to read from the socket if the socket was not selected for reading after the timeout" do
+      connection.stub(:select => nil)
+      connection.should_not_receive(:read)
+      perform
+    end
+
+    it "reconnects the socket" do
+      connection.should_receive(:reconnect)
+      perform
+    end
+
+    it "logs that the connection is being reconnected" do
+      Rpush.logger.should_receive(:error).with("[MyApp] Error received, reconnecting...")
+      perform
+    end
+
+    context "when the APNs disconnects without returning an error" do
+      before do
+        connection.stub(:read => nil)
+      end
+
+      it 'raises a DisconnectError error if the connection is closed without an error being returned' do
+        expect { delivery.perform }.to raise_error(Rpush::Apns::DisconnectionError)
+      end
+
+      it 'marks the notification as failed' do
+        delivery.should_receive(:mark_failed).with(nil, "APNs disconnected without returning an error.")
+        perform
+      end
+    end
+  end
+end

data/spec/unit/daemon/apns/disconnection_error_spec.rb

@@ -0,0 +1,18 @@
+require 'unit_spec_helper'
+
+describe Rpush::Apns::DisconnectionError do
+  let(:error) { Rpush::Apns::DisconnectionError.new }
+
+  it 'returns a nil error code' do
+    error.code.should be_nil
+  end
+
+  it 'contains an error description' do
+    error.description
+  end
+
+  it 'returns a message' do
+    error.message
+    error.to_s
+  end
+end

data/spec/unit/daemon/apns/feedback_receiver_spec.rb

@@ -0,0 +1,117 @@
+require "unit_spec_helper"
+
+describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
+
+  let(:host) { 'feedback.push.apple.com' }
+  let(:port) { 2196 }
+  let(:poll) { 60 }
+  let(:certificate) { double }
+  let(:password) { double }
+  let(:app) { double(:name => 'my_app', :password => password, :certificate => certificate, :environment => 'production') }
+  let(:connection) { double(:connect => nil, :read => nil, :close => nil) }
+  let(:logger) { double(:error => nil, :info => nil) }
+  let(:receiver) { Rpush::Daemon::Apns::FeedbackReceiver.new(app) }
+  let(:feedback) { double }
+  let(:sleeper) { double(Rpush::Daemon::InterruptibleSleep, :sleep => nil, :interrupt_sleep => nil) }
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord,
+    create_apns_feedback: feedback, release_connection: nil) }
+
+  before do
+    Rpush.config.feedback_poll = poll
+    Rpush::Daemon::InterruptibleSleep.stub(:new => sleeper)
+    Rpush.stub(:logger => logger)
+    Rpush::Daemon::TcpConnection.stub(:new => connection)
+    receiver.instance_variable_set("@stop", false)
+    Rpush::Daemon.stub(:store => store)
+  end
+
+  def double_connection_read_with_tuple
+    connection.unstub(:read)
+
+    def connection.read(bytes)
+      if !@called
+        @called = true
+        "N\xE3\x84\r\x00 \x83OxfU\xEB\x9F\x84aJ\x05\xAD}\x00\xAF1\xE5\xCF\xE9:\xC3\xEA\a\x8F\x1D\xA4M*N\xB0\xCE\x17"
+      end
+    end
+  end
+
+  it 'instantiates a new connection' do
+    Rpush::Daemon::TcpConnection.should_receive(:new).with(app, host, port)
+    receiver.check_for_feedback
+  end
+
+  it 'connects to the feeback service' do
+    connection.should_receive(:connect)
+    receiver.check_for_feedback
+  end
+
+  it 'closes the connection' do
+    connection.should_receive(:close)
+    receiver.check_for_feedback
+  end
+
+  it 'reads from the connection' do
+    connection.should_receive(:read).with(38)
+    receiver.check_for_feedback
+  end
+
+  it 'logs the feedback' do
+    double_connection_read_with_tuple
+    Rpush.logger.should_receive(:info).with("[my_app] [FeedbackReceiver] Delivery failed at 2011-12-10 16:08:45 UTC for 834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17.")
+    receiver.check_for_feedback
+  end
+
+  it 'creates the feedback' do
+    Rpush::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1323533325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
+    double_connection_read_with_tuple
+    receiver.check_for_feedback
+  end
+
+  it 'logs errors' do
+    error = StandardError.new('bork!')
+    connection.stub(:read).and_raise(error)
+    Rpush.logger.should_receive(:error).with(error)
+    receiver.check_for_feedback
+  end
+
+  describe 'start' do
+    before do
+      Thread.stub(:new).and_yield
+      receiver.stub(:loop).and_yield
+    end
+
+    it 'sleeps for the feedback poll period' do
+      receiver.stub(:check_for_feedback)
+      sleeper.should_receive(:sleep).with(60).at_least(:once)
+      receiver.start
+    end
+
+    it 'checks for feedback when started' do
+      receiver.should_receive(:check_for_feedback).at_least(:once)
+      receiver.start
+    end
+  end
+
+  describe 'stop' do
+    it 'interrupts sleep when stopped' do
+      receiver.stub(:check_for_feedback)
+      sleeper.should_receive(:interrupt_sleep)
+      receiver.stop
+    end
+
+    it 'releases the store connection' do
+      Thread.stub(:new).and_yield
+      receiver.stub(:loop).and_yield
+      Rpush::Daemon.store.should_receive(:release_connection)
+      receiver.start
+      receiver.stop
+    end
+  end
+
+  it 'reflects feedback was received' do
+    double_connection_read_with_tuple
+    receiver.should_receive(:reflect).with(:apns_feedback, feedback)
+    receiver.check_for_feedback
+  end
+end