rpush 1.0.0 → 2.0.0.beta1

data/lib/rpush/logger.rb

@@ -1,19 +1,15 @@
 module Rpush
   class Logger
-    def initialize(options)
-      @options = options
-
-      begin
-        log_dir = File.join(Rails.root, 'log')
-        FileUtils.mkdir_p(log_dir)
-        log = File.open(File.join(log_dir, 'rpush.log'), 'a')
-        log.sync = true
-        setup_logger(log)
-      rescue Errno::ENOENT, Errno::EPERM => e
-        @logger = nil
-        error(e)
-        error('Logging disabled.')
-      end
+    def initialize
+      log_dir = File.join(Rpush.config.log_dir, 'log')
+      FileUtils.mkdir_p(log_dir)
+      log = File.open(File.join(log_dir, 'rpush.log'), 'a')
+      log.sync = true
+      setup_logger(log)
+    rescue Errno::ENOENT, Errno::EPERM => e
+      @logger = nil
+      error(e)
+      error('Logging disabled.')
     end
 
     def info(msg)
@@ -53,7 +49,7 @@ module Rpush
 
       if io == STDERR
         io.puts formatted_msg
-      elsif @options[:foreground]
+      elsif Rpush.config.foreground
         io.puts formatted_msg
       end
 

data/lib/rpush/push.rb

@@ -10,7 +10,6 @@ module Rpush
     Rpush::Daemon.initialize_store
     Rpush::Daemon::AppRunner.sync
     Rpush::Daemon::Feeder.start
-    Rpush::Daemon::AppRunner.wait
     Rpush::Daemon::AppRunner.stop
   end
 end

data/lib/rpush/reflection.rb

@@ -12,16 +12,12 @@ module Rpush
 
     REFLECTIONS = [
       :apns_feedback, :notification_enqueued, :notification_delivered,
-      :notification_failed, :notification_will_retry, :apns_connection_lost,
-      :gcm_delivered_to_recipient, :gcm_failed_to_recipient, :gcm_canonical_id,
-      :gcm_invalid_registration_id, :error, :apns_certificate_will_expire,
-      :adm_canonical_id, :tcp_connection_lost, :ssl_certificate_will_expire
+      :notification_failed, :notification_will_retry, :gcm_delivered_to_recipient,
+      :gcm_failed_to_recipient, :gcm_canonical_id, :gcm_invalid_registration_id,
+      :error, :adm_canonical_id, :tcp_connection_lost, :ssl_certificate_will_expire
     ]
 
-    DEPRECATIONS = {
-      :apns_connection_lost => [:tcp_connection_lost, '4.1'],
-      :apns_certificate_will_expire => [:ssl_certificate_will_expire, '4.1']
-    }
+    DEPRECATIONS = {}
 
     REFLECTIONS.each do |reflection|
       class_eval(<<-RUBY, __FILE__, __LINE__)
@@ -36,7 +32,7 @@ module Rpush
       reflection = reflection.to_sym
 
       unless REFLECTIONS.include?(reflection)
-        raise NoSuchReflectionError, reflection
+        fail NoSuchReflectionError, reflection
       end
 
       if DEPRECATIONS.key?(reflection)
@@ -44,9 +40,7 @@ module Rpush
         Rpush::Deprecation.warn("#{reflection} is deprecated and will be removed in version #{removal_version}. Use #{replacement} instead.")
       end
 
-      if reflections[reflection]
-        reflections[reflection].call(*args)
-      end
+      reflections[reflection].call(*args) if reflections[reflection]
     end
 
     private

data/lib/rpush/version.rb

@@ -1,3 +1,3 @@
 module Rpush
-  VERSION = '1.0.0'
+  VERSION = '2.0.0.beta1'
 end

data/lib/tasks/quality.rake

