rpush 1.0.0 → 2.0.0.beta1

data/spec/unit/daemon/apns/feedback_receiver_spec.rb

@@ -1,4 +1,5 @@
-require "unit_spec_helper"
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
 
 describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
 
@@ -7,35 +8,41 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   let(:poll) { 60 }
   let(:certificate) { double }
   let(:password) { double }
-  let(:app) { double(:name => 'my_app', :password => password, :certificate => certificate, :environment => 'production') }
-  let(:connection) { double(:connect => nil, :read => nil, :close => nil) }
-  let(:logger) { double(:error => nil, :info => nil) }
+  let(:app) { double(name: 'my_app', password: password, certificate: certificate, environment: 'production') }
+  let(:connection) { double(connect: nil, read: nil, close: nil) }
+  let(:logger) { double(error: nil, info: nil) }
   let(:receiver) { Rpush::Daemon::Apns::FeedbackReceiver.new(app) }
   let(:feedback) { double }
-  let(:sleeper) { double(Rpush::Daemon::InterruptibleSleep, :sleep => nil, :interrupt_sleep => nil) }
-  let(:store) { double(Rpush::Daemon::Store::ActiveRecord,
-    create_apns_feedback: feedback, release_connection: nil) }
+  let(:sleeper) { double(Rpush::Daemon::InterruptibleSleep, sleep: nil, start: nil, stop: nil) }
+  let(:store) do double(Rpush::Daemon::Store::ActiveRecord,
+                        create_apns_feedback: feedback, release_connection: nil)
+  end
 
   before do
     Rpush.config.feedback_poll = poll
-    Rpush::Daemon::InterruptibleSleep.stub(:new => sleeper)
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::TcpConnection.stub(:new => connection)
+    Rpush::Daemon::InterruptibleSleep.stub(new: sleeper)
+    Rpush.stub(logger: logger)
+    Rpush::Daemon::TcpConnection.stub(new: connection)
     receiver.instance_variable_set("@stop", false)
-    Rpush::Daemon.stub(:store => store)
+    Rpush::Daemon.stub(store: store)
   end
 
   def double_connection_read_with_tuple
     connection.unstub(:read)
 
-    def connection.read(bytes)
-      if !@called
+    def connection.read(*)
+      unless @called
         @called = true
         "N\xE3\x84\r\x00 \x83OxfU\xEB\x9F\x84aJ\x05\xAD}\x00\xAF1\xE5\xCF\xE9:\xC3\xEA\a\x8F\x1D\xA4M*N\xB0\xCE\x17"
       end
     end
   end
 
+  it 'initializes the sleeper with the feedback polling duration' do
+    Rpush::Daemon::InterruptibleSleep.should_receive(:new).with(poll).and_return(sleeper)
+    Rpush::Daemon::Apns::FeedbackReceiver.new(app)
+  end
+
   it 'instantiates a new connection' do
     Rpush::Daemon::TcpConnection.should_receive(:new).with(app, host, port)
     receiver.check_for_feedback
@@ -63,7 +70,7 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   end
 
   it 'creates the feedback' do
-    Rpush::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1323533325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
+    Rpush::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1_323_533_325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
     double_connection_read_with_tuple
     receiver.check_for_feedback
   end
@@ -81,9 +88,9 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
       receiver.stub(:loop).and_yield
     end
 
-    it 'sleeps for the feedback poll period' do
+    it 'sleeps' do
       receiver.stub(:check_for_feedback)
-      sleeper.should_receive(:sleep).with(60).at_least(:once)
+      sleeper.should_receive(:sleep).at_least(:once)
       receiver.start
     end
 
@@ -96,7 +103,7 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   describe 'stop' do
     it 'interrupts sleep when stopped' do
       receiver.stub(:check_for_feedback)
-      sleeper.should_receive(:interrupt_sleep)
+      sleeper.should_receive(:stop)
       receiver.stop
     end
 

data/spec/unit/daemon/app_runner_spec.rb

@@ -1,4 +1,5 @@
 require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
 
 module Rpush
   module AppRunnerSpecService
@@ -11,7 +12,7 @@ module Rpush
       extend ServiceConfigMethods
 
       class ServiceLoop
