rapns 0.2.3 → 1.0.0

data/spec/rapns/daemon/connection_spec.rb

@@ -10,10 +10,10 @@ describe Rapns::Daemon::Connection, "when setting up the SSL context" do
     Rapns::Daemon.stub(:certificate).and_return(@certificate)
     @x509_certificate = mock("X509 Certificate")
     OpenSSL::X509::Certificate.stub(:new).and_return(@x509_certificate)
-    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
     @connection.stub(:connect_socket)
     @connection.stub(:setup_at_exit_hook)
-    configuration = mock("Configuration", :host => "localhost", :port => 123, :certificate_password => "abc123")
+    configuration = mock("Configuration", :certificate_password => "abc123")
     Rapns::Daemon.stub(:configuration).and_return(configuration)
   end
 
@@ -32,24 +32,20 @@ end
 
 describe Rapns::Daemon::Connection, "when connecting the socket" do
   before do
-    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
     @connection.stub(:setup_at_exit_hook)
     @ssl_context = mock("SSLContext")
     @connection.stub(:setup_ssl_context).and_return(@ssl_context)
     @tcp_socket = mock("TCPSocket", :close => nil, :setsockopt => nil)
     TCPSocket.stub(:new).and_return(@tcp_socket)
-    Rapns::Daemon::Configuration.stub(:host).and_return("localhost")
-    Rapns::Daemon::Configuration.stub(:port).and_return(123)
     @ssl_socket = mock("SSLSocket", :sync= => nil, :connect => nil, :close => nil)
     OpenSSL::SSL::SSLSocket.stub(:new).and_return(@ssl_socket)
-    configuration = mock("Configuration", :host => "localhost", :port => 123)
-    Rapns::Daemon.stub(:configuration).and_return(configuration)
     @logger = mock("Logger", :info => nil)
     Rapns::Daemon.stub(:logger).and_return(@logger)
   end
 
   it "should create a TCP socket using the configured host and port" do
-    TCPSocket.should_receive(:new).with("localhost", 123).and_return(@tcp_socket)
+    TCPSocket.should_receive(:new).with('gateway.push.apple.com', 2195).and_return(@tcp_socket)
     @connection.connect
   end
 
@@ -81,7 +77,7 @@ end
 
 describe Rapns::Daemon::Connection, "when shuting down the connection" do
   before do
-    @connection = Rapns::Daemon::Connection.new("Connection 1")
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
     @connection.stub(:setup_ssl_context)
     @ssl_socket = mock("SSLSocket", :close => nil)
     @tcp_socket = mock("TCPSocket", :close => nil)
@@ -113,69 +109,58 @@ describe Rapns::Daemon::Connection, "when shuting down the connection" do
     @connection.instance_variable_set("@ssl_socket", nil)
     @connection.close
   end
-end
 
-describe Rapns::Daemon::Connection, "when the connection is lost" do
-  before do
-    @connection = Rapns::Daemon::Connection.new("Connection 1")
-    @ssl_socket = mock("SSLSocket")
-    @connection.instance_variable_set("@ssl_socket", @ssl_socket)
-    @connection.stub(:connect_socket).and_return([mock("TCPSocket"), @ssl_socket])
-    @ssl_socket.stub(:write).and_raise(Errno::EPIPE)
-    @logger = mock("Logger", :error => nil)
-    Rapns::Daemon.stub(:logger).and_return(@logger)
-    @connection.stub(:sleep)
-    configuration = mock("Configuration", :host => "localhost", :port => 123)
-    Rapns::Daemon.stub(:configuration).and_return(configuration)
+  it "should ignore IOError when the socket is already closed" do
+    @tcp_socket.stub(:close).and_raise(IOError)
+    @connection.connect
+    expect {@connection.close }.should_not raise_error(IOError)
   end
+end
 
