rpush 1.0.0-java

data/spec/unit/daemon/tcp_connection_spec.rb

@@ -0,0 +1,287 @@
+require "unit_spec_helper"
+
+describe Rpush::Daemon::TcpConnection do
+  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) { 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)
+    connection.stub(:reflect)
+  end
+
+  it "reads the number of bytes from the SSL socket" do
+    ssl_socket.should_receive(:read).with(123)
+    connection.connect
+    connection.read(123)
+  end
+
+  it "selects on the SSL socket until the given timeout" do
+    IO.should_receive(:select).with([ssl_socket], nil, nil, 10)
+    connection.connect
+    connection.select(10)
+  end
+
+  describe "when setting up the SSL context" do
+    it "sets the key on the context" do
+      OpenSSL::PKey::RSA.should_receive(:new).with(certificate, password).and_return(rsa_key)
+      ssl_context.should_receive(:key=).with(rsa_key)
+      connection.connect
+    end
+
+    it "sets the cert on the context" do
+      OpenSSL::X509::Certificate.should_receive(:new).with(certificate).and_return(x509_certificate)
+      ssl_context.should_receive(:cert=).with(x509_certificate)
+      connection.connect
+    end
+  end
+
+  describe "when connecting the socket" do
+    it "creates a TCP socket using the configured host and port" do
+      TCPSocket.should_receive(:new).with(host, port).and_return(tcp_socket)
+      connection.connect
+    end
+
+    it "creates a new SSL socket using the TCP socket and SSL context" do
+      OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_context).and_return(ssl_socket)
+      connection.connect
+    end
+
+    it "sets the sync option on the SSL socket" do
+      ssl_socket.should_receive(:sync=).with(true)
+      connection.connect
+    end
+
+    it "connects the SSL socket" do
+      ssl_socket.should_receive(:connect)
+      connection.connect
+    end
+
+    it "sets the socket option TCP_NODELAY" do
+      tcp_socket.should_receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      connection.connect
+    end
+
+    it "sets the socket option SO_KEEPALIVE" 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(:ssl_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(:ssl_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 Rpush::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(Rpush::Apns::CertificateExpiredError)
+        end
+      end
+    end
+  end
+
+  describe "when shuting down the connection" do
+    it "closes the TCP socket" do
+      connection.connect
+      tcp_socket.should_receive(:close)
+      connection.close
+    end
+
+    it "does not attempt to close the TCP socket if it is not connected" do
+      connection.connect
+      tcp_socket.should_not_receive(:close)
+      connection.instance_variable_set("@tcp_socket", nil)
+      connection.close
+    end
+
+    it "closes the SSL socket" do
+      connection.connect
+      ssl_socket.should_receive(:close)
+      connection.close
+    end
+
+    it "does not attempt to close the SSL socket if it is not connected" do
+      connection.connect
+      ssl_socket.should_not_receive(:close)
+      connection.instance_variable_set("@ssl_socket", nil)
+      connection.close
+    end
+
+    it "ignores IOError when the socket is already closed" do
+      tcp_socket.stub(:close).and_raise(IOError)
+      connection.connect
+      connection.close
+    end
+  end
+
+  shared_examples_for "when the write fails" do
+    before do
+      connection.stub(:sleep)
+      connection.connect
+      ssl_socket.stub(:write).and_raise(error_type)
+    end
+
+    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
+    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
+    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
+    end
+
+    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
+
+    it "sleeps 1 second before retrying the connection" do
+      connection.should_receive(:sleep).with(1)
+      begin
+        connection.write(nil)
+      rescue Rpush::Daemon::TcpConnectionError
+      end
+    end
+  end
+
+  describe "when write raises an Errno::EPIPE" do
+    it_should_behave_like "when the write fails"
+
+    def error_type
+      Errno::EPIPE
+    end
+  end
+
+  describe "when write raises an Errno::ETIMEDOUT" do
+    it_should_behave_like "when the write fails"
+
+    def error_type
+      Errno::ETIMEDOUT
+    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
+    end
+  end
+
+  describe "when write raises an IOError" do
+    it_should_behave_like "when the write fails"
+
+    def error_type
+      IOError
+    end
+  end
+
+  describe "when reconnecting" do
+    before { connection.connect }
+
+    it 'closes the socket' do
+      connection.should_receive(:close)
+      connection.send(:reconnect)
+    end
+
+    it 'connects the socket' do
+      connection.should_receive(:connect_socket)
+      connection.send(:reconnect)
+    end
+  end
+
+  describe "when sending a notification" do
+    before { connection.connect }
+
+    it "writes the data to the SSL socket" do
+      ssl_socket.should_receive(:write).with("blah")
+      connection.write("blah")
+    end
+
+    it "flushes the SSL socket" do
+      ssl_socket.should_receive(:flush)
+      connection.write("blah")
+    end
+  end
+
+  describe 'idle period' 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)
+      connection.should_receive(:reconnect)
+      connection.write('blah')
+    end
+
+    it 'resets the last write time' do
+      now = Time.now
+      Time.stub(:now => now)
+      connection.write('blah')
+      connection.last_write.should eq now
+    end
+
+    it 'does not reconnect if the connection has not been idle for more than the defined period' do
+      connection.should_not_receive(:reconnect)
+      connection.write('blah')
+    end
+
+    it 'logs the the connection is idle' do
+      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
+  end
+end

data/spec/unit/daemon/too_many_requests_error_spec.rb

@@ -0,0 +1,14 @@
+require "unit_spec_helper"
+
+describe Rpush::TooManyRequestsError do
+  let(:response) { double(:code => 429, :header => { 'retry-after' => 3600 }) }
+  let(:error) { Rpush::TooManyRequestsError.new(429, 12, "Too Many Requests", response) }
+
+  it "returns an informative message" do
+    error.to_s.should eq "Too many requests for 12, received error 429 (Too Many Requests) - retry after 3600"
+  end
+
+  it "returns the error code" do
+    error.code.should eq 429
+  end
+end

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

@@ -0,0 +1,159 @@
+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(:now) { Time.parse('2012-10-14 00:00:00') }
+  let(:batch) { double(mark_failed: nil, mark_delivered: nil, mark_retryable: nil) }
+  let(:delivery) { Rpush::Daemon::Wpns::Delivery.new(app, http, notification, batch) }
+  let(:store) { double(:create_wpns_notification => double(:id => 2)) }
+
+  def perform
+    delivery.perform
+  end
+
+  before do
+    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)) }
+
+    it "marks the original notification falied" do
+      delivery.should_receive(:mark_failed).with(notification, nil, error_description)
+      perform rescue Rpush::DeliveryError
+    end
+
+    it "raises a DeliveryError" do
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe "an 200 response" do
+    before do
+      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"]})
+      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))
+      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
+    end
+  end
+
+  describe "an 400 response" do
+    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
+    end
+  end
+
+  describe "an 401 response" do
+    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
+    end
+  end
+
+  describe "an 404 response" do
+    before { response.stub(:code => 404) }
+    it "marks notifications as failed" do
+      delivery.should_receive(:mark_failed).with(404, "Not Found")
+      perform rescue Rpush::DeliveryError
+    end
+  end
+
+  describe "an 405 response" do
+    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
+    end
+  end
+
+  describe "an 406 response" do
+    before { response.stub(:code => 406) }
+
+    it "retries the notification" do
+      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).")
+      perform
+    end
+  end
+
+  describe "an 412 response" do
+    before { response.stub(:code => 412) }
+
+    it "retries the notification" do
+      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).")
+      perform
+    end
+  end
+
+  describe "an 503 response" do
+    before { response.stub(:code => 503) }
+
+    it "retries the notification exponentially" do
+      delivery.should_receive(:mark_retryable_exponential).with(notification)
+      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] Service Unavailable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+      perform
+    end
+  end
+
+  describe 'an un-handled response' do
+    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
+    end
+  end
+end