-        def initialize(app)
+        def initialize(*)
         end
 
         def start
@@ -42,69 +43,63 @@ describe Rpush::Daemon::AppRunner, 'stop' do
 end
 
 describe Rpush::Daemon::AppRunner, 'enqueue' do
-  let(:runner) { double(:enqueue => nil) }
-  let(:notification1) { double(:app_id => 1) }
-  let(:notification2) { double(:app_id => 2) }
-  let(:logger) { double(Rpush::Logger, :error => nil) }
+  let(:runner) { double(enqueue: nil) }
+  let(:notification1) { double(app_id: 1) }
+  let(:notification2) { double(app_id: 2) }
+  let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
-    Rpush.stub(:logger => logger)
+    Rpush.stub(logger: logger)
+    Rpush::Daemon::ProcTitle.stub(:update)
     Rpush::Daemon::AppRunner.runners[1] = runner
+    Rpush::Daemon::AppRunner.runners[2] = runner
   end
 
   after { Rpush::Daemon::AppRunner.runners.clear }
 
-  it 'batches notifications by app' do
-    batch = double.as_null_object
-    Rpush::Daemon::Batch.stub(:new => batch)
-    Rpush::Daemon::Batch.should_receive(:new).with([notification1])
-    Rpush::Daemon::Batch.should_receive(:new).with([notification2])
+  it 'enqueues notifications on each runner' do
+    runner.should_receive(:enqueue).with([notification1])
+    runner.should_receive(:enqueue).with([notification2])
     Rpush::Daemon::AppRunner.enqueue([notification1, notification2])
   end
 
-  it 'enqueues each batch' do
-    runner.should_receive(:enqueue).with(kind_of(Rpush::Daemon::Batch))
-    Rpush::Daemon::AppRunner.enqueue([notification1])
-  end
-
-  it 'logs an error if there is no runner to deliver the notification' do
-    notification1.stub(:app_id => 2, :id => 123)
-    notification2.stub(:app_id => 2, :id => 456)
-    logger.should_receive(:error).with("No such app '#{notification1.app_id}' for notifications 123, 456.")
-    Rpush::Daemon::AppRunner.enqueue([notification1, notification2])
+  it 'syncs the app if a runner does not exist' do
+    Rpush::Daemon::AppRunner.runners[3].should be_nil
+    notification = double(app_id: 3)
+    app = double(Rpush::App, id: 3, connections: 1, service_name: 'app_runner_spec_service', environment: 'sandbox', certificate: TEST_CERT, password: nil, name: 'test')
+    Rpush::Daemon.store = double(app: app)
+    Rpush::Daemon::AppRunner.enqueue([notification])
+    Rpush::Daemon::AppRunner.runners[3].should_not be_nil
   end
 end
 
 describe Rpush::Daemon::AppRunner, 'sync' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :name => 'test') }
-  let(:new_app) { double(Rpush::AppRunnerSpecService::App, :name => 'new_test') }
-  let(:runner) { double(:sync => nil, :stop => nil, :start => nil) }
-  let(:logger) { double(Rpush::Logger, :error => nil, :warn => nil) }
+  let(:app) { double(Rpush::AppRunnerSpecService::App, name: 'test') }
+  let(:new_app) { double(Rpush::AppRunnerSpecService::App, name: 'new_test') }
+  let(:runner) { double(sync: nil, stop: nil, start: nil) }
+  let(:logger) { double(Rpush::Logger, error: nil, warn: nil) }
   let(:queue) { Queue.new }
+  let(:store) { double(all_apps: [app]) }
 
   before do
-    app.stub(:id => 1)
-    new_app.stub(:id => 2)
-    Queue.stub(:new => queue)
+    app.stub(id: 1)
+    new_app.stub(id: 2)
+    Queue.stub(new: queue)
     Rpush::Daemon::AppRunner.runners[app.id] = runner
-    Rpush::App.stub(:all => [app])
-    Rpush.stub(:logger => logger)
+    Rpush.stub(logger: logger)
+    Rpush::Daemon.stub(store: store)
+    Rpush::Daemon::ProcTitle.stub(:update)
   end
 
   after { Rpush::Daemon::AppRunner.runners.clear }
 
