rpush_extended 3.2.5

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

@@ -0,0 +1,365 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/redis'
+
+describe Rpush::Daemon::Store::Redis do
+  let(:app) { Rpush::Client::Redis::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
+  let(:notification) { Rpush::Client::Redis::Apns::Notification.create!(device_token: "a" * 64, app: app) }
+  let(:store) { Rpush::Daemon::Store::Redis.new }
+  let(:time) { Time.now.utc }
+  let(:logger) { double(Rpush::Logger, error: nil, internal_logger: nil) }
+
+  before do
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Time).to receive_messages(now: time)
+  end
+
+  it 'updates an notification' do
+    expect(notification).to receive(:save!)
+    store.update_notification(notification)
+  end
+
+  it 'updates an app' do
+    expect(app).to receive(:save!)
+    store.update_app(app)
+  end
+
+  it 'finds an app by ID' do
+    app
+    expect(store.app(app.id)).to eq(app)
+  end
+
+  it 'finds all apps' do
+    app
+    expect(store.all_apps).to eq([app])
+  end
+
+  it 'translates an Integer notification ID' do
+    expect(store.translate_integer_notification_id(notification.id)).to eq(notification.id)
+  end
+
+  it 'returns the pending notification count' do
+    notification
+    expect(store.pending_delivery_count).to eq(1)
+  end
+
+  describe 'deliverable_notifications' do
+    it 'loads notifications in batches' do
+      Rpush.config.batch_size = 100
+      allow(store).to receive_messages(pending_notification_ids: [1, 2, 3, 4])
+      expect(Rpush::Client::Redis::Notification).to receive(:find).exactly(4).times
+      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)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to 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)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to eq [notification]
+    end
+
+    it 'does not load an notification with a deliver_after time in the future' do
+      notification
+      notification = store.deliverable_notifications(Rpush.config.batch_size).first
+      store.mark_retryable(notification, 1.hour.from_now)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
+    end
+
+    it 'does not load a previously delivered notification' do
+      notification
+      notification = store.deliverable_notifications(Rpush.config.batch_size).first
+      store.mark_delivered(notification, Time.now)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
+    end
+
+    it "does not enqueue a notification that has previously failed delivery" do
+      notification
+      notification = store.deliverable_notifications(Rpush.config.batch_size).first
+      store.mark_failed(notification, 0, "failed", Time.now)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
+    end
+  end
+
+  describe 'mark_retryable' do
+    it 'increments the retry count' do
+      expect do
+        store.mark_retryable(notification, time)
+      end.to change(notification, :retries).by(1)
+    end
+
+    it 'sets the deliver after timestamp' do
+      deliver_after = time + 10.seconds
+      expect do
+        store.mark_retryable(notification, deliver_after)
+      end.to change(notification, :deliver_after).to(deliver_after)
+    end
+
+    it 'saves the notification without validation' do
+      expect(notification).to receive(:save!).with(validate: false)
+      store.mark_retryable(notification, time)
+    end
+
+    it 'does not save the notification if persist: false' do
+      expect(notification).not_to receive(:save!)
+      store.mark_retryable(notification, time, persist: false)
+    end
+  end
+
+  describe 'mark_ids_retryable' do
+    let(:deliver_after) { time + 10.seconds }
+
+    it 'sets the deliver after timestamp' do
+      expect do
+        store.mark_ids_retryable([notification.id], deliver_after)
+        notification.reload
+      end.to change { notification.deliver_after.try(:utc).to_s }.to(deliver_after.utc.to_s)
+    end
+  end
+
+  describe 'mark_batch_retryable' do
+    let(:deliver_after) { time + 10.seconds }
+
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_retryable([notification], deliver_after)
+      expect(notification.deliver_after).to eq deliver_after
+      expect(notification.retries).to eq 1
+    end
+
+    it 'increments the retired count' do
+      expect do
+        store.mark_batch_retryable([notification], deliver_after)
+        notification.reload
+      end.to change(notification, :retries).by(1)
+    end
+
+    it 'sets the deliver after timestamp' do
+      expect do
+        store.mark_batch_retryable([notification], deliver_after)
+        notification.reload
+      end.to change { notification.deliver_after.try(:utc).to_s }.to(deliver_after.utc.to_s)
+    end
+  end
+
+  describe 'mark_delivered' do
+    it 'marks the notification as delivered' do
+      expect do
+        store.mark_delivered(notification, time)
+      end.to change(notification, :delivered).to(true)
+    end
+
+    it 'sets the time the notification was delivered' do
+      expect do
+        store.mark_delivered(notification, time)
+        notification.reload
+      end.to change { notification.delivered_at.try(:utc).to_s }.to(time.to_s)
+    end
+
+    it 'saves the notification without validation' do
+      expect(notification).to receive(:save!).with(validate: false)
+      store.mark_delivered(notification, time)
+    end
+
+    it 'does not save the notification if persist: false' do
+      expect(notification).not_to receive(:save!)
+      store.mark_delivered(notification, time, persist: false)
+    end
+  end
+
+  describe 'mark_batch_delivered' do
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_delivered([notification])
+      expect(notification.delivered_at).to eq time
+      expect(notification.delivered).to be_truthy
+    end
+
+    it 'marks the notifications as delivered' do
+      expect do
+        store.mark_batch_delivered([notification])
+        notification.reload
+      end.to change(notification, :delivered).to(true)
+    end
+
+    it 'sets the time the notifications were delivered' do
+      expect do
+        store.mark_batch_delivered([notification])
+        notification.reload
+      end.to change { notification.delivered_at.try(:utc).to_s }.to(time.to_s)
+    end
+  end
+
+  describe 'mark_failed' do
+    it 'marks the notification as not delivered' do
+      store.mark_failed(notification, nil, '', time)
+      expect(notification.delivered).to eq(false)
+    end
+
+    it 'marks the notification as failed' do
+      expect do
+        store.mark_failed(notification, nil, '', time)
+        notification.reload
+      end.to change(notification, :failed).to(true)
+    end
+
+    it 'sets the time the notification delivery failed' do
+      expect do
+        store.mark_failed(notification, nil, '', time)
+        notification.reload
+      end.to change { notification.failed_at.try(:utc).to_s }.to(time.to_s)
+    end
+
+    it 'sets the error code' do
+      expect do
+        store.mark_failed(notification, 42, '', time)
+      end.to change(notification, :error_code).to(42)
+    end
+
+    it 'sets the error description' do
+      expect do
+        store.mark_failed(notification, 42, 'Weeee', time)
+      end.to change(notification, :error_description).to('Weeee')
+    end
+
+    it 'saves the notification without validation' do
+      expect(notification).to receive(:save!).with(validate: false)
+      store.mark_failed(notification, nil, '', time)
+    end
+
+    it 'does not save the notification if persist: false' do
+      expect(notification).not_to receive(:save!)
+      store.mark_failed(notification, nil, '', time, persist: false)
+    end
+  end
+
+  describe 'mark_ids_failed' do
+    it 'marks the notification as failed' do
+      expect do
+        store.mark_ids_failed([notification.id], nil, '', Time.now)
+        notification.reload
+      end.to change(notification, :failed).to(true)
+    end
+  end
+
+  describe 'mark_batch_failed' do
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_failed([notification], 123, 'an error')
+      expect(notification.failed_at).to eq time
+      expect(notification.delivered_at).to be_nil
+      expect(notification.delivered).to eq(false)
+      expect(notification.failed).to be_truthy
+      expect(notification.error_code).to eq 123
+      expect(notification.error_description).to eq 'an error'
+    end
+
+    it 'marks the notification as not delivered' do
+      store.mark_batch_failed([notification], nil, '')
+      notification.reload
+      expect(notification.delivered).to be_falsey
+    end
+
+    it 'marks the notification as failed' do
+      expect do
+        store.mark_batch_failed([notification], nil, '')
+        notification.reload
+      end.to change(notification, :failed).to(true)
+    end
+
+    it 'sets the time the notification delivery failed' do
+      expect do
+        store.mark_batch_failed([notification], nil, '')
+        notification.reload
+      end.to change { notification.failed_at.try(:utc).to_s }.to(time.to_s)
+    end
+
+    it 'sets the error code' do
+      expect do
+        store.mark_batch_failed([notification], 42, '')
+        notification.reload
+      end.to change(notification, :error_code).to(42)
+    end
+
+    it 'sets the error description' do
+      expect do
+        store.mark_batch_failed([notification], 42, 'Weeee')
+        notification.reload
+      end.to change(notification, :error_description).to('Weeee')
+    end
+  end
+
+  describe 'create_apns_feedback' do
+    it 'creates the Feedback record' do
+      expect(Rpush::Client::Redis::Apns::Feedback).to 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) { %w(123 456) }
+    let(:deliver_after) { time + 10.seconds }
+    let(:args) { [attributes, data, registration_ids, deliver_after, app] }
+
+    it 'sets the given attributes' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.device_token).to eq 'ab' * 32
+    end
+
+    it 'sets the given data' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.data).to eq(data: true)
+    end
+
+    it 'sets the given registration IDs' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.registration_ids).to eq registration_ids
+    end
+
+    it 'sets the deliver_after timestamp' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.deliver_after.utc.to_s).to eq deliver_after.to_s
+    end
+
+    it 'saves the new notification' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.new_record?).to be_falsey
+    end
+  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) { %w(123 456) }
+    let(:deliver_after) { time + 10.seconds }
+    let(:args) { [attributes, data, registration_ids, deliver_after, app] }
+
+    it 'sets the given attributes' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.app_id).to eq app.id
+      expect(new_notification.collapse_key).to eq 'ckey'
+      expect(new_notification.delay_while_idle).to be_truthy
+    end
+
+    it 'sets the given data' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.data).to eq(data: true)
+    end
+
+    it 'sets the given registration IDs' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.registration_ids).to eq registration_ids
+    end
+
+    it 'sets the deliver_after timestamp' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.deliver_after.utc.to_s).to eq deliver_after.to_s
+    end
+
+    it 'saves the new notification' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.new_record?).to be_falsey
+    end
+  end
+end if redis?