-  it "should log a error" do
-    Rapns::Daemon.logger.should_receive(:error).with("[Connection 1] Lost connection to localhost:123, reconnecting...")
-    begin
-      @connection.write(nil)
-    rescue Rapns::Daemon::ConnectionError
-    end
+describe Rapns::Daemon::Connection, "read" do
+  before do
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
+    @connection.stub(:setup_ssl_context)
+    @ssl_socket = mock("SSLSocket", :close => nil)
+    @tcp_socket = mock("TCPSocket", :close => nil)
+    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
   end
 
-  it "should retry to make a connection 3 times" do
-    @connection.should_receive(:connect_socket).exactly(3).times
-    begin
-      @connection.write(nil)
-    rescue Rapns::Daemon::ConnectionError
-    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
+end
 
-  it "should raise a ConnectionError after 3 attempts at reconnecting" do
-    expect do
-      @connection.write(nil)
-    end.to raise_error(Rapns::Daemon::ConnectionError, "Connection 1 tried 3 times to reconnect but failed: #<Errno::EPIPE: Broken pipe>")
+describe Rapns::Daemon::Connection, "select" do
+  before do
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
+    @connection.stub(:setup_ssl_context)
+    @ssl_socket = mock("SSLSocket", :close => nil)
+    @tcp_socket = mock("TCPSocket", :close => nil)
+    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
   end
 
-  it "should sleep 1 second before retrying the connection" do
-    @connection.should_receive(:sleep).with(1)
-    begin
-      @connection.write(nil)
-    rescue Rapns::Daemon::ConnectionError
-    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
 end
 
-describe Rapns::Daemon::Connection, "when an SSL error occurs during write" do
+shared_examples_for "when the write fails" do
   before do
-    @connection = Rapns::Daemon::Connection.new("Connection 1")
-    @ssl_socket = mock("SSLSocket")
-    @connection.instance_variable_set("@ssl_socket", @ssl_socket)
-    @connection.stub(:connect_socket).and_return([mock("TCPSocket"), @ssl_socket])
-    @ssl_socket.stub(:write).and_raise(OpenSSL::SSL::SSLError)
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
     @logger = mock("Logger", :error => nil)
     Rapns::Daemon.stub(:logger).and_return(@logger)
+    @connection.stub(:reconnect)
+    @connection.stub(:write_data).and_raise(error_type)
     @connection.stub(:sleep)
-    configuration = mock("Configuration", :host => "localhost", :port => 123)
-    Rapns::Daemon.stub(:configuration).and_return(configuration)
   end
 
-  it "should log a error" do
-    Rapns::Daemon.logger.should_receive(:error).with("[Connection 1] Lost connection to localhost:123, reconnecting...")
+  it "should log that the connection has been lost once only" do
+    Rapns::Daemon.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 Rapns::Daemon::ConnectionError
@@ -183,7 +168,7 @@ describe Rapns::Daemon::Connection, "when an SSL error occurs during write" do
   end
 
   it "should retry to make a connection 3 times" do
-    @connection.should_receive(:connect_socket).exactly(3).times
+    @connection.should_receive(:reconnect).exactly(3).times
     begin
       @connection.write(nil)
     rescue Rapns::Daemon::ConnectionError
@@ -193,7 +178,7 @@ describe Rapns::Daemon::Connection, "when an SSL error occurs during write" do
   it "should raise a ConnectionError after 3 attempts at reconnecting" do
     expect do
       @connection.write(nil)
-    end.to raise_error(Rapns::Daemon::ConnectionError, "Connection 1 tried 3 times to reconnect but failed: #<OpenSSL::SSL::SSLError: OpenSSL::SSL::SSLError>")
+    end.to raise_error(Rapns::Daemon::ConnectionError, "Connection 0 tried 3 times to reconnect but failed (#{error_type.name}).")
   end
 
   it "should sleep 1 second before retrying the connection" do
@@ -205,98 +190,65 @@ describe Rapns::Daemon::Connection, "when an SSL error occurs during write" do
   end
 end
 
