rpush 2.3.1-java → 2.3.2-java

data/spec/unit/daemon/tcp_connection_spec.rb

@@ -15,94 +15,94 @@ describe Rpush::Daemon::TcpConnection do
   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)
+    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
-    ssl_socket.should_receive(:read).with(123)
+    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
-    IO.should_receive(:select).with([ssl_socket], nil, nil, 10)
+    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
-      OpenSSL::PKey::RSA.should_receive(:new).with(certificate, password).and_return(rsa_key)
-      ssl_context.should_receive(:key=).with(rsa_key)
+      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
-      OpenSSL::X509::Certificate.should_receive(:new).with(certificate).and_return(x509_certificate)
-      ssl_context.should_receive(:cert=).with(x509_certificate)
+      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
-      TCPSocket.should_receive(:new).with(host, port).and_return(tcp_socket)
+      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
-      OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_context).and_return(ssl_socket)
+      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
-      ssl_socket.should_receive(:sync=).with(true)
+      expect(ssl_socket).to receive(:sync=).with(true)
       connection.connect
     end
 
     it "connects the SSL socket" do
-      ssl_socket.should_receive(:connect)
+      expect(ssl_socket).to 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, true)
+      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
-      tcp_socket.should_receive(:setsockopt).with(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      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)
-        connection.should_receive(:reflect).with(:ssl_certificate_will_expire, app, cert.not_after)
+        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)
-        logger.should_receive(:warn).with("[#{app.name}] Certificate will expire at 2022-09-07 03:18:32 UTC.")
+        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)
-        connection.should_not_receive(:reflect).with(:ssl_certificate_will_expire, app, kind_of(Time))
+        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)
-        logger.should_receive(:error).with("[#{app.name}] Certificate expired at 2022-09-07 03:18:32 UTC.")
+        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
 
@@ -117,16 +117,16 @@ describe Rpush::Daemon::TcpConnection do
     describe 'certificate revocation' do
       let(:cert_revoked_error) { OpenSSL::SSL::SSLError.new('certificate revoked') }
       before do
-        ssl_socket.stub(:connect).and_raise(cert_revoked_error)
+        allow(ssl_socket).to receive(:connect).and_raise(cert_revoked_error)
       end
 
       it 'reflects that the certificate has been revoked' do
-        connection.should_receive(:reflect).with(:ssl_certificate_revoked, app, cert_revoked_error)
+        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
-        logger.should_receive(:warn).with('[Connection 0] Certificate has been revoked.')
+        expect(logger).to receive(:warn).with('[Connection 0] Certificate has been revoked.')
         expect { connection.connect }.to raise_error(Rpush::Daemon::TcpConnectionError, 'OpenSSL::SSL::SSLError, certificate revoked')
       end
     end
@@ -135,32 +135,32 @@ describe Rpush::Daemon::TcpConnection do
   describe "when shuting down the connection" do
     it "closes the TCP socket" do
       connection.connect
-      tcp_socket.should_receive(:close)
+      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
-      tcp_socket.should_not_receive(:close)
+      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
-      ssl_socket.should_receive(:close)
+      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
-      ssl_socket.should_not_receive(:close)
+      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
-      tcp_socket.stub(:close).and_raise(IOError)
+      allow(tcp_socket).to receive(:close).and_raise(IOError)
       connection.connect
       connection.close
     end
@@ -168,23 +168,23 @@ describe Rpush::Daemon::TcpConnection do
 
   shared_examples_for "when the write fails" do
     before do
-      connection.stub(:sleep)
+      allow(connection).to receive(:sleep)
       connection.connect
-      ssl_socket.stub(:write).and_raise(error)
+      allow(ssl_socket).to receive(: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.class))
+      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
-      logger.should_receive(:error).with("[Connection 0] Lost connection to gateway.push.apple.com:2195 (#{error.class.name}, #{error.message}), reconnecting...").once
+      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
-      connection.should_receive(:reconnect).exactly(3).times
+      expect(connection).to receive(:reconnect).exactly(3).times
       expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
     end
 
@@ -195,7 +195,7 @@ describe Rpush::Daemon::TcpConnection do
     end
 
     it "sleeps 1 second before retrying the connection" do
-      connection.should_receive(:sleep).with(1)
+      expect(connection).to receive(:sleep).with(1)
       expect { connection.write(nil) }.to raise_error(Rpush::Daemon::TcpConnectionError)
     end
   end
@@ -236,12 +236,12 @@ describe Rpush::Daemon::TcpConnection do
     before { connection.connect }
 
     it 'closes the socket' do
-      connection.should_receive(:close)
+      expect(connection).to receive(:close)
       connection.send(:reconnect)
     end
 
     it 'connects the socket' do
