rpush 2.2.0 → 2.3.0.rc1

data/spec/functional/retry_spec.rb

@@ -7,7 +7,7 @@ describe 'Retries' do
   let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
 
   before do
-    Rpush::Daemon.initialize_store
+    Rpush::Daemon.common_init
 
     app.name = 'test'
     app.auth_key = 'abc123'

data/spec/functional/wpns_spec.rb

@@ -2,7 +2,8 @@ require 'functional_spec_helper'
 
 describe 'WPNs' do
   let(:app) { Rpush::Wpns::App.new }
-  let(:notification) { Rpush::Wpns::Notification.new }
+  let(:notification_with_data) { Rpush::Wpns::Notification.new }
+  let(:notification_with_alert) { Rpush::Wpns::Notification.new }
   let(:response) { double(Net::HTTPResponse, code: 200) }
   let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
 
@@ -10,29 +11,61 @@ describe 'WPNs' do
     app.name = 'test'
     app.save!
 
-    notification.app = app
-    notification.uri = 'http://sn1.notify.live.net/'
-    notification.alert = 'test'
-    notification.save!
+    notification_with_data.app = app
+    notification_with_data.uri = 'http://sn1.notify.live.net/'
+    notification_with_data.data = { title: "MyApp", body: "test", param: "new_user" }
+    notification_with_data.save!
+
+    notification_with_alert.app = app
+    notification_with_alert.uri = 'http://sn1.notify.live.net/'
+    notification_with_alert.alert = "Hello world!"
+    notification_with_alert.save!
 
     Net::HTTP::Persistent.stub(new: http)
   end
 
-  it 'delivers a notification successfully' do
+  it 'delivers a notification with data successfully' do
     response.stub(to_hash: { 'x-notificationstatus' => ['Received'] })
 
     expect do
       Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
+      notification_with_data.reload
+    end.to change(notification_with_data, :delivered).to(true)
   end
 
-  it 'fails to deliver a notification successfully' do
+  it 'fails to deliver a notification with data successfully' do
     response.stub(code: 400)
 
     expect do
       Rpush.push
-      notification.reload
-    end.to_not change(notification, :delivered).to(true)
+      notification_with_data.reload
+    end.to_not change(notification_with_data, :delivered).to(true)
+  end
+
+  it 'delivers a notification with an alert successfully' do
+    response.stub(to_hash: { 'x-notificationstatus' => ['Received'] })
+
+    expect do
+      Rpush.push
+      notification_with_alert.reload
+    end.to change(notification_with_alert, :delivered).to(true)
+  end
+
+  it 'fails to deliver a notification with an alert successfully' do
+    response.stub(code: 400)
+
+    expect do
+      Rpush.push
+      notification_with_alert.reload
+    end.to_not change(notification_with_alert, :delivered).to(true)
+  end
+
+  it 'retries notification that fail due to a SocketError' do
+    expect(http).to receive(:request).and_raise(SocketError.new).twice
+    expect(notification_with_data.deliver_after).to be_nil
+    expect do
+      Rpush.push
+      notification_with_data.reload
+    end.to change(notification_with_data, :deliver_after).to(kind_of(Time))
   end
 end

data/spec/spec_helper.rb

@@ -46,6 +46,8 @@ def after_example_cleanup
     Rpush.config.set_defaults if Rpush.config.is_a?(Rpush::Configuration)
     Rpush.config.client = RPUSH_CLIENT
   end
+  Rpush.plugins.values.each(&:unload)
+  Rpush.instance_variable_set('@plugins', {})
 end
 
 RSpec.configure do |config|

data/spec/unit/apns_feedback_spec.rb

@@ -8,8 +8,8 @@ describe Rpush, 'apns_feedback' do
     Rpush::Daemon::Apns::FeedbackReceiver.stub(new: receiver)
   end
 
-  it 'initializes the store' do
-    Rpush::Daemon.should_receive(:initialize_store)
+  it 'initializes the daemon' do
+    Rpush::Daemon.should_receive(:common_init)
     Rpush.apns_feedback
   end
 

data/spec/unit/client/active_record/apns/app_spec.rb

@@ -4,7 +4,7 @@ describe Rpush::Client::ActiveRecord::App do
   it 'does not validate an app with an invalid certificate' do
     app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: 'foo')
     app.valid?
