rpush 1.0.0-java → 2.0.0-java

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_id: app.id)
       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

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

@@ -1,37 +1,41 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Wpns::Delivery do
-  let(:app) { Rpush::Wpns::App.new(:name => "MyApp") }
-  let(:notification) { Rpush::Wpns::Notification.create!(:app => app,:alert => "test",
-                                                         :uri => "http://some.example/",
-                                                         :deliver_after => Time.now) }
-  let(:logger) { double(:error => nil, :info => nil, :warn => nil) }
-  let(:response) { double(:code => 200, :header => {}) }
-  let(:http) { double(:shutdown => nil, :request => response) }
+  let(:app) { Rpush::Wpns::App.create!(name: "MyApp") }
+  let(:notification) { Rpush::Wpns::Notification.create!(app: app, alert: "test", uri: "http://some.example/", deliver_after: Time.now) }
+  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(:batch) { double(mark_failed: nil, mark_delivered: nil, mark_retryable: nil, notification_processed: nil) }
   let(:delivery) { Rpush::Daemon::Wpns::Delivery.new(app, http, notification, batch) }
-  let(:store) { double(:create_wpns_notification => double(:id => 2)) }
+  let(:store) { double(create_wpns_notification: double(id: 2)) }
 
   def perform
     delivery.perform
   end
 
+  def perform_with_rescue
+    expect { perform }.to raise_error
+  end
+
   before do
-    delivery.stub(:reflect => nil)
-    Rpush::Daemon.stub(:store => store)
-    Time.stub(:now => now)
-    Rpush.stub(:logger => logger)
+    delivery.stub(reflect: nil)
+    Rpush::Daemon.stub(store: store)
+    Time.stub(now: now)
+    Rpush.stub(logger: logger)
   end
 
   shared_examples_for "an notification with some delivery faliures" do
     let(:new_notification) { Rpush::Wpns::Notification.where('id != ?', notification.id).first }
 
-    before { response.stub(:body => JSON.dump(body)) }
+    before { response.stub(body: JSON.dump(body)) }
 
     it "marks the original notification falied" do
-      delivery.should_receive(:mark_failed).with(notification, nil, error_description)
-      perform rescue Rpush::DeliveryError
+      delivery.should_receive(:mark_failed) do |error|
+        error.message.should =~ error_description
+      end
+      perform_with_rescue
     end
 
     it "raises a DeliveryError" do
@@ -41,99 +45,102 @@ describe Rpush::Daemon::Wpns::Delivery do
 
   describe "an 200 response" do
     before do
-      response.stub(:code => 200)
+      response.stub(code: 200)
     end
 
     it "marks the notification as delivered if delivered successfully to all devices" do
-      response.stub(:body => JSON.dump({ "failure" => 0 }))
-      response.stub(:to_hash => {"x-notificationstatus" => ["Received"]})
+      response.stub(body: JSON.dump("failure" => 0))
+      response.stub(to_hash: { "x-notificationstatus" => ["Received"] })
       batch.should_receive(:mark_delivered).with(notification)
       perform
     end
 
     it "retries the notification when the queue is full" do
-      response.stub(:body => JSON.dump({ "failure" => 0 }))
-      response.stub(:to_hash => { "x-notificationstatus" => ["QueueFull"] })
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60*10))
+      response.stub(body: JSON.dump("failure" => 0))
+      response.stub(to_hash: { "x-notificationstatus" => ["QueueFull"] })
+      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 10))
       perform
     end
 
     it "marks the notification as failed if the notification is suppressed" do
-      response.stub(:body => JSON.dump({ "faliure" => 0 }))
-      response.stub(:to_hash => { "x-notificationstatus" => ["Suppressed"] })
-      delivery.should_receive(:mark_failed).with(200, "Notification was received but suppressed by the service.")
-      perform rescue Rpush::DeliveryError
+      response.stub(body: JSON.dump("faliure" => 0))
+      response.stub(to_hash: { "x-notificationstatus" => ["Suppressed"] })
+      error = Rpush::DeliveryError.new(200, notification.id, 'Notification was received but suppressed by the service.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 400 response" do
-    before { response.stub(:code => 400) }
+    before { response.stub(code: 400) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(400,
-        "Bad XML or malformed notification URI.")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(400, notification.id, 'Bad XML or malformed notification URI.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 401 response" do
-    before { response.stub(:code => 401) }
+    before { response.stub(code: 401) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(401,
-        "Unauthorized to send a notification to this app.")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(401, notification.id, 'Unauthorized to send a notification to this app.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 404 response" do
-    before { response.stub(:code => 404) }
+    before { response.stub(code: 404) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(404, "Not Found")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(404, notification.id, 'Not Found')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 405 response" do
-    before { response.stub(:code => 405) }
+    before { response.stub(code: 405) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(405, "Method Not Allowed")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(405, notification.id, 'Method Not Allowed')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 406 response" do
-    before { response.stub(:code => 406) }
+    before { response.stub(code: 406) }
 
     it "retries the notification" do
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60*60))
+      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 60))
       perform
     end
 
     it "logs a warning that the notification will be retried" do
       notification.retries = 1
       notification.deliver_after = now + 2
-      logger.should_receive(:warn).with("[MyApp] Per-day throttling limit reached. Notification 1 will be retried after 2012-10-14 00:00:02 (retry 1).")
+      logger.should_receive(:warn).with("[MyApp] Per-day throttling limit reached. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
       perform
     end
   end
 
   describe "an 412 response" do
-    before { response.stub(:code => 412) }
+    before { response.stub(code: 412) }
 
     it "retries the notification" do
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60*60))
+      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 60))
       perform
     end
 
     it "logs a warning that the notification will be retried" do
       notification.retries = 1
       notification.deliver_after = now + 2
-      logger.should_receive(:warn).with("[MyApp] Device unreachable. Notification 1 will be retried after 2012-10-14 00:00:02 (retry 1).")
+      logger.should_receive(:warn).with("[MyApp] Device unreachable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
       perform
     end
   end
 
   describe "an 503 response" do
-    before { response.stub(:code => 503) }
+    before { response.stub(code: 503) }
 
     it "retries the notification exponentially" do
       delivery.should_receive(:mark_retryable_exponential).with(notification)
@@ -149,11 +156,12 @@ describe Rpush::Daemon::Wpns::Delivery do
   end
 
   describe 'an un-handled response' do
-    before { response.stub(:code => 418) }
+    before { response.stub(code: 418) }
 
     it 'marks the notification as failed' do
-      delivery.should_receive(:mark_failed).with(418, "I'm a Teapot")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 end