-describe Rapns::Daemon::Connection, "when sending a notification" do
-  before do
-    @connection = Rapns::Daemon::Connection.new("Connection 1")
-    @ssl_socket = mock("SSLSocket", :write => nil, :flush => nil, :close => nil)
-    @tcp_socket = mock("TCPSocket", :close => nil)
-    @connection.stub(:setup_ssl_context)
-    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
-    @connection.stub(:check_for_error)
-    @connection.connect
-  end
-
-  it "should write the data to the SSL socket" do
-    @ssl_socket.should_receive(:write).with("blah")
-    @connection.write("blah")
-  end
-
-  it "should flush the SSL socket" do
-    @ssl_socket.should_receive(:flush)
-    @connection.write("blah")
-  end
+describe Rapns::Daemon::Connection, "when write raises an Errno::EPIPE" do
+  it_should_behave_like "when the write fails"
 
-  it "should select check for an error packet" do
-    @connection.should_receive(:check_for_error)
-    @connection.write("blah")
+  def error_type
+    Errno::EPIPE
   end
 end
 
-describe Rapns::Daemon::Connection, "when receiving an error packet" do
-  before do
-    @notification = Rapns::Notification.create!(:device_token => "a" * 64)
-    @notification.stub(:save!)
-    @connection = Rapns::Daemon::Connection.new("Connection 1")
-    @ssl_socket = mock("SSLSocket", :write => nil, :flush => nil, :close => nil, :read => [8, 4, @notification.id].pack("ccN"))
-    @connection.stub(:setup_ssl_context)
-    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
-    IO.stub(:select).and_return([@ssl_socket, [], []])
-    logger = mock("Logger", :error => nil, :warn => nil)
-    Rapns::Daemon.stub(:logger).and_return(logger)
-    @connection.connect
-  end
+describe Rapns::Daemon::Connection, "when write raises an Errno::ETIMEDOUT" do
+  it_should_behave_like "when the write fails"
 
-  it "should raise a DeliveryError when an error is received" do
-    expect { @connection.write("msg with an error") }.should raise_error(Rapns::DeliveryError)
+  def error_type
+    Errno::ETIMEDOUT
   end
+end
 
-  it "should not raise a DeliveryError if the packet cmd value is not 8" do
-    @ssl_socket.stub(:read).and_return([6, 4, 12].pack("ccN"))
-    expect { @connection.write("msg with an error") }.should_not raise_error(Rapns::DeliveryError)
-  end
+describe Rapns::Daemon::Connection, "when write raises an OpenSSL::SSL::SSLError" do
+  it_should_behave_like "when the write fails"
 
-  it "should not raise a DeliveryError if the status code is 0 (no error)" do
-    @ssl_socket.stub(:read).and_return([8, 0, 12].pack("ccN"))
-    expect { @connection.write("msg with an error") }.should_not raise_error(Rapns::DeliveryError)
+  def error_type
+    OpenSSL::SSL::SSLError
   end
+end
 
-  it "should read 6 bytes from the socket" do
-    @ssl_socket.should_receive(:read).with(6).and_return(nil)
-    @connection.write("msg with an error")
+describe Rapns::Daemon::Connection, "when reconnecting" do
+  before do
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
+    @connection.stub(:close)
+    @connection.stub(:connect_socket)
   end
 
-  it "should not attempt to read from the socket if the socket was not selected for reading after the timeout" do
-    IO.stub(:select).and_return(nil)
-    @ssl_socket.should_not_receive(:read)
-    @connection.write("msg with an error")
+  it 'closes the socket' do
+    @connection.should_receive(:close)
+    @connection.send(:reconnect)
   end
 
-  it "should not raise a DeliveryError if the socket read returns nothing" do
-    @ssl_socket.stub(:read).with(6).and_return(nil)
-    expect { @connection.write("msg with an error") }.should_not raise_error(Rapns::DeliveryError)
+  it 'connects the socket' do
+    @connection.should_receive(:connect_socket)
+    @connection.send(:reconnect)
   end
+end
 