-    app.errors[:certificate].should eq ['Certificate value must contain a certificate and a private key.']
+    app.errors[:certificate].should eq ['value must contain a certificate and a private key.']
   end
 
   it 'validates a certificate without a password' do
@@ -24,6 +24,6 @@ describe Rpush::Client::ActiveRecord::App do
     app = Rpush::Client::ActiveRecord::Apns::App.new name: 'test', environment: 'development',
                                                      certificate: TEST_CERT_WITH_PASSWORD, password: 'incorrect'
     app.valid?
-    app.errors[:certificate].should eq ["Certificate value must contain a certificate and a private key."]
+    app.errors[:certificate].should eq ['value must contain a certificate and a private key.']
   end
 end

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

@@ -76,7 +76,7 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, "as_json" do
   end
 
   it "should not include the sound key if the sound is not present" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(sound: false)
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(sound: nil)
     notification.as_json["aps"].key?("sound").should be_false
   end
 
@@ -92,7 +92,6 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, "as_json" do
     notification.data = { omg: { ilike: :hashes } }
     notification.as_json["omg"]["ilike"].should eq "hashes"
   end
-
 end
 
 describe Rpush::Client::ActiveRecord::Apns::Notification, 'MDM' do

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

@@ -13,9 +13,15 @@ describe Rpush::Client::ActiveRecord::Wpns::Notification do
     notification.errors[:uri].include?("is invalid").should be_true
   end
 
-  it "should be invalid if there's no message" do
-    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(alert: "")
+  it "should be invalid if there's no data" do
+    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(data: {})
     notification.valid?
-    notification.errors[:alert].include?("can't be blank").should be_true
+    notification.errors[:data].include?("can't be blank").should be_true
+  end
+
+  it "should be invalid if there's no alert" do
+    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(alert: nil)
+    notification.valid?
+    notification.errors[:data].include?("can't be blank").should be_true
   end
 end

data/spec/unit/configuration_spec.rb

@@ -39,6 +39,7 @@ describe Rpush::Configuration do
   end
 
   it 'delegate redis_options to Modis' do
+    Rpush.config.client = :redis
     Rpush.config.redis_options = { hi: :mom }
     Modis.redis_options.should eq(hi: :mom)
   end

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

@@ -87,7 +87,6 @@ describe Rpush::Daemon::Adm::Delivery do
       delivery.should_receive(:reflect).with(:adm_failed_to_recipient, notification, '1', 'Unregistered')
       expect { perform }.to raise_error
     end
-
   end
 
   describe 'a 401 (Unauthorized) response' do

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

@@ -2,7 +2,6 @@ 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(:poll) { 60 }

data/spec/unit/daemon/app_runner_spec.rb

@@ -34,7 +34,7 @@ end
 describe Rpush::Daemon::AppRunner, 'enqueue' do
   let(:app) { double(id: 1, name: 'Test', connections: 1) }
   let(:notification) { double(app_id: 1) }
-  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start: nil, stop: nil) }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start_dispatchers: nil, start_loops: nil, stop: nil) }
   let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
@@ -62,7 +62,7 @@ end
 
 describe Rpush::Daemon::AppRunner, 'start_app' do
   let(:app) { double(id: 1, name: 'test', connections: 1) }
-  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start: nil, stop: nil) }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start_dispatchers: nil, stop: nil) }
   let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
@@ -71,7 +71,7 @@ describe Rpush::Daemon::AppRunner, 'start_app' do
 
   it 'logs an error if the runner could not be started' do
     Rpush::Daemon::AppRunner.should_receive(:new).with(app).and_return(runner)
-    runner.stub(:start).and_raise(StandardError)
+    runner.stub(:start_dispatchers).and_raise(StandardError)
     Rpush.logger.should_receive(:error)
     Rpush::Daemon::AppRunner.start_app(app)
   end
@@ -80,7 +80,8 @@ end
 describe Rpush::Daemon::AppRunner, 'debug' do
   let(:app) do
     double(Rpush::AppRunnerSpecService::App, id: 1, name: 'test', connections: 1,
-      environment: 'development', certificate: TEST_CERT, service_name: 'app_runner_spec_service')
+                                             environment: 'development', certificate: TEST_CERT,
+                                             service_name: 'app_runner_spec_service')
   end
   let(:logger) { double(Rpush::Logger, info: nil) }
   let(:store) { double(all_apps: [app], release_connection: nil) }
