rapns 3.3.2-java → 3.4.0-java

data/spec/unit/daemon/gcm/app_runner_spec.rb

@@ -7,11 +7,13 @@ describe Rapns::Daemon::Gcm::AppRunner do
   let(:app_class) { Rapns::Gcm::App }
   let(:app) { app_class.new }
   let(:runner) { Rapns::Daemon::Gcm::AppRunner.new(app) }
-  let(:handler) { stub(:start => nil, :stop => nil, :queue= => nil) }
-  let(:logger) { stub(:info => nil) }
+  let(:handler) { double(:start => nil, :queue= => nil, :wakeup => nil, :wait => nil) }
+  let(:handler_collection) { double(:handler_collection, :push => nil, :size => 1, :stop => nil) }
+  let(:logger) { double(:info => nil) }
 
   before do
     Rapns.stub(:logger => logger)
     Rapns::Daemon::Gcm::DeliveryHandler.stub(:new => handler)
+    Rapns::Daemon::DeliveryHandlerCollection.stub(:new => handler_collection)
   end
 end

data/spec/unit/daemon/gcm/delivery_handler_spec.rb

@@ -4,23 +4,32 @@ require File.dirname(__FILE__) + '/../delivery_handler_shared.rb'
 describe Rapns::Daemon::Gcm::DeliveryHandler do
   it_should_behave_like 'an DeliveryHandler subclass'
 
-  let(:app) { stub }
+  let(:notification) { double }
+  let(:batch) { double(:notification_processed => nil) }
+  let(:queue) { Queue.new }
+  let(:app) { double }
   let(:delivery_handler) { Rapns::Daemon::Gcm::DeliveryHandler.new(app) }
-  let(:notification) { stub }
-  let(:http) { stub(:shutdown => nil)}
-  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+  let(:http) { double(:shutdown => nil) }
+  let(:delivery) { double(:perform => nil) }
 
   before do
     Net::HTTP::Persistent.stub(:new => http)
-    Rapns::Daemon::Gcm::Delivery.stub(:perform)
+    Rapns::Daemon::Gcm::Delivery.stub(:new => delivery)
     delivery_handler.queue = queue
-    queue.push(notification)
+    queue.push([notification, batch])
   end
 
-  it 'performs delivery of an notification' do
-    Rapns::Daemon::Gcm::Delivery.should_receive(:perform).with(app, http, notification)
+  def run_delivery_handler
     delivery_handler.start
     delivery_handler.stop
+    delivery_handler.wakeup
+    delivery_handler.wait
+  end
+
+  it 'performs delivery of an notification' do
+    Rapns::Daemon::Gcm::Delivery.should_receive(:new).with(app, http, notification, batch).and_return(delivery)
+    delivery.should_receive(:perform)
+    run_delivery_handler
   end
 
   it 'initiates a persistent connection object' do
@@ -30,7 +39,6 @@ describe Rapns::Daemon::Gcm::DeliveryHandler do
 
   it 'shuts down the http connection stopped' do
     http.should_receive(:shutdown)
-    delivery_handler.start
-    delivery_handler.stop
+    run_delivery_handler
   end
 end

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

@@ -3,12 +3,13 @@ require 'unit_spec_helper'
 describe Rapns::Daemon::Gcm::Delivery do
   let(:app) { Rapns::Gcm::App.new(:name => 'MyApp', :auth_key => 'abc123') }
   let(:notification) { Rapns::Gcm::Notification.create!(:app => app, :registration_ids => ['xyz'], :deliver_after => Time.now) }