data/spec/unit/daemon_spec.rb

@@ -0,0 +1,159 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
+
+describe Rpush::Daemon, "when starting" do
+  module Rails; end
+
+  let(:certificate) { double }
+  let(:password) { double }
+  let(:config) { double(:pid_file => nil, :foreground => true,
+    :embedded => false, :push => false, :store => :active_record,
+    :logger => nil) }
+  let(:logger) { double(:logger, :info => nil, :error => nil, :warn => nil) }
+
+  before do
+    Rpush.stub(:config => config, :logger => logger)
+    Rpush::Daemon::Feeder.stub(:start)
+    Rpush::Daemon::AppRunner.stub(:sync => nil, :stop => nil)
+    Rpush::Daemon.stub(:daemonize => nil, :exit => nil, :puts => nil)
+    File.stub(:open)
+    Rails.stub(:root).and_return("/rails_root")
+  end
+
+  unless Rpush.jruby?
+    it "forks into a daemon if the foreground option is false" do
+      config.stub(:foreground => false)
+      Rpush::Daemon.initialize_store
+      Rpush::Daemon.store.stub(:after_daemonize => nil)
+      Rpush::Daemon.should_receive(:daemonize)
+      Rpush::Daemon.start
+    end
+
+    it 'notifies the store after forking' do
+      config.stub(:foreground => false)
+      Rpush::Daemon.initialize_store
+      Rpush::Daemon.store.should_receive(:after_daemonize)
+      Rpush::Daemon.start
+    end
+
+    it "does not fork into a daemon if the foreground option is true" do
+      config.stub(:foreground => true)
+      Rpush::Daemon.should_not_receive(:daemonize)
+      Rpush::Daemon.start
+    end
+
+    it "does not fork into a daemon if the push option is true" do
+      config.stub(:push => true)
+      Rpush::Daemon.should_not_receive(:daemonize)
+      Rpush::Daemon.start
+    end
+
+    it "does not fork into a daemon if the embedded option is true" do
+      config.stub(:embedded => true)
+      Rpush::Daemon.should_not_receive(:daemonize)
+      Rpush::Daemon.start
+    end
+  end
+
+  it 'sets up setup signal traps' do
+    Rpush::Daemon.should_receive(:setup_signal_traps)
+    Rpush::Daemon.start
+  end
+
+  it 'does not setup signal traps when embedded' do
+    config.stub(:embedded => true)
+    Rpush::Daemon.should_not_receive(:setup_signal_traps)
+    Rpush::Daemon.start
+  end
+
+  it 'instantiates the store' do
+    config.stub(:store => :active_record)
+    Rpush::Daemon.start
+    Rpush::Daemon.store.should be_kind_of(Rpush::Daemon::Store::ActiveRecord)
+  end
+
+  it 'logs an error if the store cannot be loaded' do
+    config.stub(:store => :foo_bar)
+    Rpush.logger.should_receive(:error).with(kind_of(LoadError))
+    Rpush::Daemon.start
+  end
+
+  it "writes the process ID to the PID file" do
+    Rpush::Daemon.should_receive(:write_pid_file)
+    Rpush::Daemon.start
+  end
+
+  it "logs an error if the PID file could not be written" do
+    config.stub(:pid_file => '/rails_root/rpush.pid')
+    File.stub(:open).and_raise(Errno::ENOENT)
+    logger.should_receive(:error).with("Failed to write PID to '/rails_root/rpush.pid': #<Errno::ENOENT: No such file or directory>")
+    Rpush::Daemon.start
+  end
+
+  it "starts the feeder" do
+    Rpush::Daemon::Feeder.should_receive(:start)
+    Rpush::Daemon.start
+  end
+
+  it "syncs apps" do
+    Rpush::Daemon::AppRunner.should_receive(:sync)
+    Rpush::Daemon.start
+  end
+end
+
+describe Rpush::Daemon, "when being shutdown" do
+  let(:config) { double(:pid_file => '/rails_root/rpush.pid') }
+  let(:logger) { double(:info => nil, :error => nil, :warn => nil) }
+
+  before do
+    Rpush.stub(:config => config)
+    Rpush::Daemon.stub(:puts => nil)
+    Rpush::Daemon::Feeder.stub(:stop)
+    Rpush::Daemon::AppRunner.stub(:stop)
+  end
+
+  # These tests do not work on JRuby.
+  unless Rpush.jruby?
+    it "shuts down when signaled signaled SIGINT" do
+      Rpush::Daemon.setup_signal_traps
+      Rpush::Daemon.should_receive(:shutdown)
+      Process.kill("SIGINT", Process.pid)
+      sleep 0.01
+    end
+
+    it "shuts down when signaled signaled SIGTERM" do
+      Rpush::Daemon.setup_signal_traps
+      Rpush::Daemon.should_receive(:shutdown)
+      Process.kill("SIGTERM", Process.pid)
+      sleep 0.01
+    end
+  end
+
+  it "stops the feeder" do
+    Rpush::Daemon::Feeder.should_receive(:stop)
+    Rpush::Daemon.shutdown
+  end
+
+  it "stops the app runners" do
+    Rpush::Daemon::AppRunner.should_receive(:stop)
+    Rpush::Daemon.shutdown
+  end
+
+  it "removes the PID file if one was written" do
+    File.stub(:exists?).and_return(true)
+    File.should_receive(:delete).with("/rails_root/rpush.pid")
+    Rpush::Daemon.shutdown
+  end
+
+  it "does not attempt to remove the PID file if it does not exist" do
+    File.stub(:exists?).and_return(false)
+    File.should_not_receive(:delete)
+    Rpush::Daemon.shutdown
+  end
+
+  it "does not attempt to remove the PID file if one was not written" do
+    config.stub(:pid_file).and_return(nil)
+    File.should_not_receive(:delete)
+    Rpush::Daemon.shutdown
+  end
+end

