rpush 1.0.0 → 2.0.0.beta1

data/spec/unit/daemon/reflectable_spec.rb

@@ -5,12 +5,12 @@ describe Rpush::Daemon::Reflectable do
     include Rpush::Daemon::Reflectable
   end
 
-  let(:logger) { double(:error => nil) }
+  let(:logger) { double(error: nil) }
   let(:test_reflectable) { TestReflectable.new }
 
   before do
     Rpush.reflections.stub(:__dispatch)
-    Rpush.stub(:logger => logger)
+    Rpush.stub(logger: logger)
   end
 
   it 'dispatches the given reflection' do

data/spec/unit/daemon/retryable_error_spec.rb

@@ -1,7 +1,7 @@
 require "unit_spec_helper"
 
 describe Rpush::RetryableError do
-  let(:response) { double(:code => 401, :header => { 'retry-after' => 3600 }) }
+  let(:response) { double(code: 401, header: { 'retry-after' => 3600 }) }
   let(:error) { Rpush::RetryableError.new(401, 12, "Unauthorized", response) }
 
   it "returns an informative message" do

data/spec/unit/daemon/service_config_methods_spec.rb

@@ -10,10 +10,13 @@ describe Rpush::Daemon::ServiceConfigMethods do
     ServiceConfigMethodsSpec.delivery_class.should eq ServiceConfigMethodsSpec::Delivery
   end
 
-  it 'gets & sets loops' do
-    loop_class = double
+  it 'instantiates loops' do
+    loop_class = Class.new
+    app = double
+    loop_instance = loop_class.new
+    loop_class.should_receive(:new).with(app).and_return(loop_instance)
     ServiceConfigMethodsSpec.loops loop_class
-    ServiceConfigMethodsSpec.loops.should eq [loop_class]
+    ServiceConfigMethodsSpec.loop_instances(app).should eq [loop_instance]
   end
 
   it 'returns a new dispatcher' do

data/spec/unit/daemon/signal_handler_spec.rb

@@ -0,0 +1,72 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::SignalHandler do
+  def signal_handler(sig)
+    Process.kill(sig, Process.pid)
+    sleep 0.1
+  end
+
+  def with_handler_start_stop
+    Rpush::Daemon::SignalHandler.start
+    yield
+  ensure
+    Rpush::Daemon::SignalHandler.stop
+  end
+
+  describe 'shutdown signals' do
+    unless Rpush.jruby? # These tests do not work on JRuby.
+      it "shuts down when signaled signaled SIGINT" do
+        with_handler_start_stop do
+          Rpush::Daemon.should_receive(:shutdown)
+          signal_handler('SIGINT')
+        end
+      end
+
+      it "shuts down when signaled signaled SIGTERM" do
+        with_handler_start_stop do
+          Rpush::Daemon.should_receive(:shutdown)
+          signal_handler('SIGTERM')
+        end
+      end
+    end
+  end
+
+  describe 'config.embedded = true' do
+    before { Rpush.config.embedded = true }
+
+    it 'does not trap signals' do
+      Signal.should_not_receive(:trap)
+      Rpush::Daemon::SignalHandler.start
+    end
+  end
+
+  describe 'HUP' do
+    before do
+      Rpush::Daemon::AppRunner.stub(:sync)
+      Rpush::Daemon::Feeder.stub(:wakeup)
+    end
+
+    it 'syncs the AppRunner' do
+      with_handler_start_stop do
+        Rpush::Daemon::AppRunner.should_receive(:sync)
+        signal_handler('HUP')
+      end
+    end
+
+    it 'wakes up the Feeder' do
+      with_handler_start_stop do
+        Rpush::Daemon::Feeder.should_receive(:wakeup)
+        signal_handler('HUP')
+      end
+    end
+  end
+
+  describe 'USR2' do
+    it 'instructs the AppRunner to print debug information' do
+      with_handler_start_stop do
+        Rpush::Daemon::AppRunner.should_receive(:debug)
+        signal_handler('USR2')
+      end
+    end
+  end
+end

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

@@ -16,13 +16,13 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
     def perform
       with_database_reconnect_and_retry do
         @calls += 1
-        raise @error if @calls <= @max_calls
+        fail @error if @calls <= @max_calls
       end
     end
   end
 
   let(:adapter_error_class) do
-    case $adapter
+    case SPEC_ADAPTER
     when 'postgresql'
       PGError
     when 'mysql'
@@ -38,14 +38,14 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
     when 'sqlite3'
       SQLite3::Exception
     else