data/spec/unit/daemon/tcp_connection_spec.rb

@@ -0,0 +1,292 @@
+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
+    allow(OpenSSL::SSL::SSLContext).to receive_messages(new: ssl_context)
+    allow(OpenSSL::PKey::RSA).to receive_messages(new: rsa_key)
+    allow(OpenSSL::X509::Certificate).to receive_messages(new: x509_certificate)
+    allow(TCPSocket).to receive_messages(new: tcp_socket)
+    allow(OpenSSL::SSL::SSLSocket).to receive_messages(new: ssl_socket)
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(connection).to receive(:reflect)
+  end
+
+  it "reads the number of bytes from the SSL socket" do
+    expect(ssl_socket).to receive(:read).with(123)
+    connection.connect
+    connection.read(123)
+  end
+
+  it "selects on the SSL socket until the given timeout" do
+    expect(IO).to 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
+      expect(OpenSSL::PKey::RSA).to receive(:new).with(certificate, password).and_return(rsa_key)
+      expect(ssl_context).to receive(:key=).with(rsa_key)
+      connection.connect
+    end
+
+    it "sets the cert on the context" do
+      expect(OpenSSL::X509::Certificate).to receive(:new).with(certificate).and_return(x509_certificate)
+      expect(ssl_context).to 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
+      expect(TCPSocket).to 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
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_context).and_return(ssl_socket)
+      connection.connect
+    end
+
+    it "sets the sync option on the SSL socket" do
+      expect(ssl_socket).to receive(:sync=).with(true)
+      connection.connect
+    end
+
+    it "connects the SSL socket" do
+      expect(ssl_socket).to receive(:connect)
+      connection.connect
+    end
+
+    it "sets the socket option TCP_NODELAY" do
+      expect(tcp_socket).to receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+      connection.connect
+    end
+
+    it "sets the socket option SO_KEEPALIVE" do
+      expect(tcp_socket).to receive(:setsockopt).with(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      connection.connect
+    end
+
+    describe 'certificate expiry' do
+      it 'reflects if the certificate will expire soon' do
+        cert = OpenSSL::X509::Certificate.new(app.certificate)
+        expect(connection).to 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)
+        expect(logger).to 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)
+        expect(connection).not_to 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)
+        expect(logger).to 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::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::CertificateExpiredError)
+        end
+      end
+    end
+
+    describe 'certificate revocation' do
+      let(:cert_revoked_error) { OpenSSL::SSL::SSLError.new('certificate revoked') }
+      before do
+        allow(ssl_socket).to receive(:connect).and_raise(cert_revoked_error)
+      end
+
+      it 'reflects that the certificate has been revoked' do
+        expect(connection).to receive(:reflect).with(:ssl_certificate_revoked, app, 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
+        expect(logger).to receive(:error).with('[Connection 0] Certificate has been revoked.')
+        expect { connection.connect }.to raise_error(Rpush::Daemon::TcpConnectionError, 'OpenSSL::SSL::SSLError, certificate revoked')
+      end
+    end
+  end
+
+  describe "when shuting down the connection" do
+    it "closes the TCP socket" do
+      connection.connect
+      expect(tcp_socket).to receive(:close)
+      connection.close
+    end
+
+    it "does not attempt to close the TCP socket if it is not connected" do
+      connection.connect
+      expect(tcp_socket).not_to receive(:close)
+      connection.instance_variable_set("@tcp_socket", nil)
+      connection.close
+    end
+
+    it "closes the SSL socket" do
+      connection.connect
+      expect(ssl_socket).to receive(:close)
+      connection.close
+    end
+
+    it "does not attempt to close the SSL socket if it is not connected" do
+      connection.connect
+      expect(ssl_socket).not_to receive(:close)
+      connection.instance_variable_set("@ssl_socket", nil)
+      connection.close
+    end
+
+    it "ignores IOError when the socket is already closed" do
+      allow(tcp_socket).to receive(:close).and_raise(IOError)
+      connection.connect
+      connection.close
+    end
+  end
+
+  shared_examples_for "when the write fails" do
+    before do
+      allow(connection).to receive(:sleep)
+      connection.connect
+      allow(ssl_socket).to receive(:write).and_raise(error)
+    end
+
+    it 'reflects the connection has been lost' do
+      expect(connection).to 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
+      expect(logger).to 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
+
+    it "retries to make a connection 3 times" do
+      expect(connection).to receive(:reconnect).exactly(3).times
+      expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
+    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.class.name}, #{error.message}).")
+    end
+
+    it "sleeps 1 second before retrying the connection" do
+      expect(connection).to receive(:sleep).with(1)
+      expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
+    end
+  end
+
+  describe "when write raises an Errno::EPIPE" do
+    it_should_behave_like "when the write fails"
+
+    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
+      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
+      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
+      IOError.new('an message')
+    end
+  end
+
+  describe "when reconnecting" do
+    before { connection.connect }
+
+    it 'closes the socket' do
+      expect(connection).to receive(:close)
+      connection.send(:reconnect)
+    end
+
+    it 'connects the socket' do
+      expect(connection).to 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
+      expect(ssl_socket).to receive(:write).with("blah")
+      connection.write("blah")
+    end
+
+    it "flushes the SSL socket" do
+      expect(ssl_socket).to 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
+      allow(Rpush::Daemon::TcpConnection).to receive_messages(idle_period: 60)
+      allow(Time).to receive_messages(now: Time.now + 61)
+      expect(connection).to receive(:reconnect)
+      connection.write('blah')
+    end
+
+    it 'resets the last touch time' do
+      now = Time.now
+      allow(Time).to receive_messages(now: now)
+      connection.write('blah')
+      expect(connection.last_touch).to eq now
+    end
+
+    it 'does not reconnect if the connection has not been idle for more than the defined period' do
+      expect(connection).not_to receive(:reconnect)
+      connection.write('blah')
+    end
+
+    it 'logs the the connection is idle' do
+      allow(Rpush::Daemon::TcpConnection).to receive_messages(idle_period: 60)
+      allow(Time).to receive_messages(now: Time.now + 61)
+      expect(Rpush.logger).to receive(:info).with('[Connection 0] Idle period exceeded, reconnecting...')
+      connection.write('blah')
+    end
+  end
+end