-  let(:logger) { stub(:error => nil, :info => nil, :warn => nil) }
-  let(:response) { stub(:code => 200, :header => {}) }
-  let(:http) { stub(:shutdown => nil, :request => response)}
+  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(:delivery) { Rapns::Daemon::Gcm::Delivery.new(app, http, notification) }
-  let(:store) { stub(:mark_failed => nil, :mark_delivered => nil, :retry_after => nil, :create_gcm_notification => stub(:id => 2)) }
+  let(:batch) { double(:mark_failed => nil, :mark_delivered => nil, :mark_retryable => nil) }
+  let(:delivery) { Rapns::Daemon::Gcm::Delivery.new(app, http, notification, batch) }
+  let(:store) { double(:create_gcm_notification => double(:id => 2)) }
 
   def perform
     delivery.perform
@@ -21,6 +22,35 @@ describe Rapns::Daemon::Gcm::Delivery do
     Rapns.stub(:logger => logger)
   end
 
+  shared_examples_for 'an notification with some delivery failures' do
+    let(:new_notification) { Rapns::Gcm::Notification.where('id != ?', notification.id).first }
+
+    before { response.stub(:body => JSON.dump(body)) }
+
+    it 'marks the original notification as failed' do
+      batch.should_receive(:mark_failed).with(notification, nil, error_description)
+      perform rescue Rapns::DeliveryError
+    end
+
+    it 'reflects the notification delivery failed' do
+      delivery.should_receive(:reflect).with(:notification_failed, notification)
+      perform rescue Rapns::DeliveryError
+    end
+
+    it 'creates a new notification for the unavailable devices' do
+      notification.update_attributes(:registration_ids => ['id_0', 'id_1', 'id_2'], :data => {'one' => 1}, :collapse_key => 'thing', :delay_while_idle => true)
+      response.stub(:header => { 'retry-after' => 10 })
+      attrs = { 'collapse_key' => 'thing', 'delay_while_idle' => true, 'app_id' => app.id }
+      store.should_receive(:create_gcm_notification).with(attrs, notification.data,
+          ['id_0', 'id_2'], now + 10.seconds, notification.app)
+      perform rescue Rapns::DeliveryError
+    end
+
+    it 'raises a DeliveryError' do
+      expect { perform }.to raise_error(Rapns::DeliveryError)
+    end
+  end
+
   describe 'an 200 response' do
     before do
       response.stub(:code => 200)
@@ -28,7 +58,7 @@ describe Rapns::Daemon::Gcm::Delivery do
 
     it 'marks the notification as delivered if delivered successfully to all devices' do
       response.stub(:body => JSON.dump({ 'failure' => 0 }))
-      store.should_receive(:mark_delivered).with(notification)
+      batch.should_receive(:mark_delivered).with(notification)
       perform
     end
 
@@ -53,7 +83,7 @@ describe Rapns::Daemon::Gcm::Delivery do
           { 'error' => 'NotRegistered' }
       ]}
       response.stub(:body => JSON.dump(body))
-      store.should_receive(:mark_failed).with(notification, nil, "Failed to deliver to all recipients. Errors: NotRegistered.")
+      batch.should_receive(:mark_failed).with(notification, nil, "Failed to deliver to all recipients. Errors: NotRegistered.")
       perform rescue Rapns::DeliveryError
     end
 
@@ -87,17 +117,17 @@ describe Rapns::Daemon::Gcm::Delivery do
 
       it 'retries the notification respecting the Retry-After header' do
         response.stub(:header => { 'retry-after' => 10 })
-        store.should_receive(:retry_after).with(notification, now + 10.seconds)
+        batch.should_receive(:mark_retryable).with(notification, now + 10.seconds)
         perform
       end
 
       it 'retries the notification using exponential back-off if the Retry-After header is not present' do
-        store.should_receive(:retry_after).with(notification, now + 2)
+        batch.should_receive(:mark_retryable).with(notification, now + 2)
         perform
       end
 
       it 'does not mark the notification as failed' do
-        store.should_not_receive(:mark_failed)
+        batch.should_not_receive(:mark_failed)
         perform
       end
 
@@ -115,7 +145,7 @@ describe Rapns::Daemon::Gcm::Delivery do
       before { response.stub(:body => JSON.dump(body)) }
 
       it 'marks the original notification as failed' do