-      raise "Please update #{__FILE__} for adapter #{$adapter}"
+      fail "Please update #{__FILE__} for adapter #{SPEC_ADAPTER}"
     end
   end
   let(:error) { adapter_error_class.new("db down!") }
   let(:test_double) { TestDouble.new(error, 1) }
 
   before do
-    @logger = double("Logger", :info => nil, :error => nil, :warn => nil)
+    @logger = double("Logger", info: nil, error: nil, warn: nil)
     Rpush.stub(:logger).and_return(@logger)
 
     ActiveRecord::Base.stub(:clear_all_connections!)
@@ -79,21 +79,21 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
   end
 
   it "should test out the new connection by performing a count" do
-    Rpush::Notification.should_receive(:count)
+    Rpush::Client::ActiveRecord::Notification.should_receive(:count)
     test_double.perform
   end
 
   context "when the reconnection attempt is not successful" do
     before do
-      class << Rpush::Notification
+      class << Rpush::Client::ActiveRecord::Notification
         def count
           @count_calls += 1
           return if @count_calls == 2
-          raise @error
+          fail @error
         end
       end
-      Rpush::Notification.instance_variable_set("@count_calls", 0)
-      Rpush::Notification.instance_variable_set("@error", error)
+      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@count_calls", 0)
+      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@error", error)
     end
 
     it "should log the 2nd attempt" do

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

@@ -2,20 +2,15 @@ require 'unit_spec_helper'
 require 'rpush/daemon/store/active_record'
 
 describe Rpush::Daemon::Store::ActiveRecord do
-  let(:app) { Rpush::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
-  let(:notification) { Rpush::Apns::Notification.create!(:device_token => "a" * 64, :app => app) }
+  let(:app) { Rpush::Client::ActiveRecord::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
+  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.create!(device_token: "a" * 64, app: app) }
   let(:store) { Rpush::Daemon::Store::ActiveRecord.new }
   let(:time) { Time.now.utc }
   let(:logger) { double(Rpush::Logger, error: nil) }
 
   before do
     Rpush.stub(logger: logger)
-    Time.stub(:now => time)
-  end
-
-  it 'reconnects after daemonize' do
-    store.should_receive(:reconnect_database)
-    store.after_daemonize
+    Time.stub(now: time)
   end
 
   it 'can update a notification' do
@@ -29,13 +24,13 @@ describe Rpush::Daemon::Store::ActiveRecord do
   end
 
   it 'can release a connection' do
-    ActiveRecord::Base.connection_pool.should_receive(:release_connection)
+    ActiveRecord::Base.connection.should_receive(:close)
     store.release_connection
   end
 
   it 'logs errors raised when trying to release the connection' do
     e = StandardError.new
-    ActiveRecord::Base.connection_pool.stub(:release_connection).and_raise(e)
+    ActiveRecord::Base.connection.stub(:close).and_raise(e)
     Rpush.logger.should_receive(:error).with(e)
     store.release_connection
   end
@@ -43,7 +38,7 @@ describe Rpush::Daemon::Store::ActiveRecord do
   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)
-      store.deliverable_notifications(app)
+      store.deliverable_notifications(Rpush.config.batch_size)
     end
 
     it 'loads notifications in batches' do
@@ -51,46 +46,42 @@ describe Rpush::Daemon::Store::ActiveRecord do
       Rpush.config.push = false
       relation = double.as_null_object
       relation.should_receive(:limit).with(5000)
-      Rpush::Notification.stub(:ready_for_delivery => relation)
-      store.deliverable_notifications([app])
+      relation.stub(to_a: [])
+      store.stub(ready_for_delivery: relation)
+      store.deliverable_notifications(Rpush.config.batch_size)
     end
 
     it 'does not load notification in batches if in push mode' do
       Rpush.config.push = true
       relation = double.as_null_object
       relation.should_not_receive(:limit)
-      Rpush::Notification.stub(:ready_for_delivery => relation)
-      store.deliverable_notifications([app])
+      Rpush::Notification.stub(ready_for_delivery: relation)
+      store.deliverable_notifications(Rpush.config.batch_size)
     end
 
     it 'loads an undelivered notification without deliver_after set' do
-      notification.update_attributes!(:delivered => false, :deliver_after => nil)
-      store.deliverable_notifications([app]).should eq [notification]
+      notification.update_attributes!(delivered: false, deliver_after: nil)
+      store.deliverable_notifications(Rpush.config.batch_size).should eq [notification]
     end
 
     it 'loads an notification with a deliver_after time in the past' do
