rpush_extended 3.2.5

data/spec/unit/client/active_record/wpns/notification_spec.rb

@@ -0,0 +1,21 @@
+require 'unit_spec_helper'
+require 'unit/notification_shared.rb'
+
+describe Rpush::Client::ActiveRecord::Wpns::Notification do
+  it_should_behave_like 'an Notification subclass'
+  let(:app) { Rpush::Client::ActiveRecord::Wpns::App.create!(name: 'test', auth_key: 'abc') }
+  let(:notification_class) { Rpush::Client::ActiveRecord::Wpns::Notification }
+  let(:notification) { notification_class.new }
+
+  it "should have an url in the uri parameter" do
+    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(uri: "somthing")
+    notification.valid?
+    expect(notification.errors[:uri]).to include('is invalid')
+  end
+
+  it "should be invalid if there's no data" do
+    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(data: {})
+    notification.valid?
+    expect(notification.errors[:data]).to include("can't be blank")
+  end
+end if active_record?

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,46 @@
+require 'unit_spec_helper'
+
+describe Rpush do
+  let(:config) { Rpush.config }
+
+  before do
+    allow(Rpush).to receive_messages(require: nil)
+    allow(Rpush).to receive_messages(config: config)
+  end
+
+  it 'yields a configure block' do
+    expect { |b| Rpush.configure(&b) }.to yield_with_args(config)
+  end
+end
+
+describe Rpush::Configuration do
+  let(:config) do
+    Rpush::Deprecation.muted do
+      Rpush::Configuration.new
+    end
+  end
+
+  it 'can be updated' do
+    Rpush::Deprecation.muted do
+      new_config = Rpush::Configuration.new
+      new_config.batch_size = 200
+      expect { config.update(new_config) }.to change(config, :batch_size).to(200)
+    end
+  end
+
+  it 'sets the pid_file relative if not absolute' do
+    config.pid_file = 'tmp/rpush.pid'
+    expect(config.pid_file).to eq '/tmp/rails_root/tmp/rpush.pid'
+  end
+
+  it 'does not alter an absolute pid_file path' do
+    config.pid_file = '/tmp/rpush.pid'
+    expect(config.pid_file).to eq '/tmp/rpush.pid'
+  end
+
+  it 'delegate redis_options to Modis' do
+    Rpush.config.client = :redis
+    Rpush.config.redis_options = { hi: :mom }
+    expect(Modis.redis_options).to eq(hi: :mom)
+  end
+end

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