-  it "should close the socket after handling the error" do
-    @connection.should_receive(:close)
-    begin
-      @connection.write("msg with an error")
-    rescue Rapns::DeliveryError
-    end
+describe Rapns::Daemon::Connection, "when sending a notification" do
+  before do
+    @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
+    @ssl_socket = mock("SSLSocket", :write => nil, :flush => nil, :close => nil)
+    @tcp_socket = mock("TCPSocket", :close => nil)
+    @connection.stub(:setup_ssl_context)
+    @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
+    @connection.connect
   end
 
-  it "should reconnect the socket" do
-    @connection.should_receive(:connect_socket)
-    begin
-      @connection.write("msg with an error")
-    rescue Rapns::DeliveryError
-    end
+  it "should write the data to the SSL socket" do
+    @ssl_socket.should_receive(:write).with("blah")
+    @connection.write("blah")
   end
 
-  it "should log that the connection is being reconnected" do
-    Rapns::Daemon.logger.should_receive(:error).with("[Connection 1] Error received, reconnecting...")
-    begin
-      @connection.write("msg with an error")
-    rescue Rapns::DeliveryError
-    end
+  it "should flush the SSL socket" do
+    @ssl_socket.should_receive(:flush)
+    @connection.write("blah")
   end
 end

data/spec/rapns/daemon/delivery_handler_pool_spec.rb

@@ -13,14 +13,9 @@ describe Rapns::Daemon::DeliveryHandlerPool do
     @pool.populate
   end
 
-  it "should tell each connection to close when drained" do
+  it "waits for each handle to stop" do
     @pool.populate
     @handler.should_receive(:stop).exactly(3).times
     @pool.drain
   end
-
-  it "should initiate the topping process for each DeliveryHandler before the pool is drained" do
-    Rapns::Daemon.delivery_queue.should_receive(:push).with(0x666).exactly(3).times
-    @pool.drain
-  end
 end

data/spec/rapns/daemon/delivery_handler_spec.rb

@@ -1,115 +1,202 @@
 require "spec_helper"
 
 describe Rapns::Daemon::DeliveryHandler do
+  let(:delivery_handler) { Rapns::Daemon::DeliveryHandler.new(0) }
+
   before do
     @notification = Rapns::Notification.create!(:device_token => "a" * 64)
-    Rapns::Daemon.stub(:delivery_queue).and_return(Rapns::Daemon::DeliveryQueue.new(1))
+    Rapns::Daemon.stub(:delivery_queue).and_return(Rapns::Daemon::DeliveryQueue.new)
     Rapns::Daemon.delivery_queue.push(@notification)
-    @connection = mock("Connection", :connect => nil, :write => nil)
+    @connection = mock("Connection", :connect => nil, :write => nil, :close => nil, :select => nil, :read => nil)
     Rapns::Daemon::Connection.stub(:new).and_return(@connection)
-    @connection_pool = Rapns::Daemon::ConnectionPool.new(1)
-    @connection_pool.populate
-    Rapns::Daemon.stub(:connection_pool).and_return(@connection_pool)
-    @delivery_handler = Rapns::Daemon::DeliveryHandler.new
+    configuration = mock("Configuration", :push => stub(:host => "gateway.push.apple.com", :port => 2195))
+    Rapns::Daemon.stub(:configuration).and_return(configuration)
     @logger = mock("Logger", :error => nil, :info => nil)
     Rapns::Daemon.stub(:logger).and_return(@logger)
   end
 
+  it "instantiates a new connection" do
+    Rapns::Daemon::Connection.should_receive(:new).with('DeliveryHandler 0', 'gateway.push.apple.com', 2195)
+    delivery_handler
+  end
+
+  it "connects the socket when started" do
+    @connection.should_receive(:connect)
+    delivery_handler.start
+    delivery_handler.stop
+  end
+
+  it "pushes a STOP instruction into the queue when told to stop" do
+    Rapns::Daemon.delivery_queue.should_receive(:push).with(Rapns::Daemon::DeliveryHandler::STOP)
+    delivery_handler.stop
+  end
+
+  it "closes the connection when a STOP instruction is received" do
+    Rapns::Daemon.delivery_queue.push(Rapns::Daemon::DeliveryHandler::STOP)
+    delivery_handler.send(:handle_next_notification)
+  end
+
   it "should pop a new notification from the delivery queue" do
     Rapns::Daemon.delivery_queue.should_receive(:pop)