-      notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.ago)
-      store.deliverable_notifications([app]).should eq [notification]
+      notification.update_attributes!(delivered: false, deliver_after: 1.hour.ago)
+      store.deliverable_notifications(Rpush.config.batch_size).should eq [notification]
     end
 
     it 'does not load an notification with a deliver_after time in the future' do
-      notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.from_now)
-      store.deliverable_notifications([app]).should be_empty
+      notification.update_attributes!(delivered: false, deliver_after: 1.hour.from_now)
+      store.deliverable_notifications(Rpush.config.batch_size).should be_empty
     end
 
     it 'does not load a previously delivered notification' do
-      notification.update_attributes!(:delivered => true, :delivered_at => time)
-      store.deliverable_notifications([app]).should be_empty
+      notification.update_attributes!(delivered: true, delivered_at: time)
+      store.deliverable_notifications(Rpush.config.batch_size).should be_empty
     end
 
     it "does not enqueue a notification that has previously failed delivery" do
-      notification.update_attributes!(:delivered => false, :failed => true)
-      store.deliverable_notifications([app]).should be_empty
-    end
-
-    it 'does not load notifications for apps that are still processing the previous batch' do
-      notification
-      store.deliverable_notifications([]).should be_empty
+      notification.update_attributes!(delivered: false, failed: true)
+      store.deliverable_notifications(Rpush.config.batch_size).should be_empty
     end
   end
 
@@ -109,13 +100,13 @@ describe Rpush::Daemon::Store::ActiveRecord do
     end
 
     it 'saves the notification without validation' do
-      notification.should_receive(:save!).with(:validate => false)
+      notification.should_receive(:save!).with(validate: false)
       store.mark_retryable(notification, time)
     end
 
-    it 'does not save the notification if :persist => false' do
+    it 'does not save the notification if persist: false' do
       notification.should_not_receive(:save!)
-      store.mark_retryable(notification, time, :persist => false)
+      store.mark_retryable(notification, time, persist: false)
     end
   end
 
@@ -158,13 +149,13 @@ describe Rpush::Daemon::Store::ActiveRecord do
     end
 
     it 'saves the notification without validation' do
-      notification.should_receive(:save!).with(:validate => false)
+      notification.should_receive(:save!).with(validate: false)
       store.mark_delivered(notification, time)
     end
 
-    it 'does not save the notification if :persist => false' do
+    it 'does not save the notification if persist: false' do
       notification.should_not_receive(:save!)
-      store.mark_delivered(notification, time, :persist => false)
+      store.mark_delivered(notification, time, persist: false)
     end
   end
 
@@ -223,13 +214,13 @@ describe Rpush::Daemon::Store::ActiveRecord do
     end
 
     it 'saves the notification without validation' do
-      notification.should_receive(:save!).with(:validate => false)
+      notification.should_receive(:save!).with(validate: false)
       store.mark_failed(notification, nil, '', time)
     end
 
-    it 'does not save the notification if :persist => false' do
+    it 'does not save the notification if persist: false' do
       notification.should_not_receive(:save!)
-      store.mark_failed(notification, nil, '', time, :persist => false)
+      store.mark_failed(notification, nil, '', time, persist: false)
     end
   end
 
@@ -281,16 +272,16 @@ describe Rpush::Daemon::Store::ActiveRecord do
 
   describe 'create_apns_feedback' do
     it 'creates the Feedback record' do
-      Rpush::Apns::Feedback.should_receive(:create!).with(
-        :failed_at => time, :device_token => 'ab' * 32, :app => app)
+      Rpush::Client::ActiveRecord::Apns::Feedback.should_receive(:create!).with(
+        failed_at: time, device_token: 'ab' * 32, app: app)
       store.create_apns_feedback(time, 'ab' * 32, app)
     end
   end
 
   describe 'create_gcm_notification' do
-    let(:data) { { :data => true } }
-    let(:attributes) { { :device_token => 'ab' * 32 } }
-    let(:registration_ids) { ['123', '456'] }
+    let(:data) { { data: true } }
+    let(:attributes) { { device_token: 'ab' * 32 } }
+    let(:registration_ids) { %w(123 456) }
     let(:deliver_after) { time + 10.seconds }
     let(:args) { [attributes, data, registration_ids, deliver_after, app] }
 
@@ -321,9 +312,9 @@ describe Rpush::Daemon::Store::ActiveRecord do
   end
 
   describe 'create_adm_notification' do
-    let(:data) { { :data => true } }
-    let(:attributes) { {:app_id => app.id, :collapse_key => 'ckey', :delay_while_idle => true} }
-    let(:registration_ids) { ['123', '456'] }
+    let(:data) { { data: true } }
+    let(:attributes) { { app_id: app.id, collapse_key: 'ckey', delay_while_idle: true } }
+    let(:registration_ids) { %w(123 456) }
     let(:deliver_after) { time + 10.seconds }
     let(:args) { [attributes, data, registration_ids, deliver_after, app] }
 