@@ -0,0 +1,34 @@
+begin
+  require 'cane/rake_task'
+
+  desc 'Run cane to check quality metrics'
+  Cane::RakeTask.new(:cane_quality) do |cane|
+    cane.add_threshold 'coverage/covered_percent', :>=, 95
+    cane.no_style = false
+    cane.style_measure = 1000
+    cane.no_doc = true
+    cane.abc_max = 20
+  end
+
+  namespace :spec do
+    task :cane => ['spec', 'cane_quality']
+  end
+rescue LoadError
+  warn "cane not available."
+
+  namespace :spec do
+    task :cane => ['spec']
+  end
+end
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  warn 'rubocop not available.'
+  task :rubocop => ['spec']
+end
+
+namespace :spec do
+  task quality: ['cane', 'rubocop']
+end

data/spec/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_from: ../.rubocop.yml
+
+RescueModifier:
+  Enabled: false

data/spec/functional/adm_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'ADM' do
   let(:app) { Rpush::Adm::App.new }
@@ -17,14 +17,11 @@ describe 'ADM' do
     notification.data = { message: 'test' }
     notification.save!
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
-
     Net::HTTP::Persistent.stub(new: http)
   end
 
   it 'delivers a notification successfully' do
-    response.stub(body: JSON.dump({registrationID: notification.registration_ids.first.to_s}))
+    response.stub(body: JSON.dump(registrationID: notification.registration_ids.first.to_s))
 
     expect do
       Rpush.push
@@ -33,7 +30,7 @@ describe 'ADM' do
   end
 
   it 'fails to deliver a notification successfully' do
-    response.stub(code: 400, body: JSON.dump({reason: 'error', registrationID: notification.registration_ids.first.to_s}))
+    response.stub(code: 400, body: JSON.dump(reason: 'error', registrationID: notification.registration_ids.first.to_s))
 
     expect do
       Rpush.push

data/spec/functional/apns_spec.rb

@@ -1,58 +1,152 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'APNs' do
-  let(:app) { Rpush::Apns::App.new }
-  let(:notification) { Rpush::Apns::Notification.new }
+  let(:timeout) { 10 }
+  let(:app) { create_app }
+  let!(:notification) { create_notification }
   let(:tcp_socket) { double(TCPSocket, setsockopt: nil, close: nil) }
-  let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil,
-    write: nil, flush: nil, read: nil, close: nil) }
+  let(:ssl_socket) do double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil,
+                                                      write: nil, flush: nil, read: nil, close: nil)
+  end
+  let(:io_double) { double(select: nil) }
 
   before do
+    stub_tcp_connection
+  end
+
+  def create_app
+    app = Rpush::Apns::App.new
     app.certificate = TEST_CERT
     app.name = 'test'
     app.environment = 'sandbox'
     app.save!
+    app
+  end
 
+  def create_notification
+    notification = Rpush::Apns::Notification.new
     notification.app = app
     notification.alert = 'test'
     notification.device_token = 'a' * 64
     notification.save!
+    notification
+  end
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
+  def stub_tcp_connection
+    Rpush::Daemon::TcpConnection.any_instance.stub(connect_socket: [tcp_socket, ssl_socket])
+    Rpush::Daemon::TcpConnection.any_instance.stub(setup_ssl_context: double.as_null_object)
+    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
+  end
 
-    stub_tcp_connection
+  def wait_for_notification_to_deliver(notification)
+    Timeout.timeout(timeout) do
+      until notification.delivered
+        sleep 0.1
+        notification.reload
+      end
+    end
   end
 
-  def stub_tcp_connection
-    TCPSocket.stub(:new => tcp_socket)
-    OpenSSL::SSL::SSLSocket.stub(:new => ssl_socket)
-    IO.stub(:select => nil)
+  def wait_for_notification_to_fail(notification)
+    Timeout.timeout(timeout) do
+      while notification.delivered
+        sleep 0.1
+        notification.reload
+      end
+    end
   end
 
-  it 'delivers a notification successfully' do
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
+  def wait_for_notification_to_retry(notification)
+    Timeout.timeout(timeout) do
+      until !notification.delivered && !notification.failed && !notification.deliver_after.nil?
+        sleep 0.1
+        notification.reload
+      end
+    end
+  end
+
+  def fail_notification(notification)
+    ssl_socket.stub(read: [8, 4, notification.id].pack('ccN'))
+    enable_io_select
   end
 