-  it 'loads all apps' do
-    Rpush::App.should_receive(:all)
-    Rpush::Daemon::AppRunner.sync
-  end
-
   it 'instructs existing runners to sync' do
     runner.should_receive(:sync).with(app)
     Rpush::Daemon::AppRunner.sync
   end
 
   it 'starts a runner for a new app' do
-    Rpush::App.stub(:all => [app, new_app])
+    store.stub(all_apps: [app, new_app])
     new_runner = double
     Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
     new_runner.should_receive(:start)
@@ -112,13 +107,13 @@ describe Rpush::Daemon::AppRunner, 'sync' do
   end
 
   it 'deletes old runners' do
-    Rpush::App.stub(:all => [])
+    store.stub(all_apps: [])
     runner.should_receive(:stop)
     Rpush::Daemon::AppRunner.sync
   end
 
   it 'logs an error if the runner could not be started' do
-    Rpush::App.stub(:all => [app, new_app])
+    store.stub(all_apps: [app, new_app])
     new_runner = double
     Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
     new_runner.stub(:start).and_raise(StandardError)
@@ -127,7 +122,7 @@ describe Rpush::Daemon::AppRunner, 'sync' do
   end
 
   it 'reflects errors if the runner could not be started' do
-    Rpush::App.stub(:all => [app, new_app])
+    store.stub(all_apps: [app, new_app])
     new_runner = double
     Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
     e = StandardError.new
@@ -138,90 +133,53 @@ describe Rpush::Daemon::AppRunner, 'sync' do
 end
 
 describe Rpush::Daemon::AppRunner, 'debug' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :id => 1, :name => 'test', :connections => 1,
-    :environment => 'development', :certificate => TEST_CERT, :service_name => 'app_runner_spec_service') }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
+  let(:app) do double(Rpush::AppRunnerSpecService::App, id: 1, name: 'test', connections: 1,
+                                                        environment: 'development', certificate: TEST_CERT, service_name: 'app_runner_spec_service')
+  end
+  let(:logger) { double(Rpush::Logger, info: nil) }
+  let(:store) { double(all_apps: [app]) }
 
   before do
-    Rpush::App.stub(:all => [app])
-    Rpush::Daemon.stub(:config => {})
-    Rpush.stub(:logger => logger)
+    Rpush::Daemon.stub(config: {}, store: store)
+    Rpush.stub(logger: logger)
     Rpush::Daemon::AppRunner.sync
   end
 
   after { Rpush::Daemon::AppRunner.runners.clear }
 
   it 'prints debug app states to the log' do
-    Rpush.logger.should_receive(:info).with("\ntest:\n  dispatchers: 1\n  queued: 0\n  batch size: 0\n  batch processed: 0\n  idle: true\n")
+    Rpush.logger.should_receive(:info).with(kind_of(String))
     Rpush::Daemon::AppRunner.debug
   end
 end
 
-describe Rpush::Daemon::AppRunner, 'idle' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :name => 'test', :connections => 1,
-    :environment => 'development', :certificate => TEST_CERT, :id => 1,
-    :service_name => 'app_runner_spec_service') }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
-
-  before do
-    Rpush::App.stub(:all => [app])
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'returns idle runners' do
-    runner = Rpush::Daemon::AppRunner.runners[app.id]
-    Rpush::Daemon::AppRunner.idle.should eq [runner]
-  end
-end
-
-describe Rpush::Daemon::AppRunner, 'wait' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :id => 1, :name => 'test',
-    :connections => 1, :environment => 'development', :certificate => TEST_CERT,
-    :service_name => 'app_runner_spec_service') }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
-
-  before do
-    Rpush::App.stub(:all => [app])
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'waits until all runners are idle' do
-    Rpush::Daemon::AppRunner.runners.count.should eq 1
-    Timeout.timeout(5) { Rpush::Daemon::AppRunner.wait }
-  end
-end
-
 describe Rpush::Daemon::AppRunner do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :environment => :sandbox,