data/spec/unit/daemon/tcp_connection_spec.rb

@@ -5,22 +5,22 @@ describe Rpush::Daemon::TcpConnection do
   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(:ssl_context) { double(:key= => nil, :cert= => nil, cert: x509_certificate) }
   let(:host) { 'gateway.push.apple.com' }
   let(:port) { '2195' }
-  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(: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) { Rpush::Daemon::TcpConnection.new(app, host, port) }
 
   before do
-    OpenSSL::SSL::SSLContext.stub(:new => ssl_context)
-    OpenSSL::PKey::RSA.stub(:new => rsa_key)
-    OpenSSL::X509::Certificate.stub(:new => x509_certificate)
-    TCPSocket.stub(:new => tcp_socket)
-    OpenSSL::SSL::SSLSocket.stub(:new => ssl_socket)
-    Rpush.stub(:logger => logger)
+    OpenSSL::SSL::SSLContext.stub(new: ssl_context)
+    OpenSSL::PKey::RSA.stub(new: rsa_key)
+    OpenSSL::X509::Certificate.stub(new: x509_certificate)
+    TCPSocket.stub(new: tcp_socket)
+    OpenSSL::SSL::SSLSocket.stub(new: ssl_socket)
+    Rpush.stub(logger: logger)
     connection.stub(:reflect)
   end
 
@@ -103,13 +103,13 @@ describe Rpush::Daemon::TcpConnection do
       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 Rpush::Apns::CertificateExpiredError }
+        Timecop.freeze(cert.not_after + 1.day) { connection.connect rescue Rpush::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(Rpush::Apns::CertificateExpiredError)
+          expect { connection.connect }.to raise_error(Rpush::CertificateExpiredError)
         end
       end
     end
@@ -158,26 +158,17 @@ describe Rpush::Daemon::TcpConnection do
 
     it 'reflects the connection has been lost' do
       connection.should_receive(:reflect).with(:tcp_connection_lost, app, kind_of(error_type))
-      begin
-        connection.write(nil)
-      rescue Rpush::Daemon::TcpConnectionError
-      end
+      expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
     end
 
     it "logs that the connection has been lost once only" do
       logger.should_receive(:error).with("[Connection 0] Lost connection to gateway.push.apple.com:2195 (#{error_type.name}), reconnecting...").once
-      begin
-        connection.write(nil)
-      rescue Rpush::Daemon::TcpConnectionError
-      end
+      expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
     end
 
     it "retries to make a connection 3 times" do
       connection.should_receive(:reconnect).exactly(3).times
-      begin
-        connection.write(nil)
-      rescue Rpush::Daemon::TcpConnectionError
-      end
+      expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
     end
 
     it "raises a TcpConnectionError after 3 attempts at reconnecting" do
@@ -188,10 +179,7 @@ describe Rpush::Daemon::TcpConnection do
 
     it "sleeps 1 second before retrying the connection" do
       connection.should_receive(:sleep).with(1)
-      begin
-        connection.write(nil)
-      rescue Rpush::Daemon::TcpConnectionError
-      end
+      expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
     end
   end
 
@@ -259,15 +247,15 @@ describe Rpush::Daemon::TcpConnection do
     before { connection.connect }
 
     it 'reconnects if the connection has been idle for more than the defined period' do
-      Rpush::Daemon::TcpConnection.stub(:idle_period => 60)
-      Time.stub(:now => Time.now + 61)
+      Rpush::Daemon::TcpConnection.stub(idle_period: 60)
+      Time.stub(now: Time.now + 61)
       connection.should_receive(:reconnect)
       connection.write('blah')
     end
 
     it 'resets the last write time' do
       now = Time.now
-      Time.stub(:now => now)
+      Time.stub(now: now)
       connection.write('blah')
       connection.last_write.should eq now
     end
@@ -278,8 +266,8 @@ describe Rpush::Daemon::TcpConnection do
     end
 
     it 'logs the the connection is idle' do
-      Rpush::Daemon::TcpConnection.stub(:idle_period => 60)
-      Time.stub(:now => Time.now + 61)
+      Rpush::Daemon::TcpConnection.stub(idle_period: 60)
+      Time.stub(now: Time.now + 61)
       Rpush.logger.should_receive(:info).with('[Connection 0] Idle period exceeded, reconnecting...')
       connection.write('blah')
     end