data/spec/unit/deprecatable_spec.rb

@@ -0,0 +1,32 @@
+require 'unit_spec_helper'
+
+describe Rpush::Deprecatable do
+  class HasDeprecatedMethod
+    include Rpush::Deprecatable
+
+    def original_called?
+      @called == true
+    end
+
+    def deprecated_method
+      @called = true
+    end
+    deprecated(:deprecated_method, '4.0')
+  end
+
+  let(:klass) { HasDeprecatedMethod.new }
+
+  before do
+    Rpush::Deprecation.stub(:warn)
+  end
+
+  it 'warns the method is deprecated when called' do
+    Rpush::Deprecation.should_receive(:warn).with("deprecated_method is deprecated and will be removed from Rpush 4.0.")
+    klass.deprecated_method
+  end
+
+  it 'calls the original method' do
+    klass.deprecated_method
+    klass.original_called?.should be_true
+  end
+end

data/spec/unit/deprecation_spec.rb

@@ -0,0 +1,15 @@
+require 'unit_spec_helper'
+
+describe Rpush::Deprecation do
+  it 'prints a warning' do
+    STDERR.should_receive(:puts).with("DEPRECATION WARNING: msg")
+    Rpush::Deprecation.warn("msg")
+  end
+
+  it 'does not print a warning when muted' do
+    STDERR.should_not_receive(:puts)
+    Rpush::Deprecation.muted do
+      Rpush::Deprecation.warn("msg")
+    end
+  end
+end