-  it 'fails to deliver a notification successfully' do
-    IO.stub(:select => true)
-    ssl_socket.stub(:read => [8, 4, 69].pack('ccN'))
+  def enable_io_select
+    called = false
+    io_double.stub(:select) do
+      if called
+        nil
+      else
+        called = true
+      end
+    end
+  end
 
+  it 'delivers a notification successfully' do
     expect do
       Rpush.push
       notification.reload
-    end.to_not change(notification, :delivered).to(true)
+    end.to change(notification, :delivered).to(true)
   end
 
   it 'receives feedback' do
     tuple = "N\xE3\x84\r\x00 \x83OxfU\xEB\x9F\x84aJ\x05\xAD}\x00\xAF1\xE5\xCF\xE9:\xC3\xEA\a\x8F\x1D\xA4M*N\xB0\xCE\x17"
     allow(ssl_socket).to receive(:read).and_return(tuple, nil)
+    Rpush.apns_feedback
+    feedback = Rpush::Apns::Feedback.all
+    feedback.should_not be_empty
+  end
 
-    expect do
-      Rpush.apns_feedback
-    end.to change(Rpush::Apns::Feedback, :count).to(1)
+  describe 'delivery failures' do
+    before { Rpush.embed }
+    after { Timeout.timeout(timeout) { Rpush.shutdown } }
+
+    it 'fails to deliver a notification' do
+      wait_for_notification_to_deliver(notification)
+      fail_notification(notification)
+      wait_for_notification_to_fail(notification)
+    end
+
+    describe 'with multiple notifications' do
+      let(:notification1) { create_notification }
+      let(:notification2) { create_notification }
+      let(:notification3) { create_notification }
+      let(:notification4) { create_notification }
+      let!(:notifications) { [notification1, notification2, notification3, notification4] }
+
+      it 'marks the correct notification as failed' do
+        notifications.each { |n| wait_for_notification_to_deliver(n) }
+        fail_notification(notification2)
+        wait_for_notification_to_fail(notification2)
+      end
+
+      it 'does not mark prior notifications as failed' do
+        notifications.each { |n| wait_for_notification_to_deliver(n) }
+        fail_notification(notification2)
+        sleep 1
+        notification1.reload
+        notification1.delivered.should be_true
+      end
+
+      it 'marks notifications following the failed one as retryable' # do
+      #   # Such hacks. Set the poll frequency high enough that we'll only ever feed once.
+      #   Rpush.config.push_poll = 1_000_000
+      #
+      #   notifications.each { |n| wait_for_notification_to_deliver(n) }
+      #   fail_notification(notification2)
+      #
+      #   [notification3, notification4].each do |n|
+      #     wait_for_notification_to_retry(n)
+      #   end
+      # end
+
+      describe 'without an error response' do
+        it 'marks all notifications as failed' do
+          notifications.each { |n| wait_for_notification_to_deliver(n) }
+          ssl_socket.stub(read: nil)
+          enable_io_select
+          notifications.each { |n| wait_for_notification_to_fail(n) }
+        end
+      end
+    end
   end
 end

data/spec/functional/embed_spec.rb

@@ -1,11 +1,14 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'embedding' do
+  let(:timeout) { 10 }
   let(:app) { Rpush::Apns::App.new }
   let(:notification) { Rpush::Apns::Notification.new }
   let(:tcp_socket) { double(TCPSocket, setsockopt: nil, close: nil) }
-  let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil,
-    write: nil, flush: nil, read: nil, close: nil) }
+  let(:ssl_socket) do double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil,
+                                                      write: nil, flush: nil, read: nil, close: nil)
+  end
+  let(:io_double) { double(select: nil) }
 
   before do
     app.certificate = TEST_CERT
@@ -18,32 +21,31 @@ describe 'embedding' do
     notification.device_token = 'a' * 64
     notification.save!
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
-
     stub_tcp_connection
   end
 
   def stub_tcp_connection