-    @delivery_handler.send(:handle_next_notification)
+    delivery_handler.send(:handle_next_notification)
   end
 
-  it "should claim a connection for the delivery" do
-    Rapns::Daemon.connection_pool.should_receive(:claim_connection)
-    @delivery_handler.send(:handle_next_notification)
+  it "does not attempt to deliver a notification when a STOP instruction is received" do
+    Rapns::Daemon.delivery_queue.pop # empty the queue
+    delivery_handler.should_not_receive(:deliver)
+    Rapns::Daemon.delivery_queue.push(Rapns::Daemon::DeliveryHandler::STOP)
+    delivery_handler.send(:handle_next_notification)
   end
 
   it "should send the binary version of the notification" do
     @notification.stub((:to_binary)).and_return("hi mom")
     @connection.should_receive(:write).with("hi mom")
-    @delivery_handler.send(:handle_next_notification)
+    delivery_handler.send(:handle_next_notification)
   end
 
   it "should log the notification delivery" do
     Rapns::Daemon.logger.should_receive(:info).with("Notification #{@notification.id} delivered to #{@notification.device_token}")
-    @delivery_handler.send(:handle_next_notification)
+    delivery_handler.send(:handle_next_notification)
   end
 
   it "should mark the notification as delivered" do
-    expect { @delivery_handler.send(:handle_next_notification); @notification.reload }.to change(@notification, :delivered).to(true)
+    expect { delivery_handler.send(:handle_next_notification); @notification.reload }.to change(@notification, :delivered).to(true)
   end
 
   it "should set the time the notification was delivered" do
     @notification.delivered_at.should be_nil
-    @delivery_handler.send(:handle_next_notification)
+    delivery_handler.send(:handle_next_notification)
     @notification.reload
     @notification.delivered_at.should be_kind_of(Time)
   end
 
   it "should not trigger validations when saving the notification" do
     @notification.should_receive(:save!).with(:validate => false)
-    @delivery_handler.send(:handle_next_notification)
+    delivery_handler.send(:handle_next_notification)
   end
 
   it "should log if an error is raised when updating the notification" do
     e = StandardError.new("bork!")
     @notification.stub(:save!).and_raise(e)
     Rapns::Daemon.logger.should_receive(:error).with(e)
-    @delivery_handler.send(:handle_next_notification)
+    delivery_handler.send(:handle_next_notification)
   end
 
-  it "should notify the delivery queue a handler is now available" do
-    Rapns::Daemon.delivery_queue.should_receive(:handler_available)
-    @delivery_handler.send(:handle_next_notification)
+  it "should notify the delivery queue the notification has been processed" do
+    Rapns::Daemon.delivery_queue.should_receive(:notification_processed)
+    delivery_handler.send(:handle_next_notification)
   end
 
   describe "when delivery fails" do
     before do
-      @error = Rapns::DeliveryError.new(4, "Missing payload", 1)
-      @connection.stub(:write).and_raise(@error)
+      @connection.stub(:select => true, :read => [8, 4, 69].pack("ccN"), :reconnect => nil)
+      @error = Rapns::DeliveryError.new(4, "Missing payload", 69)
+      Rapns::DeliveryError.stub(:new => @error)
     end
 
     it "should set the notification as not delivered" do
       @notification.should_receive(:delivered=).with(false)
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
     end
 
     it "should set the notification delivered_at timestamp to nil" do
       @notification.should_receive(:delivered_at=).with(nil)
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
     end
 
     it "should set the notification as failed" do
       @notification.should_receive(:failed=).with(true)
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
     end
 
     it "should set the notification failed_at timestamp" do
       now = Time.now
       Time.stub(:now).and_return(now)
       @notification.should_receive(:failed_at=).with(now)
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
     end
 
     it "should set the notification error code" do
       @notification.should_receive(:error_code=).with(4)
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
     end
 
     it "should log the delivery error" do
       Rapns::Daemon.logger.should_receive(:error).with(@error)
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
     end
 
     it "should set the notification error description" do
       @notification.should_receive(:error_description=).with("Missing payload")
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
     end
 
     it "should skip validation when saving the notification" do
       @notification.should_receive(:save!).with(:validate => false)