@@ -102,7 +103,8 @@ end
 describe Rpush::Daemon::AppRunner do
   let(:app) do
     double(Rpush::AppRunnerSpecService::App, environment: :sandbox,
-      connections: 1, service_name: 'app_runner_spec_service', name: 'test')
+                                             connections: 1, service_name: 'app_runner_spec_service',
+                                             name: 'test')
   end
   let(:runner) { Rpush::Daemon::AppRunner.new(app) }
   let(:logger) { double(Rpush::Logger, info: nil) }
@@ -122,18 +124,18 @@ describe Rpush::Daemon::AppRunner do
   describe 'start' do
     it 'starts a delivery dispatcher for each connection' do
       app.stub(connections: 2)
-      runner.start
+      runner.start_dispatchers
       runner.num_dispatcher_loops.should eq 2
     end
 
     it 'starts the dispatcher loop' do
       dispatcher_loop.should_receive(:start)
-      runner.start
+      runner.start_dispatchers
     end
 
     it 'starts the loops' do
       service_loop.should_receive(:start)
-      runner.start
+      runner.start_loops
     end
   end
 
@@ -169,7 +171,10 @@ describe Rpush::Daemon::AppRunner do
   end
 
   describe 'stop' do
-    before { runner.start }
+    before do
+      runner.start_dispatchers
+      runner.start_loops
+    end
 
     it 'stops the delivery dispatchers' do
       dispatcher_loop.should_receive(:stop)

data/spec/unit/daemon/delivery_spec.rb

@@ -1,7 +1,6 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Delivery do
-
   class DeliverySpecDelivery < Rpush::Daemon::Delivery
     def initialize(batch)
       @batch = batch

data/spec/unit/daemon/dispatcher/tcp_spec.rb

@@ -16,12 +16,6 @@ describe Rpush::Daemon::Dispatcher::Tcp do
   before { Rpush::Daemon::TcpConnection.stub(new: connection) }
 
   describe 'dispatch' do
-    it 'lazily connects the socket' do
-      Rpush::Daemon::TcpConnection.should_receive(:new).with(app, host, port).and_return(connection)
-      connection.should_receive(:connect)
-      dispatcher.dispatch(queue_payload)
-    end
-
     it 'delivers the notification' do
       delivery_class.should_receive(:new).with(app, connection, notification, batch).and_return(delivery)
       delivery.should_receive(:perform)
@@ -31,7 +25,6 @@ describe Rpush::Daemon::Dispatcher::Tcp do
 
   describe 'cleanup' do
     it 'closes the connection' do
-      dispatcher.dispatch(queue_payload) # lazily initialize connection
       connection.should_receive(:close)
       dispatcher.cleanup
     end

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

@@ -291,7 +291,7 @@ describe Rpush::Daemon::Gcm::Delivery do
     it 'logs a warning that the notification has been re-queued.' do
       notification.retries = 3
       notification.deliver_after = now + 2**3
-      Rpush.logger.should_receive(:warn).with("[MyApp] GCM responded with an Internal Error. Notification #{notification.id} will be retried after #{(now + 2**3).strftime("%Y-%m-%d %H:%M:%S")} (retry 3).")
+      Rpush.logger.should_receive(:warn).with("[MyApp] GCM responded with an Internal Error. Notification #{notification.id} will be retried after #{(now + 2**3).strftime('%Y-%m-%d %H:%M:%S')} (retry 3).")
       perform
     end
 

data/spec/unit/daemon/signal_handler_spec.rb

@@ -44,6 +44,7 @@ describe Rpush::Daemon::SignalHandler do
     before do
       Rpush::Daemon::Synchronizer.stub(:sync)
       Rpush::Daemon::Feeder.stub(:wakeup)
+      Rpush::Daemon.stub(store: double(reopen_log: nil))
     end
 
     it 'syncs' do
@@ -73,7 +74,10 @@ describe Rpush::Daemon::SignalHandler do
   describe 'error handing' do
     let(:error) { StandardError.new('test') }
 
-    before { Rpush.stub(logger: double(error: nil, info: nil)) }
+    before do
+      Rpush.stub(logger: double(error: nil, info: nil, reopen: nil))
+      Rpush::Daemon.stub(store: double(reopen_log: nil))
+    end
 
     it 'logs errors received when handling a signal' do
       Rpush::Daemon::Synchronizer.stub(:sync).and_raise(error)

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

@@ -6,7 +6,7 @@ describe Rpush::Daemon::Store::ActiveRecord do
   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) }