-    :connections => 1, :service_name => 'app_runner_spec_service',
-    :name => 'test') }
+  let(:app) do double(Rpush::AppRunnerSpecService::App, environment: :sandbox,
+                                                        connections: 1, service_name: 'app_runner_spec_service',
+                                                        name: 'test')
+  end
   let(:runner) { Rpush::Daemon::AppRunner.new(app) }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
+  let(:logger) { double(Rpush::Logger, info: nil) }
   let(:queue) { Queue.new }
   let(:dispatcher_loop_collection) { Rpush::Daemon::DispatcherLoopCollection.new }
-  let(:service_loop) { double(Rpush::Daemon::AppRunnerSpecService::ServiceLoop,
-    :start => nil, :stop => nil) }
+  let(:service_loop) do double(Rpush::Daemon::AppRunnerSpecService::ServiceLoop,
+                               start: nil, stop: nil)
+  end
   let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil) }
 
   before do
     Rpush::Daemon.stub(store: store)
-    Rpush::Daemon::AppRunnerSpecService::ServiceLoop.stub(:new => service_loop)
-    Queue.stub(:new => queue)
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::DispatcherLoopCollection.stub(:new => dispatcher_loop_collection)
+    Rpush::Daemon::AppRunnerSpecService::ServiceLoop.stub(new: service_loop)
+    Queue.stub(new: queue)
+    Rpush.stub(logger: logger)
+    Rpush::Daemon::DispatcherLoopCollection.stub(new: dispatcher_loop_collection)
   end
 
   describe 'start' do
     it 'starts a delivery dispatcher for each connection' do
-      app.stub(:connections => 2)
+      app.stub(connections: 2)
       runner.start
-      runner.num_dispatchers.should eq 2
+      runner.num_dispatcher_loops.should eq 2
     end
 
     it 'starts the loops' do
@@ -232,16 +190,18 @@ describe Rpush::Daemon::AppRunner do
 
   describe 'enqueue' do
     let(:notification) { double }
-    let(:batch) { double(:notifications => [notification]) }
 
     it 'enqueues the batch' do
-      queue.should_receive(:push).with([notification, batch])
-      runner.enqueue(batch)
+      queue.should_receive(:push) do |queue_payload|
+        queue_payload.notification.should eq notification
+        queue_payload.batch.should_not be_nil
+      end
+      runner.enqueue([notification])
     end
 
     it 'reflects the notification has been enqueued' do
       runner.should_receive(:reflect).with(:notification_enqueued, notification)
-      runner.enqueue(batch)
+      runner.enqueue([notification])
     end
   end
 
@@ -259,34 +219,17 @@ describe Rpush::Daemon::AppRunner do
     end
   end
 
-  describe 'idle?' do
-    it 'is idle if all notifications have been processed' do
-      runner.batch = double(:complete? => true)
-      runner.idle?.should be_true
-    end
-
-    it 'is idle if the runner has no associated batch' do
-      runner.batch = nil
-      runner.idle?.should be_true
-    end
-
-    it 'is not idle if not all notifications have been processed' do
-      runner.batch = double(:complete? => false)
-      runner.idle?.should be_false
-    end
-  end
-
   describe 'sync' do
     before { runner.start }
 
     it 'reduces the number of dispatchers if needed' do
-      app.stub(:connections => 0)
-      expect { runner.sync(app) }.to change(runner, :num_dispatchers).to(0)
+      app.stub(connections: 0)
+      expect { runner.sync(app) }.to change(runner, :num_dispatcher_loops).to(0)
     end
 
     it 'increases the number of dispatchers if needed' do
-      app.stub(:connections => 2)
-      expect { runner.sync(app) }.to change(runner, :num_dispatchers).to(2)
+      app.stub(connections: 2)
+      expect { runner.sync(app) }.to change(runner, :num_dispatcher_loops).to(2)
     end
   end
 end

data/spec/unit/daemon/batch_spec.rb

@@ -1,23 +1,15 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Batch do
-  let(:notification1) { double(:notification1, :id => 1) }
-  let(:notification2) { double(:notification2, :id => 2) }
+  let(:notification1) { double(:notification1, id: 1) }
+  let(:notification2) { double(:notification2, id: 2) }
   let(:batch) { Rpush::Daemon::Batch.new([notification1, notification2]) }
   let(:store) { double.as_null_object }
   let(:time) { Time.now }
 
   before do
