rapns 3.3.2-java → 3.4.0-java

data/spec/unit/apns_feedback_spec.rb

@@ -2,7 +2,7 @@ require 'unit_spec_helper'
 
 describe Rapns, 'apns_feedback' do
   let!(:app) { Rapns::Apns::App.create!(:name => 'test', :environment => 'production', :certificate => TEST_CERT) }
-  let(:receiver) { stub(:check_for_feedback => nil) }
+  let(:receiver) { double(:check_for_feedback => nil) }
 
   before do
     Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => receiver)

data/spec/unit/configuration_spec.rb

@@ -1,7 +1,7 @@
 require 'unit_spec_helper'
 
 describe Rapns do
-  let(:config) { stub }
+  let(:config) { double }
 
   before { Rapns.stub(:config => config) }
 
@@ -11,20 +11,26 @@ describe Rapns do
 end
 
 describe Rapns::Configuration do
-  let(:config) { Rapns::Configuration.new }
+  let(:config) do
+    Rapns::Deprecation.muted do
+      Rapns::Configuration.new
+    end
+  end
 
   it 'configures a feedback callback' do
     b = Proc.new {}
-    Rapns::Deprecation.silenced do
+    Rapns::Deprecation.muted do
       config.on_apns_feedback(&b)
     end
     config.apns_feedback_callback.should == b
   end
 
   it 'can be updated' do
-    new_config = Rapns::Configuration.new
-    new_config.batch_size = 100
-    expect { config.update(new_config) }.to change(config, :batch_size).to(100)
+    Rapns::Deprecation.muted do
+      new_config = Rapns::Configuration.new
+      new_config.batch_size = 100
+      expect { config.update(new_config) }.to change(config, :batch_size).to(100)
+    end
   end
 
   it 'sets the pid_file relative if not absolute' do

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

@@ -8,14 +8,16 @@ describe Rapns::Daemon::Apns::AppRunner do
   let(:app) { app_class.create!(:name => 'my_app', :environment => 'development',
                                 :certificate => TEST_CERT, :password => 'pass') }
   let(:runner) { Rapns::Daemon::Apns::AppRunner.new(app) }
-  let(:handler) { stub(:start => nil, :stop => nil, :queue= => nil) }
-  let(:receiver) { stub(:start => nil, :stop => nil) }
-  let(:config) { stub(:feedback_poll => 60, :push => false) }
-  let(:logger) { stub(:info => nil) }
+  let(:handler) { double(:start => nil, :queue= => nil, :wakeup => nil, :wait => nil, :stop => nil) }
+  let(:handler_collection) { double(:handler_collection, :push => nil, :size => 1, :stop => nil) }
+  let(:receiver) { double(:start => nil, :stop => nil) }
+  let(:config) { double(:feedback_poll => 60, :push => false) }
+  let(:logger) { double(:info => nil, :warn => nil, :error => nil) }
 
   before do
     Rapns.stub(:logger => logger, :config => config)
     Rapns::Daemon::Apns::DeliveryHandler.stub(:new => handler)
+    Rapns::Daemon::DeliveryHandlerCollection.stub(:new => handler_collection)
     Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => receiver)
   end
 

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

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

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

@@ -1,17 +1,17 @@
 require "unit_spec_helper"
 
 describe Rapns::Daemon::Apns::Connection do
-  let(:ssl_context) { stub(:key= => nil, :cert= => nil) }
-  let(:rsa_key) { stub }
-  let(:certificate) { stub }
-  let(:password) { stub }
-  let(:x509_certificate) { stub }
+  let(:rsa_key) { double }
+  let(:certificate) { double }
+  let(:password) { double }
+  let(:x509_certificate) { OpenSSL::X509::Certificate.new(TEST_CERT) }
+  let(:ssl_context) { double(:key= => nil, :cert= => nil, :cert => x509_certificate) }
   let(:host) { 'gateway.push.apple.com' }
   let(:port) { '2195' }
-  let(:tcp_socket) { stub(:setsockopt => nil, :close => nil) }
-  let(:ssl_socket) { stub(:sync= => nil, :connect => nil, :close => nil, :write => nil, :flush => nil) }
-  let(:logger) { stub(:info => nil, :error => nil) }
-  let(:app) { stub(:name => 'Connection 0', :certificate => certificate, :password => password)}
+  let(:tcp_socket) { double(:setsockopt => nil, :close => nil) }
+  let(:ssl_socket) { double(:sync= => nil, :connect => nil, :close => nil, :write => nil, :flush => nil) }
+  let(:logger) { double(:info => nil, :error => nil, :warn => nil) }
+  let(:app) { double(:name => 'Connection 0', :certificate => certificate, :password => password)}
   let(:connection) { Rapns::Daemon::Apns::Connection.new(app, host, port) }
 
   before do
