rpush 8.0.0 → 9.1.0

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

@@ -1,387 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Daemon::Gcm::Delivery do
-  let(:app) { Rpush::Gcm::App.create!(name: 'MyApp', auth_key: 'abc123') }
-  let(:notification) { Rpush::Gcm::Notification.create!(app: app, registration_ids: ['xyz'], 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, notification_processed: nil) }
-  let(:delivery) { Rpush::Daemon::Gcm::Delivery.new(app, http, notification, batch) }
-  let(:store) { double(create_gcm_notification: double(id: 2)) }
-
-  def perform
-    delivery.perform
-  end
-
-  def perform_with_rescue
-    expect { perform }.to raise_error(StandardError)
-  end
-
-  before do
-    allow(delivery).to receive_messages(reflect: nil)
-    allow(Rpush::Daemon).to receive_messages(store: store)
-    allow(Time).to receive_messages(now: now)
-    allow(Rpush).to receive_messages(logger: logger)
-  end
-
-  shared_examples_for 'a notification with some delivery failures' do
-    let(:new_notification) { Rpush::Gcm::Notification.where('id != ?', notification.id).first }
-
-    before { allow(response).to receive_messages(body: JSON.dump(body)) }
-
-    it 'marks the original notification as failed' do
-      # error = Rpush::DeliveryError.new(nil, notification.id, error_description)
-      expect(delivery).to receive(:mark_failed) do |error|
-        expect(error.to_s).to match(error_description)
-      end
-      perform_with_rescue
-    end
-
-    it 'creates a new notification for the unavailable devices' do
-      notification.update(registration_ids: %w(id_0 id_1 id_2), data: { 'one' => 1 }, collapse_key: 'thing', delay_while_idle: true)
-      allow(response).to receive_messages(header: { 'retry-after' => 10 })
-      attrs = { 'collapse_key' => 'thing', 'delay_while_idle' => true, 'app_id' => app.id }
-      expect(store).to receive(:create_gcm_notification).with(attrs, notification.data,
-                                                              %w(id_0 id_2), now + 10.seconds, notification.app)
-      perform_with_rescue
-    end
-
-    it 'raises a DeliveryError' do
-      expect { perform }.to raise_error(Rpush::DeliveryError)
-    end
-  end
-
-  describe 'a 200 response' do
-    before do
-      allow(response).to receive_messages(code: 200)
-    end
-
-    it 'reflects on any IDs which successfully received the notification' do
-      body = {
-        'failure' => 1,
-        'success' => 1,
-        'results' => [
-          { 'message_id' => '1:000' },
-          { 'error' => 'Err' }
-        ]
-      }
-
-      allow(response).to receive_messages(body: JSON.dump(body))
-      allow(notification).to receive_messages(registration_ids: %w(1 2))
-      expect(delivery).to receive(:reflect).with(:gcm_delivered_to_recipient, notification, '1')
-      expect(delivery).not_to receive(:reflect).with(:gcm_delivered_to_recipient, notification, '2')
-      perform_with_rescue
-    end
-
-    it 'reflects on any IDs which failed to receive the notification' do
-      body = {
-        'failure' => 1,
-        'success' => 1,
-        'results' => [
-          { 'error' => 'Err' },
-          { 'message_id' => '1:000' }
-        ]
-      }
-
-      allow(response).to receive_messages(body: JSON.dump(body))
-      allow(notification).to receive_messages(registration_ids: %w(1 2))
-      expect(delivery).to receive(:reflect).with(:gcm_failed_to_recipient, notification, 'Err', '1')
-      expect(delivery).not_to receive(:reflect).with(:gcm_failed_to_recipient, notification, anything, '2')
-      perform_with_rescue
-    end
-
-    it 'reflects on canonical IDs' do
-      body = {
-        'failure' => 0,
-        'success' => 3,
-        'canonical_ids' => 1,
-        'results' => [
-          { 'message_id' => '1:000' },
-          { 'message_id' => '1:000', 'registration_id' => 'canonical123' },
-          { 'message_id' => '1:000' }
-        ] }
-
-      allow(response).to receive_messages(body: JSON.dump(body))
-      allow(notification).to receive_messages(registration_ids: %w(1 2 3))
-      expect(delivery).to receive(:reflect).with(:gcm_canonical_id, '2', 'canonical123')
-      perform
-    end
-
-    it 'reflects on invalid IDs' do
-      body = {
-        'failure' => 1,
-        'success' => 2,
-        'canonical_ids' => 0,
-        'results' => [
-          { 'message_id' => '1:000' },
-          { 'error' => 'NotRegistered' },
-          { 'message_id' => '1:000' }
-        ]
-      }
-
-      allow(response).to receive_messages(body: JSON.dump(body))
-      allow(notification).to receive_messages(registration_ids: %w(1 2 3))
-      expect(delivery).to receive(:reflect).with(:gcm_invalid_registration_id, app, 'NotRegistered', '2')
-      perform_with_rescue
-    end
-
-    describe 'when delivered successfully to all devices' do
-      let(:body) do
-        {
-          'failure' => 0,
-          'success' => 1,
-          'results' => [{ 'message_id' => '1:000' }]
-        }
-      end
-
-      before { allow(response).to receive_messages(body: JSON.dump(body)) }
-
-      it 'marks the notification as delivered' do
-        expect(delivery).to receive(:mark_delivered)
-        perform
-      end
-
-      it 'logs that the notification was delivered' do
-        expect(logger).to receive(:info).with("[MyApp] #{notification.id} sent to xyz")
-        perform
-      end
-    end
-
-    it 'marks a notification as failed if any ids are invalid' do
-      body = {
-        'failure' => 1,
-        'success' => 2,
-        'canonical_ids' => 0,
-        'results' => [
-          { 'message_id' => '1:000' },
-          { 'error' => 'NotRegistered' },
-          { 'message_id' => '1:000' }
-        ]
-      }
-
-      allow(response).to receive_messages(body: JSON.dump(body))
-      expect(delivery).to receive(:mark_failed)
-      expect(delivery).not_to receive(:mark_retryable)
-      expect(store).not_to receive(:create_gcm_notification)
-      perform_with_rescue
-    end
-
-    it 'marks a notification as failed if any deliveries failed that cannot be retried' do
-      body = {
-        'failure' => 1,
-        'success' => 1,
-        'results' => [
-          { 'message_id' => '1:000' },
-          { 'error' => 'InvalidDataKey' }
-        ] }
-      allow(response).to receive_messages(body: JSON.dump(body))
-      error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients. Errors: InvalidDataKey.')
-      expect(delivery).to receive(:mark_failed).with(error)
-      perform_with_rescue
-    end
-
-    describe 'all deliveries failed with Unavailable or InternalServerError' do
-      let(:body) do
-        {
-          'failure' => 2,
-          'success' => 0,
-          'results' => [
-            { 'error' => 'Unavailable' },
-            { 'error' => 'Unavailable' }
-          ]
-        }
-      end
-
-      before do
-        allow(response).to receive_messages(body: JSON.dump(body))
-        allow(notification).to receive_messages(registration_ids: %w(1 2))
-      end
-
-      it 'retries the notification respecting the Retry-After header' do
-        allow(response).to receive_messages(header: { 'retry-after' => 10 })
-        expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
-        perform
-      end
-
-      it 'retries the notification using exponential back-off if the Retry-After header is not present' do
-        expect(delivery).to receive(:mark_retryable).with(notification, now + 2)
-        perform
-      end
-
-      it 'does not mark the notification as failed' do
-        expect(delivery).not_to receive(:mark_failed)
-        perform
-      end
-
-      it 'logs that the notification will be retried' do
-        notification.retries = 1
-        notification.deliver_after = now + 2
-        expect(Rpush.logger).to receive(:warn).with("[MyApp] All recipients unavailable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
-        perform
-      end
-    end
-
-    describe 'all deliveries failed with some as Unavailable or InternalServerError' do
-      let(:body) do
-        { 'failure' => 3,
-          'success' => 0,
-          'results' => [
-            { 'error' => 'Unavailable' },
-            { 'error' => 'InvalidDataKey' },
-            { 'error' => 'Unavailable' }
-          ]
-        }
-      end
-      let(:error_description) { /#{Regexp.escape("Failed to deliver to recipients 0, 1, 2. Errors: Unavailable, InvalidDataKey, Unavailable. 0, 2 will be retried as notification")} [\d]+\./ }
-      it_should_behave_like 'a notification with some delivery failures'
-    end
-
-    describe 'some deliveries failed with Unavailable or InternalServerError' do
-      let(:body) do
-        { 'failure' => 2,
-          'success' => 1,
-          'results' => [
-            { 'error' => 'Unavailable' },
-            { 'message_id' => '1:000' },
-            { 'error' => 'InternalServerError' }
-          ]
-        }
-      end
-      let(:error_description) { /#{Regexp.escape("Failed to deliver to recipients 0, 2. Errors: Unavailable, InternalServerError. 0, 2 will be retried as notification")} [\d]+\./ }
-      it_should_behave_like 'a notification with some delivery failures'
-    end
-  end
-
-  describe 'a 503 response' do
-    before { allow(response).to receive_messages(code: 503) }
-
-    it 'logs a warning that the notification will be retried.' do
-      notification.retries = 1
-      notification.deliver_after = now + 2
-      expect(logger).to receive(:warn).with("[MyApp] GCM responded with an Service Unavailable Error. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
-      perform
-    end
-
-    it 'respects an integer Retry-After header' do
-      allow(response).to receive_messages(header: { 'retry-after' => 10 })
-      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
-      perform
-    end
-
-    it 'respects a HTTP-date Retry-After header' do
-      allow(response).to receive_messages(header: { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
-      expect(delivery).to receive(:mark_retryable).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
-      perform
-    end
-
-    it 'defaults to exponential back-off if the Retry-After header is not present' do
-      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**1)
-      perform
-    end
-  end
-
-  describe 'a 502 response' do
-    before { allow(response).to receive_messages(code: 502) }
-
-    it 'logs a warning that the notification will be retried.' do
-      notification.retries = 1
-      notification.deliver_after = now + 2
-      expect(logger).to receive(:warn).with("[MyApp] GCM responded with a Bad Gateway Error. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
-      perform
-    end
-
-    it 'respects an integer Retry-After header' do
-      allow(response).to receive_messages(header: { 'retry-after' => 10 })
-      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
-      perform
-    end
-
-    it 'respects a HTTP-date Retry-After header' do
-      allow(response).to receive_messages(header: { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
-      expect(delivery).to receive(:mark_retryable).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
-      perform
-    end
-
-    it 'defaults to exponential back-off if the Retry-After header is not present' do
-      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**1)
-      perform
-    end
-  end
-
-  describe 'a 500 response' do
-    before do
-      notification.update_attribute(:retries, 2)
-      allow(response).to receive_messages(code: 500)
-    end
-
-    it 'logs a warning that the notification has been re-queued.' do
-      notification.retries = 3
-      notification.deliver_after = now + 2**3
-      expect(Rpush.logger).to 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
-
-    it 'retries the notification in accordance with the exponential back-off strategy.' do
-      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**3)
-      perform
-    end
-  end
-
-  describe 'a 5xx response' do
-    before { allow(response).to receive_messages(code: 555) }
-
-    it 'logs a warning that the notification will be retried.' do
-      notification.retries = 1
-      notification.deliver_after = now + 2
-      expect(logger).to receive(:warn).with("[MyApp] GCM responded with a 5xx Error. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
-      perform
-    end
-
-    it 'respects an integer Retry-After header' do
-      allow(response).to receive_messages(header: { 'retry-after' => 10 })
-      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
-      perform
-    end
-
-    it 'respects a HTTP-date Retry-After header' do
-      allow(response).to receive_messages(header: { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
-      expect(delivery).to receive(:mark_retryable).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
-      perform
-    end
-
-    it 'defaults to exponential back-off if the Retry-After header is not present' do
-      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**1)
-      perform
-    end
-  end
-
-  describe 'a 401 response' do
-    before { allow(response).to receive_messages(code: 401) }
-
-    it 'raises an error' do
-      expect { perform }.to raise_error(Rpush::DeliveryError)
-    end
-  end
-
-  describe 'a 400 response' do
-    before { allow(response).to receive_messages(code: 400) }
-
-    it 'marks the notification as failed' do
-      error = Rpush::DeliveryError.new(400, notification.id, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
-      expect(delivery).to receive(:mark_failed).with(error)
-      perform_with_rescue
-    end
-  end
-
-  describe 'an un-handled response' do
-    before { allow(response).to receive_messages(code: 418) }
-
-    it 'marks the notification as failed' do
-      error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
-      expect(delivery).to receive(:mark_failed).with(error)
-      perform_with_rescue
-    end
-  end
-end

data/spec/unit/daemon/tcp_connection_spec.rb

@@ -1,293 +0,0 @@
-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(x509_certificate).to receive(:not_after).and_return(Time.now + 1.year)
-    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 = x509_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 = x509_certificate
-        expect(logger).to receive(:warn).with("[#{app.name}] Certificate will expire at #{cert.not_after.utc}.")
-        Timecop.freeze(cert.not_after - 3.days) { connection.connect }
-      end
-
-      it 'does not reflect if the certificate will not expire soon' do
-        cert = x509_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 = x509_certificate
-        expect(logger).to receive(:error).with("[#{app.name}] Certificate expired at #{cert.not_after.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 = x509_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