-    Time.stub(:now => time)
-    Rpush::Daemon.stub(:store => store)
-  end
-
-  it 'exposes the notifications' do
-    batch.notifications.should eq [notification1, notification2]
-  end
-
-  it 'exposes the number notifications' do
-    batch.num_notifications.should eq 2
+    Time.stub(now: time)
+    Rpush::Daemon.stub(store: store)
   end
 
   it 'exposes the number notifications processed' do
@@ -25,125 +17,85 @@ describe Rpush::Daemon::Batch do
   end
 
   it 'increments the processed notifications count' do
-    expect { batch.notification_dispatched }.to change(batch, :num_processed).to(1)
+    expect { batch.notification_processed }.to change(batch, :num_processed).to(1)
   end
 
   it 'completes the batch when all notifications have been processed' do
     batch.should_receive(:complete)
-    2.times { batch.notification_dispatched }
-  end
-
-  it 'can be described' do
-    batch.describe.should eq '1, 2'
+    2.times { batch.notification_processed }
   end
 
   describe 'mark_delivered' do
-    describe 'batching is disabled' do
-      before { Rpush.config.batch_storage_updates = false }
-
-      it 'marks the notification as delivered immediately' do
-        store.should_receive(:mark_delivered).with(notification1, time)
-        batch.mark_delivered(notification1)
-      end
-
-      it 'reflects the notification was delivered' do
-        batch.should_receive(:reflect).with(:notification_delivered, notification1)
-        batch.mark_delivered(notification1)
-      end
+    it 'marks the notification as delivered immediately without persisting' do
+      store.should_receive(:mark_delivered).with(notification1, time, persist: false)
+      batch.mark_delivered(notification1)
     end
 
-    describe 'batching is enabled' do
-      before { Rpush.config.batch_storage_updates = true }
+    it 'defers persisting' do
+      batch.mark_delivered(notification1)
+      batch.delivered.should eq [notification1]
+    end
+  end
 
-      it 'marks the notification as delivered immediately without persisting' do
-        store.should_receive(:mark_delivered).with(notification1, time, :persist => false)
-        batch.mark_delivered(notification1)
-      end
+  describe 'mark_all_delivered' do
+    it 'marks the notifications as delivered immediately without persisting' do
+      store.should_receive(:mark_delivered).with(notification1, time, persist: false)
+      store.should_receive(:mark_delivered).with(notification2, time, persist: false)
+      batch.mark_all_delivered
+    end
 
-      it 'defers persisting' do
-        batch.mark_delivered(notification1)
-        batch.delivered.should eq [notification1]
-      end
+    it 'defers persisting' do
+      batch.mark_all_delivered
+      batch.delivered.should eq [notification1, notification2]
     end
   end
 
   describe 'mark_failed' do
-    describe 'batching is disabled' do
-      before { Rpush.config.batch_storage_updates = false }
-
-      it 'marks the notification as failed' do
-        store.should_receive(:mark_failed).with(notification1, 1, 'an error', time)
-        batch.mark_failed(notification1, 1, 'an error')
-      end
-
-      it 'reflects the notification failed' do
-        batch.should_receive(:reflect).with(:notification_delivered, notification1)
-        batch.mark_delivered(notification1)
-      end
+    it 'marks the notification as failed without persisting' do
+      store.should_receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)
+      batch.mark_failed(notification1, 1, 'an error')
     end
 
-    describe 'batching is enabled' do
-      before { Rpush.config.batch_storage_updates = true }
+    it 'defers persisting' do
+      batch.mark_failed(notification1, 1, 'an error')
+      batch.failed.should eq([1, 'an error'] => [notification1])
+    end
+  end
 
-      it 'marks the notification as failed without persisting' do
-        store.should_receive(:mark_failed).with(notification1, 1, 'an error', time, :persist => false)
-        batch.mark_failed(notification1, 1, 'an error')
-      end
+  describe 'mark_failed' do
+    it 'marks the notification as failed without persisting' do
+      store.should_receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)
+      store.should_receive(:mark_failed).with(notification2, 1, 'an error', time, persist: false)
+      batch.mark_all_failed(1, 'an error')
+    end
 