@@ -21,6 +21,7 @@ describe Rapns::Daemon::Apns::Connection do
     TCPSocket.stub(:new => tcp_socket)
     OpenSSL::SSL::SSLSocket.stub(:new => ssl_socket)
     Rapns.stub(:logger => logger)
+    connection.stub(:reflect)
   end
 
   it "reads the number of bytes from the SSL socket" do
@@ -79,6 +80,39 @@ describe Rapns::Daemon::Apns::Connection do
       tcp_socket.should_receive(:setsockopt).with(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1)
       connection.connect
     end
+
+    describe 'certificate expiry' do
+      it 'reflects if the certificate will expire soon' do
+        cert = OpenSSL::X509::Certificate.new(app.certificate)
+        connection.should_receive(:reflect).with(:apns_certificate_will_expire, app, cert.not_after)
+        Timecop.freeze(cert.not_after - 3.days) { connection.connect }
+      end
+
+      it 'logs that the certificate will expire soon' do
+        cert = OpenSSL::X509::Certificate.new(app.certificate)
+        logger.should_receive(:warn).with("[#{app.name}] Certificate will expire at 2022-09-07 03:18:32 UTC.")
+        Timecop.freeze(cert.not_after - 3.days) { connection.connect }
+      end
+
+      it 'does not reflect if the certificate will not expire soon' do
+        cert = OpenSSL::X509::Certificate.new(app.certificate)
+        connection.should_not_receive(:reflect).with(:apns_certificate_will_expire, app, kind_of(Time))
+        Timecop.freeze(cert.not_after - 2.months) { connection.connect }
+      end
+
+      it 'logs that the certificate has expired' do
+        cert = OpenSSL::X509::Certificate.new(app.certificate)
+        logger.should_receive(:error).with("[#{app.name}] Certificate expired at 2022-09-07 03:18:32 UTC.")
+        Timecop.freeze(cert.not_after + 1.day) { connection.connect rescue Rapns::Apns::CertificateExpiredError }
+      end
+
+      it 'raises an error if the certificate has expired' do
+        cert = OpenSSL::X509::Certificate.new(app.certificate)
+        Timecop.freeze(cert.not_after + 1.day) do
+          expect { connection.connect }.to raise_error(Rapns::Apns::CertificateExpiredError)
+        end
+      end
+    end
   end
 
   describe "when shuting down the connection" do
@@ -111,7 +145,7 @@ describe Rapns::Daemon::Apns::Connection do
     it "ignores IOError when the socket is already closed" do
       tcp_socket.stub(:close).and_raise(IOError)
       connection.connect
-      expect { connection.close }.to_not raise_error(IOError)
+      connection.close
     end
   end
 
@@ -194,6 +228,8 @@ describe Rapns::Daemon::Apns::Connection do
   end
 
   describe "when reconnecting" do
+    before { connection.connect }
+
     it 'closes the socket' do
       connection.should_receive(:close)
       connection.send(:reconnect)

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

@@ -6,44 +6,50 @@ describe Rapns::Daemon::Apns::DeliveryHandler do
 
   let(:host) { 'gateway.push.apple.com' }
   let(:port) { 2195 }
-  let(:certificate) { stub }
-  let(:password) { stub }
-  let(:app) { stub(:password => password, :certificate => certificate, :name => 'MyApp', :environment => 'production')}
+  let(:certificate) { double }
+  let(:password) { double }
+  let(:app) { double(:password => password, :certificate => certificate, :name => 'MyApp', :environment => 'production')}
   let(:delivery_handler) { Rapns::Daemon::Apns::DeliveryHandler.new(app) }