-      @delivery_handler.send(:handle_next_notification)
+      delivery_handler.send(:handle_next_notification)
+    end
+
+    it "should not raise a DeliveryError if the packet cmd value is not 8" do
+      @connection.stub(:read).and_return([6, 4, 12].pack("ccN"))
+      expect { delivery_handler.send(:handle_next_notification) }.should_not raise_error(Rapns::DeliveryError)
+    end
+
+    it "should not raise a DeliveryError if the status code is 0 (no error)" do
+      @connection.stub(:read).and_return([8, 0, 12].pack("ccN"))
+      expect { delivery_handler.send(:handle_next_notification) }.should_not raise_error(Rapns::DeliveryError)
+    end
+
+    it "should read 6 bytes from the socket" do
+      @connection.should_receive(:read).with(6).and_return(nil)
+      delivery_handler.send(:handle_next_notification)
+    end
+
+    it "should not attempt to read from the socket if the socket was not selected for reading after the timeout" do
+      @connection.stub(:select => nil)
+      @connection.should_not_receive(:read)
+      delivery_handler.send(:handle_next_notification)
+    end
+
+    it "should not raise a DeliveryError if the socket read returns nothing" do
+      @connection.stub(:read).with(6).and_return(nil)
+      expect { delivery_handler.send(:handle_next_notification) }.should_not raise_error(Rapns::DeliveryError)
+    end
+
+    it "should reconnect the socket" do
+      @connection.should_receive(:reconnect)
+      begin
+        delivery_handler.send(:handle_next_notification)
+      rescue Rapns::DeliveryError
+      end
+    end
+
+    it "should log that the connection is being reconnected" do
+      Rapns::Daemon.logger.should_receive(:error).with("[DeliveryHandler 0] Error received, reconnecting...")
+      begin
+        delivery_handler.send(:handle_next_notification)
+      rescue Rapns::DeliveryError
+      end
     end
   end
-end
+end
+
+# describe Rapns::Daemon::Connection, "when receiving an error packet" do
+#   before do
+#     @notification = Rapns::Notification.create!(:device_token => "a" * 64)
+#     @notification.stub(:save!)
+#     @connection = Rapns::Daemon::Connection.new('Connection 0', 'gateway.push.apple.com', 2195)
+#     @ssl_socket = mock("SSLSocket", :write => nil, :flush => nil, :close => nil, :read => [8, 4, @notification.id].pack("ccN"))
+#     @connection.stub(:setup_ssl_context)
+#     @connection.stub(:connect_socket).and_return([@tcp_socket, @ssl_socket])
+#     IO.stub(:select).and_return([@ssl_socket, [], []])
+#     logger = mock("Logger", :error => nil, :warn => nil)
+#     Rapns::Daemon.stub(:logger).and_return(logger)
+#     @connection.connect
+#   end
+# 
+#   it "should raise a DeliveryError when an error is received" do
+#     expect { @connection.write("msg with an error") }.should raise_error(Rapns::DeliveryError)
+#   end
+# 
+
+# end

data/spec/rapns/daemon/delivery_queue_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Rapns::Daemon::DeliveryQueue do
+  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+
+  it 'behaves likes a normal qeue' do
+    obj = stub
+    queue.push obj
+    queue.pop.should == obj
+  end
+
+  it 'returns false if notifications have not all been processed' do
+    queue.push stub
+    queue.notifications_processed?.should be_false
+  end
+
+  it 'returns false if the queue is empty but notifications have not all been processed' do
+    queue.push stub
+    queue.pop
+    queue.notifications_processed?.should be_false
+  end
+
+  it 'returns true if all notifications have been processed' do
+    queue.push stub
+    queue.pop
+    queue.notification_processed
+    queue.notifications_processed?.should be_true
+  end
+end