-      it 'defers persisting' do
-        Rpush.config.batch_storage_updates = true
-        batch.mark_failed(notification1, 1, 'an error')
-        batch.failed.should eq({[1, 'an error'] => [notification1]})
-      end
+    it 'defers persisting' do
+      batch.mark_all_failed(1, 'an error')
+      batch.failed.should eq([1, 'an error'] => [notification1, notification2])
     end
   end
 
   describe 'mark_retryable' do
-    describe 'batching is disabled' do
-      before { Rpush.config.batch_storage_updates = false }
-
-      it 'marks the notification as retryable' do
-        store.should_receive(:mark_retryable).with(notification1, time)
-        batch.mark_retryable(notification1, time)
-      end
-
-      it 'reflects the notification will be retried' do
-        batch.should_receive(:reflect).with(:notification_will_retry, notification1)
-        batch.mark_retryable(notification1, time)
-      end
+    it 'marks the notification as retryable without persisting' do
+      store.should_receive(:mark_retryable).with(notification1, time, persist: false)
+      batch.mark_retryable(notification1, time)
     end
 
-    describe 'batching is enabled' do
-      before { Rpush.config.batch_storage_updates = true }
-
-      it 'marks the notification as retryable without persisting' do
-        store.should_receive(:mark_retryable).with(notification1, time, :persist => false)
-        batch.mark_retryable(notification1, time)
-      end
-
-      it 'defers persisting' do
-        batch.mark_retryable(notification1, time)
-        batch.retryable.should eq({time => [notification1]})
-      end
+    it 'defers persisting' do
+      batch.mark_retryable(notification1, time)
+      batch.retryable.should eq(time => [notification1])
     end
   end
 
   describe 'complete' do
     before do
-      Rpush.config.batch_storage_updates = true
-      Rpush.stub(:logger => double.as_null_object)
+      Rpush.stub(logger: double.as_null_object)
       batch.stub(:reflect)
     end
 
-    it 'clears the notifications' do
-      expect do
-        2.times { batch.notification_dispatched }
-      end.to change(batch, :notifications).to([])
-    end
-
     it 'identifies as complete' do
       expect do
-        2.times { batch.notification_dispatched }
+        2.times { batch.notification_processed }
       end.to change(batch, :complete?).to(be_true)
     end
 
@@ -151,14 +103,14 @@ describe Rpush::Daemon::Batch do
       e = StandardError.new
       batch.stub(:complete_delivered).and_raise(e)
       batch.should_receive(:reflect).with(:error, e)
-      2.times { batch.notification_dispatched }
+      2.times { batch.notification_processed }
     end
 
     describe 'delivered' do
       def complete
         [notification1, notification2].each do |n|
           batch.mark_delivered(n)
-          batch.notification_dispatched
+          batch.notification_processed
         end
       end
 
@@ -172,18 +124,13 @@ describe Rpush::Daemon::Batch do
         batch.should_receive(:reflect).with(:notification_delivered, notification2)
         complete
       end
-
-      it 'clears the delivered notifications' do
-        complete
-        batch.delivered.should eq([])
-      end
     end
 
     describe 'failed' do
       def complete
         [notification1, notification2].each do |n|
           batch.mark_failed(n, 1, 'an error')
-          batch.notification_dispatched
+          batch.notification_processed
         end
       end
 
@@ -197,18 +144,13 @@ describe Rpush::Daemon::Batch do
         batch.should_receive(:reflect).with(:notification_failed, notification2)
         complete
       end
-
-      it 'clears the failed notifications' do
-        complete
-        batch.failed.should eq({})
-      end
     end
 
     describe 'retryable' do
       def complete
         [notification1, notification2].each do |n|
           batch.mark_retryable(n, time)
-          batch.notification_dispatched
+          batch.notification_processed
         end
       end
 
@@ -222,11 +164,6 @@ describe Rpush::Daemon::Batch do
         batch.should_receive(:reflect).with(:notification_will_retry, notification2)
         complete
       end
-
-      it 'clears the retryable notifications' do
-        complete
-        batch.retryable.should eq({})
-      end
     end
   end
 end