-  let(:connection) { stub('Connection', :select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
-  let(:notification) { stub }
-  let(:http) { stub(:shutdown => nil)}
-  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+  let(:connection) { double(:connection, :select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
+  let(:notification) { double(:notification) }
+  let(:batch) { double(:batch, :notification_processed => nil) }
+  let(:http) { double(:http, :shutdown => nil)}
+  let(:queue) { Queue.new }
+  let(:delivery) { double(:perform => nil) }
 
   before do
     Rapns::Daemon::Apns::Connection.stub(:new => connection)
-    Rapns::Daemon::Apns::Delivery.stub(:perform)
+    Rapns::Daemon::Apns::Delivery.stub(:new => delivery)
     delivery_handler.queue = queue
-    queue.push(notification)
+    queue.push([notification, batch])
   end
 
-  it "instantiates a new connection" do
-    Rapns::Daemon::Apns::Connection.should_receive(:new).with(app, host, port)
+  def run_delivery_handler
     delivery_handler.start
     delivery_handler.stop
+    delivery_handler.wakeup
+    delivery_handler.wait
+  end
+
+  it "instantiates a new connection" do
+    Rapns::Daemon::Apns::Connection.should_receive(:new).with(app, host, port)
+    run_delivery_handler
   end
 
   it "connects the socket" do
     connection.should_receive(:connect)
-    delivery_handler.start
-    delivery_handler.stop
+    run_delivery_handler
   end
 
   it 'performs delivery of an notification' do
-    Rapns::Daemon::Apns::Delivery.should_receive(:perform).with(app, connection, notification)
-    delivery_handler.start
-    delivery_handler.stop
+    Rapns::Daemon::Apns::Delivery.should_receive(:new).with(app, connection, notification, batch).and_return(delivery)
+    delivery.should_receive(:perform)
+    run_delivery_handler
   end
 
   it 'closes the connection stopped' do
     connection.should_receive(:close)
-    delivery_handler.start
-    delivery_handler.stop
+    run_delivery_handler
   end
 
   it 'does not attempt to close the connection if the connection was not established' do

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

@@ -1,13 +1,13 @@
 require 'unit_spec_helper'
 
 describe Rapns::Daemon::Apns::Delivery do
-  let(:app) { stub(:name => 'MyApp') }
-  let(:notification) { stub.as_null_object }
-  let(:logger) { stub(:error => nil, :info => nil) }
-  let(:config) { stub(:check_for_errors => true) }
-  let(:connection) { stub(:select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
-  let(:delivery) { Rapns::Daemon::Apns::Delivery.new(app, connection, notification) }
-  let(:store) { stub(:mark_failed => nil, :mark_delivered => nil) }
+  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) { Rapns::Daemon::Apns::Delivery.new(app, connection, notification, batch) }
 
   def perform
     begin
@@ -17,7 +17,6 @@ describe Rapns::Daemon::Apns::Delivery do
   end
 
   before do
-    Rapns::Daemon.stub(:store => store)
     Rapns.stub(:config => config, :logger => logger)
   end
 
@@ -34,7 +33,7 @@ describe Rapns::Daemon::Apns::Delivery do
   end
 
   it "marks the notification as delivered" do
-    store.should_receive(:mark_delivered).with(notification)
+    batch.should_receive(:mark_delivered).with(notification)
     perform
   end
 
@@ -53,7 +52,7 @@ describe Rapns::Daemon::Apns::Delivery do
     before { connection.stub(:select => true, :read => [8, 4, 69].pack("ccN")) }
 
     it "marks the notification as failed" do
-      store.should_receive(:mark_failed).with(notification, 4, "Missing payload")
+      batch.should_receive(:mark_failed).with(notification, 4, "Missing payload")
       perform
     end
 
@@ -63,7 +62,7 @@ describe Rapns::Daemon::Apns::Delivery do
     end
 
     it "logs the delivery error" do
-      # checking for the stubbed error doesn't work in jruby, but checking
+      # checking for the doublebed error doesn't work in jruby, but checking
       # for the exception by class does.
 
       #error = Rapns::DeliveryError.new(4, 12, "Missing payload")
@@ -104,7 +103,7 @@ describe Rapns::Daemon::Apns::Delivery do
       end
 
       it 'marks the notification as failed' do
-        store.should_receive(:mark_failed).with(notification, nil, "APNs disconnected without returning an error.")
+        batch.should_receive(:mark_failed).with(notification, nil, "APNs disconnected without returning an error.")
         perform
       end
     end

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

@@ -4,23 +4,23 @@ describe Rapns::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   let(:host) { 'feedback.push.apple.com' }
   let(:port) { 2196 }
   let(:poll) { 60 }
-  let(:certificate) { stub }
-  let(:password) { stub }
-  let(:app) { stub(:name => 'my_app', :password => password, :certificate => certificate, :environment => 'production') }
-  let(:connection) { stub(:connect => nil, :read => nil, :close => nil) }
-  let(:logger) { stub(:error => nil, :info => nil) }
+  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) { Rapns::Daemon::Apns::FeedbackReceiver.new(app, poll) }
-  let(:feedback) { stub }
+  let(:feedback) { double }
 
   before do
     receiver.stub(:interruptible_sleep)
     Rapns.stub(:logger => logger)
     Rapns::Daemon::Apns::Connection.stub(:new => connection)
     receiver.instance_variable_set("@stop", false)
-    Rapns::Daemon.stub(:store => stub(:create_apns_feedback => feedback))
+    Rapns::Daemon.stub(:store => double(:create_apns_feedback => feedback))
   end
 
-  def stub_connection_read_with_tuple
+  def double_connection_read_with_tuple
     connection.unstub(:read)
 
     def connection.read(bytes)
@@ -52,14 +52,14 @@ describe Rapns::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   end
 
   it 'logs the feedback' do
-    stub_connection_read_with_tuple
+    double_connection_read_with_tuple
     Rapns.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
     Rapns::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1323533325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
-    stub_connection_read_with_tuple
+    double_connection_read_with_tuple
     receiver.check_for_feedback
   end
 
@@ -92,13 +92,13 @@ describe Rapns::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   end
 
   it 'reflects feedback was received' do
-    stub_connection_read_with_tuple
+    double_connection_read_with_tuple
     receiver.should_receive(:reflect).with(:apns_feedback, feedback)
     receiver.check_for_feedback
   end
 
   it 'calls the apns_feedback_callback when feedback is received and the callback is set' do
-    stub_connection_read_with_tuple
+    double_connection_read_with_tuple
     Rapns.config.apns_feedback_callback = Proc.new {}
     Rapns.config.apns_feedback_callback.should_receive(:call).with(feedback)
     receiver.check_for_feedback
@@ -106,9 +106,9 @@ describe Rapns::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
 
   it 'catches exceptions in the apns_feedback_callback' do
     error = StandardError.new('bork!')
-    stub_connection_read_with_tuple
+    double_connection_read_with_tuple
     callback = Proc.new { raise error }
-    Rapns::Deprecation.silenced do
+    Rapns::Deprecation.muted do
       Rapns.config.on_apns_feedback &callback
     end
     expect { receiver.check_for_feedback }.not_to raise_error
@@ -116,10 +116,10 @@ describe Rapns::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
 
   it 'logs an exception from the apns_feedback_callback' do
     error = StandardError.new('bork!')
-    stub_connection_read_with_tuple
+    double_connection_read_with_tuple
     callback = Proc.new { raise error }
     Rapns.logger.should_receive(:error).with(error)
-    Rapns::Deprecation.silenced do
+    Rapns::Deprecation.muted do
       Rapns.config.on_apns_feedback &callback
     end
     receiver.check_for_feedback

data/spec/unit/daemon/app_runner_shared.rb

@@ -1,7 +1,7 @@
 shared_examples_for "an AppRunner subclass" do
-  let(:queue) { stub(:notifications_processed? => true, :push => nil) }
+  let(:queue) { double(:push => nil) }
 
-  before { Rapns::Daemon::DeliveryQueue.stub(:new => queue) }
+  before { Queue.stub(:new => queue) }
   after { Rapns::Daemon::AppRunner.runners.clear }
 
   describe 'start' do
@@ -10,6 +10,11 @@ shared_examples_for "an AppRunner subclass" do
       runner.start
     end
 
+    it 'adds the delivery handler to the collection' do
+      handler_collection.should_receive(:push).with(handler)
+      runner.start
+    end
+
     it 'assigns the queue to the handler' do
       handler.should_receive(:queue=).with(queue)
       runner.start
@@ -17,11 +22,17 @@ shared_examples_for "an AppRunner subclass" do
   end
 
   describe 'enqueue' do
-    let(:notification) { stub }
+    let(:notification) { double }
+    let(:batch) { double(:notifications => [notification]) }
+
+    it 'enqueues the batch' do
+      queue.should_receive(:push).with([notification, batch])
+      runner.enqueue(batch)
+    end
 
-    it 'enqueues the notification' do
-      queue.should_receive(:push).with(notification)
-      runner.enqueue(notification)
+    it 'reflects the notification has been enqueued' do
+      runner.should_receive(:reflect).with(:notification_enqueued, notification)
+      runner.enqueue(batch)
     end
   end
 
@@ -29,19 +40,24 @@ shared_examples_for "an AppRunner subclass" do
     before { runner.start }
 
     it 'stops the delivery handlers' do
-      handler.should_receive(:stop)
+      handler_collection.should_receive(:stop)
       runner.stop
     end
   end
 
   describe 'idle?' do
     it 'is idle if all notifications have been processed' do
-      queue.stub(:notifications_processed? => true)
+      runner.batch = double(:complete? => true)
+      runner.idle?.should be_true
+    end
+
+    it 'is idle if the runner has no associated batch' do
+      runner.batch = nil
       runner.idle?.should be_true
     end
 
     it 'is not idle if not all notifications have been processed' do
-      queue.stub(:notifications_processed? => false)
+      runner.batch = double(:complete? => false)
       runner.idle?.should be_false
     end
   end
@@ -50,7 +66,7 @@ shared_examples_for "an AppRunner subclass" do
     before { runner.start }
 
     it 'reduces the number of handlers if needed' do
-      handler.should_receive(:stop)
+      handler_collection.should_receive(:pop)
       new_app = app_class.new
       new_app.stub(:connections => app.connections - 1)
       runner.sync(new_app)
@@ -58,6 +74,7 @@ shared_examples_for "an AppRunner subclass" do
 
     it 'increases the number of handlers if needed' do
       runner.should_receive(:start_handler).and_return(handler)
+      handler_collection.should_receive(:push).with(handler)
       new_app = app_class.new
       new_app.stub(:connections => app.connections + 1)
       runner.sync(new_app)