-      connection.should_receive(:connect_socket)
+      expect(connection).to receive(:connect_socket)
       connection.send(:reconnect)
     end
   end
@@ -250,12 +250,12 @@ describe Rpush::Daemon::TcpConnection do
     before { connection.connect }
 
     it "writes the data to the SSL socket" do
-      ssl_socket.should_receive(:write).with("blah")
+      expect(ssl_socket).to receive(:write).with("blah")
       connection.write("blah")
     end
 
     it "flushes the SSL socket" do
-      ssl_socket.should_receive(:flush)
+      expect(ssl_socket).to receive(:flush)
       connection.write("blah")
     end
   end
@@ -264,28 +264,28 @@ describe Rpush::Daemon::TcpConnection 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)
+      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
-      Time.stub(now: now)
+      allow(Time).to receive_messages(now: now)
       connection.write('blah')
-      connection.last_touch.should eq now
+      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
-      connection.should_not_receive(:reconnect)
+      expect(connection).not_to 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...')
+      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

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

@@ -20,20 +20,20 @@ describe Rpush::Daemon::Wpns::Delivery do
   end
 
   before do
-    delivery.stub(reflect: nil)
-    Rpush::Daemon.stub(store: store)
-    Time.stub(now: now)
-    Rpush.stub(logger: logger)
+    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 "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)) }
+    before { allow(response).to receive_messages(body: JSON.dump(body)) }
 
     it "marks the original notification falied" do
-      delivery.should_receive(:mark_failed) do |error|
-        error.message.should =~ error_description
+      expect(delivery).to receive(:mark_failed) do |error|
+        expect(error.message).to match(error_description)
       end
       perform_with_rescue
     end
@@ -45,122 +45,122 @@ describe Rpush::Daemon::Wpns::Delivery do
 
   describe "an 200 response" do
     before do
-      response.stub(code: 200)
+      allow(response).to receive_messages(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)
+      allow(response).to receive_messages(body: JSON.dump("failure" => 0))
+      allow(response).to receive_messages(to_hash: { "x-notificationstatus" => ["Received"] })
+      expect(batch).to 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))
+      allow(response).to receive_messages(body: JSON.dump("failure" => 0))
+      allow(response).to receive_messages(to_hash: { "x-notificationstatus" => ["QueueFull"] })
+      expect(batch).to 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"] })
+      allow(response).to receive_messages(body: JSON.dump("faliure" => 0))
+      allow(response).to receive_messages(to_hash: { "x-notificationstatus" => ["Suppressed"] })
       error = Rpush::DeliveryError.new(200, notification.id, 'Notification was received but suppressed by the service.')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end
 
   describe "an 400 response" do
-    before { response.stub(code: 400) }
+    before { allow(response).to receive_messages(code: 400) }
     it "marks notifications as failed" do
       error = Rpush::DeliveryError.new(400, notification.id, 'Bad XML or malformed notification URI.')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end
 
   describe "an 401 response" do
-    before { response.stub(code: 401) }
+    before { allow(response).to receive_messages(code: 401) }
     it "marks notifications as failed" do
       error = Rpush::DeliveryError.new(401, notification.id, 'Unauthorized to send a notification to this app.')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end
 
   describe "an 404 response" do
-    before { response.stub(code: 404) }
+    before { allow(response).to receive_messages(code: 404) }
     it "marks notifications as failed" do
       error = Rpush::DeliveryError.new(404, notification.id, 'Not Found')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end
 
   describe "an 405 response" do
-    before { response.stub(code: 405) }
+    before { allow(response).to receive_messages(code: 405) }
     it "marks notifications as failed" do
       error = Rpush::DeliveryError.new(405, notification.id, 'Method Not Allowed')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end
 
   describe "an 406 response" do
-    before { response.stub(code: 406) }
+    before { allow(response).to receive_messages(code: 406) }
 
     it "retries the notification" do
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 60))
+      expect(batch).to 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 #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+      expect(logger).to receive(:warn).with("[MyApp] Per-day throttling limit reached. Notification #{notification.id} 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) }
+    before { allow(response).to receive_messages(code: 412) }
 
     it "retries the notification" do
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 60))
+      expect(batch).to 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 #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+      expect(logger).to receive(:warn).with("[MyApp] Device unreachable. Notification #{notification.id} 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) }
+    before { allow(response).to receive_messages(code: 503) }
 
     it "retries the notification exponentially" do
-      delivery.should_receive(:mark_retryable_exponential).with(notification)
+      expect(delivery).to 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).")
+      expect(logger).to 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) }
+    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")
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end