-    TCPSocket.stub(:new => tcp_socket)
-    OpenSSL::SSL::SSLSocket.stub(:new => ssl_socket)
-    IO.stub(:select => nil)
-    Rpush::Daemon::Apns::FeedbackReceiver.stub(:new => double.as_null_object)
+    Rpush::Daemon::TcpConnection.any_instance.stub(connect_socket: [tcp_socket, ssl_socket])
+    Rpush::Daemon::TcpConnection.any_instance.stub(setup_ssl_context: double.as_null_object)
+    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
+    Rpush::Daemon::Apns::FeedbackReceiver.stub(new: double.as_null_object)
+  end
+
+  before do
+    Rpush.config.push_poll = 5
+    Rpush.embed
   end
 
   it 'delivers a notification successfully' do
     expect do
-      ::ActiveRecord::Base.clear_all_connections!
-
-      pid = fork do
-        Rpush.embed
-        sleep 0.5
-        Rpush.shutdown
-        Kernel.at_exit { exit! } # Don't run any at_exit hooks.
+      Timeout.timeout(timeout) do
+        until notification.delivered
+          notification.reload
+          sleep 0.1
+        end
       end
-
-      Process.waitpid(pid)
-      notification.reload
     end.to change(notification, :delivered).to(true)
   end
+
+  after { Timeout.timeout(timeout) { Rpush.shutdown } }
 end

data/spec/functional/gcm_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'GCM' do
   let(:app) { Rpush::Gcm::App.new }
@@ -11,19 +11,16 @@ describe 'GCM' do
     app.auth_key = 'abc123'
     app.save!
 
-    notification.app = app
+    notification.app_id = app.id
     notification.registration_ids = ['foo']
     notification.data = { message: 'test' }
     notification.save!
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
-
     Net::HTTP::Persistent.stub(new: http)
   end
 
   it 'delivers a notification successfully' do
-    response.stub(body: JSON.dump({results: [{message_id: notification.registration_ids.first.to_s}]}))
+    response.stub(body: JSON.dump(results: [{ message_id: notification.registration_ids.first.to_s }]))
 
     expect do
       Rpush.push
@@ -32,7 +29,7 @@ describe 'GCM' do
   end
 
   it 'fails to deliver a notification successfully' do
-    response.stub(body: JSON.dump({results: [{error: 'Err'}]}))
+    response.stub(body: JSON.dump(results: [{ error: 'Err' }]))
 
     expect do
       Rpush.push

data/spec/functional/new_app_spec.rb

@@ -0,0 +1,61 @@
+require 'functional_spec_helper'
+
+describe 'New app loading' do
+  let(:timeout) { 10 }
+  let(:app) { create_app }
+  let(:tcp_socket) { double(TCPSocket, setsockopt: nil, close: nil) }
+  let(:ssl_socket) do double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil,
+                                                      write: nil, flush: nil, read: nil, close: nil)
+  end
+  let(:io_double) { double(select: nil) }
+
+  before do
+    stub_tcp_connection
+  end
+
+  def create_app
+    app = Rpush::Apns::App.new
+    app.certificate = TEST_CERT
+    app.name = 'test'
+    app.environment = 'sandbox'
+    app.save!
+    app
+  end
+
+  def create_notification
+    notification = Rpush::Apns::Notification.new
+    notification.app = app
+    notification.alert = 'test'
+    notification.device_token = 'a' * 64
+    notification.save!
+    notification
+  end
+
+  def stub_tcp_connection
+    Rpush::Daemon::TcpConnection.any_instance.stub(connect_socket: [tcp_socket, ssl_socket])
+    Rpush::Daemon::TcpConnection.any_instance.stub(setup_ssl_context: double.as_null_object)
+    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
+  end
+
+  def wait_for_notification_to_deliver(notification)
+    Timeout.timeout(timeout) do
+      until notification.delivered
+        sleep 0.1
+        notification.reload
+      end
+    end
+  end
+
+  before do
+    Rpush.config.push_poll = 0
+    Rpush.embed
+  end
+
+  it 'delivers a notification successfully' do
+    sleep 1 # TODO: Need a better way to detect when the Feeder is running.
+    notification = create_notification
+    wait_for_notification_to_deliver(notification)
+  end
+
+  after { Timeout.timeout(timeout) { Rpush.shutdown } }
+end