-        store.should_receive(:mark_failed).with(notification, nil, error_description)
+        batch.should_receive(:mark_failed).with(notification, nil, error_description)
         perform rescue Rapns::DeliveryError
       end
 
@@ -177,18 +207,18 @@ describe Rapns::Daemon::Gcm::Delivery do
 
     it 'respects an integer Retry-After header' do
       response.stub(:header => { 'retry-after' => 10 })
-      store.should_receive(:retry_after).with(notification, now + 10.seconds)
+      batch.should_receive(:mark_retryable).with(notification, now + 10.seconds)
       perform
     end
 
     it 'respects a HTTP-date Retry-After header' do
       response.stub(:header => { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
-      store.should_receive(:retry_after).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
+      batch.should_receive(:mark_retryable).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
       perform
     end
 
     it 'defaults to exponential back-off if the Retry-After header is not present' do
-      store.should_receive(:retry_after).with(notification, now + 2 ** 1)
+      batch.should_receive(:mark_retryable).with(notification, now + 2 ** 1)
       perform
     end
 
@@ -212,7 +242,7 @@ describe Rapns::Daemon::Gcm::Delivery do
     end
 
     it 'retries the notification in accordance with the exponential back-off strategy.' do
-      store.should_receive(:retry_after).with(notification, now + 2 ** 3)
+      batch.should_receive(:mark_retryable).with(notification, now + 2 ** 3)
       perform
     end
 
@@ -234,7 +264,7 @@ describe Rapns::Daemon::Gcm::Delivery do
     before { response.stub(:code => 400) }
 
     it 'marks the notification as failed' do
-      store.should_receive(:mark_failed).with(notification, 400, 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.')
+      batch.should_receive(:mark_failed).with(notification, 400, 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.')
       perform rescue Rapns::DeliveryError
     end
 
@@ -248,7 +278,7 @@ describe Rapns::Daemon::Gcm::Delivery do
     before { response.stub(:code => 418) }
 
     it 'marks the notification as failed' do
-      store.should_receive(:mark_failed).with(notification, 418, "I'm a Teapot")
+      batch.should_receive(:mark_failed).with(notification, 418, "I'm a Teapot")
       perform rescue Rapns::DeliveryError
     end
 

data/spec/unit/daemon/interruptible_sleep_spec.rb

@@ -5,8 +5,8 @@ describe Rapns::Daemon::InterruptibleSleep do
     extend Rapns::Daemon::InterruptibleSleep
   end
 
-  let(:rd) { stub(:close => nil) }
-  let(:wr) { stub(:close => nil) }
+  let(:rd) { double(:close => nil) }
+  let(:wr) { double(:close => nil) }
 
   before do
     IO.stub(:pipe)
@@ -37,4 +37,4 @@ describe Rapns::Daemon::InterruptibleSleep do
     wr.should_receive(:close)
     SleepTest.interrupt_sleep
   end
-end
+end

data/spec/unit/daemon/reflectable_spec.rb

@@ -5,7 +5,7 @@ describe Rapns::Daemon::Reflectable do
     include Rapns::Daemon::Reflectable
   end
 
-  let(:logger) { stub(:error => nil) }
+  let(:logger) { double(:error => nil) }
   let(:test_reflectable) { TestReflectable.new }
 
   before do

data/spec/unit/daemon/store/active_record/reconnectable_spec.rb

@@ -43,7 +43,7 @@ describe Rapns::Daemon::Store::ActiveRecord::Reconnectable do
   let(:test_double) { TestDouble.new(error, 1) }
 
   before do
-    @logger = mock("Logger", :info => nil, :error => nil, :warn => nil)
+    @logger = double("Logger", :info => nil, :error => nil, :warn => nil)
     Rapns.stub(:logger).and_return(@logger)
 
     ActiveRecord::Base.stub(:clear_all_connections!)

data/spec/unit/daemon/store/active_record_spec.rb

@@ -5,10 +5,15 @@ describe Rapns::Daemon::Store::ActiveRecord do
   let(:app) { Rapns::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
   let(:notification) { Rapns::Apns::Notification.create!(:device_token => "a" * 64, :app => app) }
   let(:store) { Rapns::Daemon::Store::ActiveRecord.new }
-  let(:now) { Time.now }
+  let(:now) { Time.now.utc }
 
   before { Time.stub(:now => now) }
 
+  it 'reconnects after daemonize' do
+    store.should_receive(:reconnect_database)
+    store.after_daemonize
+  end
+
   describe 'deliverable_notifications' do
     it 'checks for new notifications with the ability to reconnect the database' do
       store.should_receive(:with_database_reconnect_and_retry)
@@ -18,7 +23,7 @@ describe Rapns::Daemon::Store::ActiveRecord do
     it 'loads notifications in batches' do
       Rapns.config.batch_size = 5000
       Rapns.config.push = false
-      relation = stub.as_null_object
+      relation = double.as_null_object
       relation.should_receive(:limit).with(5000)
       Rapns::Notification.stub(:ready_for_delivery => relation)
       store.deliverable_notifications([app])
@@ -26,7 +31,7 @@ describe Rapns::Daemon::Store::ActiveRecord do
 
     it 'does not load notification in batches if in push mode' do
       Rapns.config.push = true
-      relation = stub.as_null_object
+      relation = double.as_null_object
       relation.should_not_receive(:limit)
       Rapns::Notification.stub(:ready_for_delivery => relation)
       store.deliverable_notifications([app])
@@ -63,23 +68,40 @@ describe Rapns::Daemon::Store::ActiveRecord do
     end
   end
 
-  describe 'retry_after' do
+  describe 'mark_retryable' do
     it 'increments the retry count' do
       expect do
-        store.retry_after(notification, now)
+        store.mark_retryable(notification, now)
       end.to change(notification, :retries).by(1)
     end
 
     it 'sets the deliver after timestamp' do
       deliver_after = now + 10.seconds
       expect do
-        store.retry_after(notification, deliver_after)
+        store.mark_retryable(notification, deliver_after)
       end.to change(notification, :deliver_after).to(deliver_after)
     end
 
     it 'saves the notification without validation' do
       notification.should_receive(:save!).with(:validate => false)
-      store.retry_after(notification, now)
+      store.mark_retryable(notification, now)
+    end
+  end
+
+  describe 'mark_batch_retryable' do
+    it 'increments the retired count' do
+      expect do
+        store.mark_batch_retryable([notification], now)
+        notification.reload
+      end.to change(notification, :retries).by(1)
+    end
+
+    it 'sets the deliver after timestamp' do
+      deliver_after = now + 10.seconds
+      expect do
+        store.mark_batch_retryable([notification], deliver_after)
+        notification.reload
+      end.to change { notification.deliver_after.try(:utc).to_s }.to(deliver_after.utc.to_s)
     end
   end
 
@@ -93,7 +115,8 @@ describe Rapns::Daemon::Store::ActiveRecord do
     it 'sets the time the notification was delivered' do
       expect do
         store.mark_delivered(notification)
-      end.to change(notification, :delivered_at).to(now)
+        notification.reload
+      end.to change { notification.delivered_at.try(:utc).to_s }.to(now.to_s)
     end
 
     it 'saves the notification without validation' do
@@ -102,6 +125,22 @@ describe Rapns::Daemon::Store::ActiveRecord do
     end
   end
 
+  describe 'mark_batch_delivered' do
+    it 'marks the notifications as delivered' do
+      expect do
+        store.mark_batch_delivered([notification])
+        notification.reload
+      end.to change(notification, :delivered).to(true)
+    end
+
+    it 'sets the time the notifications were delivered' do
+      expect do
+        store.mark_batch_delivered([notification])
+        notification.reload
+      end.to change { notification.delivered_at.try(:utc).to_s }.to(now.to_s)
+    end
+  end
+
   describe 'mark_failed' do
     it 'marks the notification as not delivered' do
       store.mark_failed(notification, nil, '')
@@ -111,13 +150,15 @@ describe Rapns::Daemon::Store::ActiveRecord do
     it 'marks the notification as failed' do
       expect do
         store.mark_failed(notification, nil, '')
+        notification.reload
       end.to change(notification, :failed).to(true)
     end
 
     it 'sets the time the notification delivery failed' do
       expect do
         store.mark_failed(notification, nil, '')
-      end.to change(notification, :failed_at).to(now)
+        notification.reload
+      end.to change { notification.failed_at.try(:utc).to_s }.to(now.to_s)
     end
 
     it 'sets the error code' do
@@ -138,6 +179,42 @@ describe Rapns::Daemon::Store::ActiveRecord do
     end
   end
 
+  describe 'mark_batch_failed' do
+    it 'marks the notification as not delivered' do
+      store.mark_batch_failed([notification], nil, '')
+      notification.reload
+      notification.delivered.should be_false
+    end
+
+    it 'marks the notification as failed' do
+      expect do
+        store.mark_batch_failed([notification], nil, '')
+        notification.reload
+      end.to change(notification, :failed).to(true)
+    end
+
+    it 'sets the time the notification delivery failed' do
+      expect do
+        store.mark_batch_failed([notification], nil, '')
+        notification.reload
+      end.to change { notification.failed_at.try(:utc).to_s }.to(now.to_s)
+    end
+
+    it 'sets the error code' do
+      expect do
+        store.mark_batch_failed([notification], 42, '')
+        notification.reload
+      end.to change(notification, :error_code).to(42)
+    end
+
+    it 'sets the error description' do
+      expect do
+        store.mark_batch_failed([notification], 42, 'Weeee')
+        notification.reload
+      end.to change(notification, :error_description).to('Weeee')
+    end
+  end
+
   describe 'create_apns_feedback' do
     it 'creates the Feedback record' do
       Rapns::Apns::Feedback.should_receive(:create!).with(
@@ -170,7 +247,7 @@ describe Rapns::Daemon::Store::ActiveRecord do
 
     it 'sets the deliver_after timestamp' do
       new_notification = store.create_gcm_notification(*args)
-      new_notification.deliver_after.should == deliver_after
+      new_notification.deliver_after.to_s.should == deliver_after.to_s
     end
 
     it 'saves the new notification' do

data/spec/unit/daemon_spec.rb

@@ -4,12 +4,12 @@ require 'rapns/daemon/store/active_record'
 describe Rapns::Daemon, "when starting" do
   module Rails; end
 
-  let(:certificate) { stub }
-  let(:password) { stub }
-  let(:config) { stub(:pid_file => nil, :airbrake_notify => false,
+  let(:certificate) { double }
+  let(:password) { double }
+  let(:config) { double(:pid_file => nil, :airbrake_notify => false,
     :foreground => true, :embedded => false, :push => false,
     :store => :active_record, :logger => nil) }
-  let(:logger) { stub(:logger, :info => nil, :error => nil, :warn => nil) }
+  let(:logger) { double(:logger, :info => nil, :error => nil, :warn => nil) }
 
   before do
     Rapns.stub(:config => config, :logger => logger)
@@ -102,8 +102,8 @@ describe Rapns::Daemon, "when starting" do
 end
 
 describe Rapns::Daemon, "when being shutdown" do
-  let(:config) { stub(:pid_file => '/rails_root/rapns.pid') }
-  let(:logger) { stub(:info => nil, :error => nil, :warn => nil) }
+  let(:config) { double(:pid_file => '/rails_root/rapns.pid') }
+  let(:logger) { double(:info => nil, :error => nil, :warn => nil) }
 
   before do
     Rapns.stub(:config => config)