+  let(:logger) { double(Rpush::Logger, error: nil, internal_logger: nil) }
 
   before do
     Rpush.stub(logger: logger)

data/spec/unit/daemon/tcp_connection_spec.rb

@@ -72,12 +72,12 @@ describe Rpush::Daemon::TcpConnection do
     end
 
     it "sets the socket option TCP_NODELAY" do
-      tcp_socket.should_receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      tcp_socket.should_receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
       connection.connect
     end
 
     it "sets the socket option SO_KEEPALIVE" do
-      tcp_socket.should_receive(:setsockopt).with(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1)
+      tcp_socket.should_receive(:setsockopt).with(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
       connection.connect
     end
 
@@ -122,12 +122,12 @@ describe Rpush::Daemon::TcpConnection do
 
       it 'reflects that the certificate has been revoked' do
         connection.should_receive(:reflect).with(:ssl_certificate_revoked, app, cert_revoked_error)
-        expect { connection.connect }.to raise_error(cert_revoked_error)
+        expect { connection.connect }.to raise_error(Rpush::Daemon::TcpConnectionError, 'OpenSSL::SSL::SSLError, certificate revoked')
       end
 
       it 'logs that the certificate has been revoked' do
         logger.should_receive(:warn).with('[Connection 0] Certificate has been revoked.')
-        expect { connection.connect }.to raise_error(cert_revoked_error)
+        expect { connection.connect }.to raise_error(Rpush::Daemon::TcpConnectionError, 'OpenSSL::SSL::SSLError, certificate revoked')
       end
     end
   end
@@ -170,16 +170,16 @@ describe Rpush::Daemon::TcpConnection do
     before do
       connection.stub(:sleep)
       connection.connect
-      ssl_socket.stub(:write).and_raise(error_type)
+      ssl_socket.stub(:write).and_raise(error)
     end
 
     it 'reflects the connection has been lost' do
-      connection.should_receive(:reflect).with(:tcp_connection_lost, app, kind_of(error_type))
+      connection.should_receive(:reflect).with(:tcp_connection_lost, app, kind_of(error.class))
       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
+      logger.should_receive(:error).with("[Connection 0] Lost connection to gateway.push.apple.com:2195 (#{error.class.name}, #{error.message}), reconnecting...").once
       expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
     end
 
@@ -191,7 +191,7 @@ describe Rpush::Daemon::TcpConnection do
     it "raises a TcpConnectionError after 3 attempts at reconnecting" do
       expect do
         connection.write(nil)
-      end.to raise_error(Rpush::Daemon::TcpConnectionError, "Connection 0 tried 3 times to reconnect but failed (#{error_type.name}).")
+      end.to raise_error(Rpush::Daemon::TcpConnectionError, "Connection 0 tried 3 times to reconnect but failed (#{error.class.name}, #{error.message}).")
     end
 
     it "sleeps 1 second before retrying the connection" do
@@ -203,32 +203,32 @@ describe Rpush::Daemon::TcpConnection do
   describe "when write raises an Errno::EPIPE" do
     it_should_behave_like "when the write fails"
 
-    def error_type
-      Errno::EPIPE
+    def error
+      Errno::EPIPE.new('an message')
     end
   end
 
   describe "when write raises an Errno::ETIMEDOUT" do
     it_should_behave_like "when the write fails"
 
-    def error_type
-      Errno::ETIMEDOUT
+    def error
+      Errno::ETIMEDOUT.new('an message')
     end
   end
 
   describe "when write raises an OpenSSL::SSL::SSLError" do
     it_should_behave_like "when the write fails"
 
-    def error_type
-      OpenSSL::SSL::SSLError
+    def error
+      OpenSSL::SSL::SSLError.new('an message')
     end
   end
 
   describe "when write raises an IOError" do
     it_should_behave_like "when the write fails"
 
-    def error_type
-      IOError
+    def error
+      IOError.new('an message')
     end
   end
 
@@ -270,11 +270,11 @@ describe Rpush::Daemon::TcpConnection do
       connection.write('blah')
     end
 
-    it 'resets the last write time' do
+    it 'resets the last touch time' do
       now = Time.now
       Time.stub(now: now)
       connection.write('blah')
-      connection.last_write.should eq now
+      connection.last_touch.should eq now
     end
 
     it 'does not reconnect if the connection has not been idle for more than the defined period' do