@@ -0,0 +1,253 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Adm::Delivery do
+  let(:app) { Rpush::Adm::App.create!(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, notification_processed: 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
+
+    allow(delivery).to receive_messages(reflect: nil)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Time).to receive_messages(now: now)
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  describe 'unknown error response' do
+    before do
+      allow(response).to receive_messages(code: 408)
+    end
+
+    it 'marks the notification as failed because no successful delivery was made' do
+      allow(response).to receive_messages(body: JSON.dump('reason' => 'InvalidData'))
+      error = Rpush::DeliveryError.new(408, notification.id, 'Request Timeout')
+      expect(delivery).to receive(:mark_failed).with(error)
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 200 (Ok) response' do
+    before do
+      allow(response).to receive_messages(code: 200)
+    end
+
+    it 'marks the notification as delivered if delivered successfully to all devices' do
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'xyz'))
+      expect(delivery).to receive(:mark_delivered)
+      perform
+    end
+
+    it 'logs that the notification was delivered' do
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'xyz'))
+      expect(logger).to receive(:info).with("[MyApp] #{notification.id} sent to xyz")
+      perform
+    end
+
+    it 'reflects on canonical IDs' do
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'canonical123'))
+      allow(notification).to receive_messages(registration_ids: ['1'])
+      expect(delivery).to receive(:reflect).with(:adm_canonical_id, '1', 'canonical123')
+      perform
+    end
+  end
+
+  describe 'a 400 (Bad Request) response' do
+    before do
+      allow(response).to receive_messages(code: 400)
+    end
+
+    it 'marks the notification as failed because no successful delivery was made' do
+      allow(response).to receive_messages(body: JSON.dump('reason' => 'InvalidData'))
+      error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      expect { perform }.to raise_error(error)
+    end
+
+    it 'logs that the notification was not delivered' do
+      allow(response).to receive_messages(body: JSON.dump('reason' => 'InvalidRegistrationId'))
+      expect(logger).to receive(:warn).with("[MyApp] bad_request: xyz (InvalidRegistrationId)")
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+
+    it 'reflects' do
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'canonical123', 'reason' => 'Unregistered'))
+      allow(notification).to receive_messages(registration_ids: ['1'])
+      expect(delivery).to receive(:reflect).with(:adm_failed_to_recipient, notification, '1', 'Unregistered')
+      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
+      allow(response).to receive_messages(code: 401, header: { 'retry-after' => 10 })
+
+      # first request to deliver message that returns unauthorized response
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
+      expect(http).to 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
+      expect(http).to receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+
+      expect(store).to receive(:update_app).with(notification.app)
+      expect(delivery).to receive(:mark_retryable).with(notification, now)
+
+      perform
+    end
+
+    it 'should update the app with the new access token' do
+      # request for access token
+      expect(http).to receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+
+      expect(store).to receive(:update_app) do |app|
+        expect(app.access_token).to eq 'ACCESS_TOKEN'
+        expect(app.access_token_expiration).to eq now + 60.seconds
+      end
+      expect(delivery).to 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
+      allow(token_response).to receive_messages(code: 404, body: "test")
+      # request for access token
+      expect(http).to receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+
+      expect(store).not_to receive(:update_app).with(notification.app)
+      expect(delivery).not_to receive(:mark_retryable)
+
+      expect(logger).to 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: %w(abc xyz), deliver_after: Time.now, collapse_key: 'sync', data: { 'message' => 'test' }) }
+    let(:rate_limited_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
+      allow(response).to receive_messages(code: 429, header: { 'retry-after' => 3600 })
+
+      # first request to deliver message that returns too many request response
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 1.hour)
+      perform
+    end
+
+    it 'should retry the entire notification using exponential backoff' do
+      allow(response).to receive_messages(code: 429, header: {})
+
+      # first request to deliver message that returns too many request response
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+
+      expect(delivery).to 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
+      allow(response).to receive_messages(code: 200, body: JSON.dump('registrationID' => 'abc'))
+
+      # first request to deliver message succeeds
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'abc'))
+      expect(http).to 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(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'xyz'))
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(rate_limited_response)
+
+      expect(store).to receive(:update_notification) do |notif|
+        expect(notif.registration_ids).to include('abc')
+        expect(notif.registration_ids).to_not include('xyz')
+      end
+
+      expect(store).to receive(:create_adm_notification) do |attrs, _notification_data, reg_ids, deliver_after, notification_app|
+        expect(attrs.keys).to include('collapse_key')
+        expect(attrs.keys).to include('delay_while_idle')
+        expect(attrs.keys).to include('app_id')
+
+        expect(reg_ids).to eq ['xyz']
+        expect(deliver_after).to eq now + 1.hour
+        expect(notification_app).to eq notification.app
+      end
+
+      expect(delivery).to receive(:mark_delivered)
+
+      perform
+    end
+  end
+
+  describe 'a 500 (Internal Server Error) response' do
+    before do
+      allow(response).to receive_messages(code: 500)
+    end
+
+    it 'marks the notification as failed because no successful delivery was made' do
+      error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+
+    it 'logs that the notification was not delivered' do
+      expect(logger).to 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
+      allow(response).to receive_messages(code: 503, header: { 'retry-after' => 10 })
+    end
+
+    it 'should retry the notification respecting the Retry-After header' do
+      expect(delivery).to 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: %w(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
+      allow(response).to receive_messages(code: 200, body: JSON.dump('registrationID' => 'abc'))
+
+      # first request to deliver message succeeds
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'abc'))
+      expect(http).to 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(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'xyz'))
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(bad_request_response)
+
+      expect(store).to receive(:update_notification) do |notif|
+        expect(notif.error_description).to eq "Failed to deliver to recipients: \nxyz: InvalidData"
+      end
+
+      expect(delivery).to 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::CertificateExpiredError do
+  let(:app) { double(name: 'test') }
+  let(:error) { Rpush::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,108 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Apns::Delivery do
+  let(:app) { double(name: 'MyApp') }
+  let(:notification1) { double.as_null_object }
+  let(:notification2) { double.as_null_object }
+  let(:batch) { double(mark_all_failed: nil, mark_all_delivered: nil, all_processed: nil) }
+  let(:logger) { double(error: nil, info: nil) }
+  let(:connection) { double(select: false, write: nil, reconnect: nil, close: nil, connect: nil) }
+  let(:delivery) { Rpush::Daemon::Apns::Delivery.new(app, connection, batch) }
+
+  before do
+    allow(batch).to receive(:each_notification) do |&blk|
+      [notification1, notification2].each(&blk)
+    end
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  it 'writes the binary batch' do
+    allow(notification1).to receive_messages(to_binary: 'binary1')
+    allow(notification2).to receive_messages(to_binary: 'binary2')
+    expect(connection).to receive(:write).with('binary1binary2')
+    delivery.perform
+  end
+
+  it 'logs the notification deliveries' do
+    allow(notification1).to receive_messages(id: 666, device_token: 'abc123')
+    allow(notification2).to receive_messages(id: 42, device_token: 'abc456')
+    expect(logger).to receive(:info).with('[MyApp] 666 sent to abc123')
+    expect(logger).to receive(:info).with('[MyApp] 42 sent to abc456')
+    delivery.perform
+  end
+
+  it 'marks all notifications as delivered' do
+    expect(delivery).to receive(:mark_batch_delivered)
+    delivery.perform
+  end
+
+  it 'notifies the batch all notifications have been processed' do
+    expect(batch).to receive(:all_processed)
+    delivery.perform
+  end
+
+  describe 'when an error is raised' do
+    it 'marks all notifications as failed' do
+      error = StandardError.new
+      allow(connection).to receive(:write).and_raise(error)
+      expect(delivery).to receive(:mark_batch_failed).with(error)
+      expect { delivery.perform }.to raise_error(error)
+    end
+  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, "Unable to deliver notification 69, received error 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::DisconnectionError)
+  #     end
+  #
+  #     it 'marks the notification as failed' do
+  #       delivery.should_receive(:mark_failed).with(nil, "The APNs disconnected without returning an error. This may indicate you are using an invalid certificate for the host.")
+  #       perform
+  #     end
+  #   end
+  # end
+end

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

@@ -0,0 +1,119 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
+
+describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
+  let(:host) { 'feedback.push.apple.com' }
+  let(:port) { 2196 }
+  let(:frequency) { 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, stop: nil) }
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, create_apns_feedback: feedback, release_connection: nil) }
+
+  before do
+    Rpush.config.apns.feedback_receiver.frequency = frequency
+    allow(Rpush::Daemon::InterruptibleSleep).to receive_messages(new: sleeper)
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection)
+    receiver.instance_variable_set("@stop", false)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+  end
+
+  def double_connection_read_with_tuple
+    def connection.read(*)
+      unless @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 'initializes the sleeper with the feedback polling frequency' do
+    expect(Rpush::Daemon::InterruptibleSleep).to receive_messages(new: sleeper)
+    Rpush::Daemon::Apns::FeedbackReceiver.new(app)
+  end
+
+  it 'instantiates a new connection' do
+    expect(Rpush::Daemon::TcpConnection).to receive(:new).with(app, host, port)
+    receiver.check_for_feedback
+  end
+
+  it 'connects to the feeback service' do
+    expect(connection).to receive(:connect)
+    receiver.check_for_feedback
+  end
+
+  it 'closes the connection' do
+    expect(connection).to receive(:close)
+    receiver.check_for_feedback
+  end
+
+  it 'reads from the connection' do
+    expect(connection).to receive(:read).with(38)
+    receiver.check_for_feedback
+  end
+
+  it 'logs the feedback' do
+    double_connection_read_with_tuple
+    expect(Rpush.logger).to 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
+    expect(Rpush::Daemon.store).to receive(:create_apns_feedback).with(Time.at(1_323_533_325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
+    double_connection_read_with_tuple
+    receiver.check_for_feedback
+  end
+
+  it 'logs errors' do
+    error = StandardError.new('bork!')
+    allow(connection).to receive(:read).and_raise(error)
+    expect(Rpush.logger).to receive(:error).with(error)
+    receiver.check_for_feedback
+  end
+
+  describe 'start' do
+    before do
+      allow(Thread).to receive(:new).and_yield
+      allow(receiver).to receive(:loop).and_yield
+    end
+
+    it 'sleeps' do
+      allow(receiver).to receive(:check_for_feedback)
+      expect(sleeper).to receive(:sleep).at_least(:once)
+      receiver.start
+    end
+
+    it 'checks for feedback when started' do
+      expect(receiver).to receive(:check_for_feedback).at_least(:once)
+      receiver.start
+    end
+  end
+
+  describe 'stop' do
+    it 'interrupts sleep when stopped' do
+      allow(receiver).to receive(:check_for_feedback)
+      expect(sleeper).to receive(:stop)
+      receiver.stop
+    end
+
+    it 'releases the store connection' do
+      allow(Thread).to receive(:new).and_yield
+      allow(receiver).to receive(:loop).and_yield
+      expect(Rpush::Daemon.store).to receive(:release_connection)
+      receiver.start
+      receiver.stop
+    end
+  end
+
+  it 'reflects feedback was received' do
+    double_connection_read_with_tuple
+    expect(receiver).to receive(:reflect).with(:apns_feedback, feedback)
+    receiver.check_for_feedback
+  end
+end