rpush 7.0.1 → 9.0.0

data/spec/functional/apns_spec.rb

@@ -1,162 +0,0 @@
-require 'functional_spec_helper'
-
-describe 'APNs' do
-  let(:app) { create_app }
-  let(:tcp_socket) { double(TCPSocket, setsockopt: nil, close: nil) }
-  let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil, write: nil, flush: nil, read: nil, close: nil) }
-  let(:io_double) { double(select: nil) }
-  let(:delivered_ids) { [] }
-  let(:failed_ids) { [] }
-  let(:retry_ids) { [] }
-
-  before do
-    Rpush.config.push_poll = 0.5
-    stub_tcp_connection(tcp_socket, ssl_socket, io_double)
-  end
-
-  def create_app
-    app = Rpush::Apns::App.new
-    app.certificate = TEST_CERT
-    app.name = 'test'
-    app.environment = 'sandbox'
-    app.save!
-    app
-  end
-
-  def create_notification
-    notification = Rpush::Apns::Notification.new
-    notification.app = app
-    notification.alert = 'test'
-    notification.device_token = 'a' * 108
-    notification.save!
-    notification
-  end
-
-  def wait
-    sleep 0.1
-  end
-
-  def wait_for_notification_to_deliver(notification)
-    timeout { wait until delivered_ids.include?(notification.id) }
-  end
-
-  def wait_for_notification_to_fail(notification)
-    timeout { wait until failed_ids.include?(notification.id) }
-  end
-
-  def wait_for_notification_to_retry(notification)
-    timeout { wait until retry_ids.include?(notification.id) }
-  end
-
-  def fail_notification(notification)
-    allow(ssl_socket).to receive_messages(read: [8, 4, notification.id].pack('ccN'))
-    enable_io_select
-  end
-
-  def enable_io_select
-    called = false
-    allow(io_double).to receive(:select) do
-      if called
-        nil
-      else
-        called = true
-      end
-    end
-  end
-
-  it 'delivers a notification successfully' do
-    notification = create_notification
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
-  end
-
-  it 'receives feedback' do
-    app
-    tuple = "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"
-    allow(ssl_socket).to receive(:read).and_return(tuple, nil)
-    Rpush.apns_feedback
-    feedback = Rpush::Apns::Feedback.all.first
-    expect(feedback).not_to be_nil
-    expect(feedback.app_id).to eq(app.id)
-    expect(feedback.device_token).to eq('834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17')
-  end
-
-  describe 'delivery failures' do
-    before do
-      Rpush.reflect do |on|
-        on.notification_delivered do |n|
-          delivered_ids << n.id
-        end
-
-        on.notification_id_failed do |_, n_id|
-          failed_ids << n_id
-        end
-
-        on.notification_id_will_retry do |_, n_id|
-          retry_ids << n_id
-        end
-
-        on.notification_will_retry do |n|
-          retry_ids << n.id
-        end
-      end
-
-      Rpush.embed
-    end
-
-    after do
-      Rpush.reflection_stack.clear
-      Rpush.reflection_stack.push(Rpush::ReflectionCollection.new)
-
-      timeout { Rpush.shutdown }
-    end
-
-    it 'fails to deliver a notification' do
-      notification = create_notification
-      wait_for_notification_to_deliver(notification)
-      fail_notification(notification)
-      wait_for_notification_to_fail(notification)
-    end
-
-    describe 'with a failed connection' do
-      it 'retries all notifications' do
-        allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(sleep: nil)
-        expect(ssl_socket).to receive(:write).at_least(1).times.and_raise(Errno::EPIPE)
-        notifications = 2.times.map { create_notification }
-        notifications.each { |n| wait_for_notification_to_retry(n) }
-      end
-    end
-
-    describe 'with multiple notifications' do
-      let(:notification1) { create_notification }
-      let(:notification2) { create_notification }
-      let(:notification3) { create_notification }
-      let(:notification4) { create_notification }
-      let(:notifications) { [notification1, notification2, notification3, notification4] }
-
-      it 'marks the correct notification as failed' do
-        notifications.each { |n| wait_for_notification_to_deliver(n) }
-        fail_notification(notification2)
-        wait_for_notification_to_fail(notification2)
-      end
-
-      it 'does not mark prior notifications as failed' do
-        notifications.each { |n| wait_for_notification_to_deliver(n) }
-        fail_notification(notification2)
-        wait_for_notification_to_fail(notification2)
-
-        expect(failed_ids).to_not include(notification1.id)
-        notification1.reload
-        expect(notification1.delivered).to eq(true)
-      end
-
-      it 'marks notifications following the failed one as retryable' do
-        notifications.each { |n| wait_for_notification_to_deliver(n) }
-        fail_notification(notification2)
-        [notification3, notification4].each { |n| wait_for_notification_to_retry(n) }
-      end
-    end
-  end
-end

data/spec/functional/gcm_spec.rb

@@ -1,46 +0,0 @@
-require 'functional_spec_helper'
-
-describe 'GCM' do
-  let(:app) { Rpush::Gcm::App.new }
-  let(:notification) { Rpush::Gcm::Notification.new }
-  let(:response) { double(Net::HTTPResponse, code: 200) }
-  let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
-
-  before do
-    app.name = 'test'
-    app.auth_key = 'abc123'
-    app.save!
-
-    notification.app_id = app.id
-    notification.registration_ids = ['foo']
-    notification.data = { message: 'test' }
-    notification.save!
-
-    allow(Net::HTTP::Persistent).to receive_messages(new: http)
-  end
-
-  it 'delivers a notification successfully' do
-    allow(response).to receive_messages(body: JSON.dump(results: [{ message_id: notification.registration_ids.first.to_s }]))
-
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
-  end
-
-  it 'fails to deliver a notification successfully' do
-    allow(response).to receive_messages(body: JSON.dump(results: [{ error: 'Err' }]))
-    Rpush.push
-    notification.reload
-    expect(notification.delivered).to eq(false)
-  end
-
-  it 'retries notification that fail due to a SocketError' do
-    expect(http).to receive(:request).and_raise(SocketError.new)
-    expect(notification.deliver_after).to be_nil
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :deliver_after).to(kind_of(Time))
-  end
-end

data/spec/functional/new_app_spec.rb

@@ -1,44 +0,0 @@
-require 'functional_spec_helper'
-
-describe 'New app loading' do
-  let(:timeout) { 10 }
-  let(:app) { create_app }
-  let(:tcp_socket) { double(TCPSocket, setsockopt: nil, close: nil) }
-  let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil, write: nil, flush: nil, read: nil, close: nil) }
-  let(:io_double) { double(select: nil) }
-
-  before do
-    stub_tcp_connection
-  end
-
-  def create_app
-    app = Rpush::Apns::App.new
-    app.certificate = TEST_CERT
-    app.name = 'test'
-    app.environment = 'sandbox'
-    app.save!
-    app
-  end
-
-  def create_notification
-    notification = Rpush::Apns::Notification.new
-    notification.app = app
-    notification.alert = 'test'
-    notification.device_token = 'a' * 108
-    notification.save!
-    notification
-  end
-
-  def stub_tcp_connection
-    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(connect_socket: [tcp_socket, ssl_socket])
-    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(setup_ssl_context: double.as_null_object)
-    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
-  end
-
-  it 'delivers a notification successfully' do
-    notification = create_notification
-    Rpush.push
-    notification.reload
-    expect(notification.delivered).to eq(true)
-  end
-end

data/spec/unit/apns_feedback_spec.rb

@@ -1,39 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush, 'apns_feedback' do
-  let!(:apns_app) { Rpush::Apns::App.create!(apns_app_params) }
-  let(:apns_app_params) do
-    {
-      name: 'test',
-      environment: 'production',
-      certificate: TEST_CERT
-    }
-  end
-  let!(:gcm_app) { Rpush::Gcm::App.create!(name: 'MyApp', auth_key: 'abc123') }
-
-  let(:receiver) { double(check_for_feedback: nil) }
-
-  before do
-    allow(Rpush::Daemon::Apns::FeedbackReceiver).to receive(:new) { receiver }
-  end
-
-  it 'initializes the daemon' do
-    expect(Rpush::Daemon).to receive(:common_init)
-    Rpush.apns_feedback
-  end
-
-  it 'checks feedback for each app' do
-    expect(Rpush::Daemon::Apns::FeedbackReceiver).to receive(:new).with(apns_app).and_return(receiver)
-    expect(receiver).to receive(:check_for_feedback)
-    Rpush.apns_feedback
-  end
-
-  context 'feedback disabled' do
-    let(:apns_app_params) { super().merge(feedback_enabled: false) }
-
-    it 'does not initialize feedback receiver' do
-      expect(Rpush::Daemon::Apns::FeedbackReceiver).not_to receive(:new)
-      Rpush.apns_feedback
-    end
-  end
-end

data/spec/unit/client/active_record/gcm/notification_spec.rb

@@ -1,14 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Client::ActiveRecord::Gcm::Notification do
-  it_behaves_like 'Rpush::Client::Gcm::Notification'
-  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
-
-  subject(:notification) { described_class.new }
-  let(:app) { Rpush::Gcm::App.create!(name: 'test', auth_key: 'abc') }
-
-  it 'accepts non-booleans as a truthy value' do
-    notification.dry_run = 'Not a boolean'
-    expect(notification.as_json['dry_run']).to eq true
-  end
-end if active_record?

data/spec/unit/client/redis/gcm/app_spec.rb

@@ -1,5 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Client::Redis::Gcm::App do
-  it_behaves_like 'Rpush::Client::Gcm::App'
-end if redis?

data/spec/unit/client/redis/gcm/notification_spec.rb

@@ -1,5 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Client::Redis::Gcm::Notification do
-  it_behaves_like 'Rpush::Client::Gcm::Notification'
-end if redis?

data/spec/unit/client/shared/gcm/app.rb

@@ -1,4 +0,0 @@
-require 'unit_spec_helper'
-
-shared_examples 'Rpush::Client::Gcm::App' do
-end

data/spec/unit/client/shared/gcm/notification.rb

@@ -1,77 +0,0 @@
-require 'unit_spec_helper'
-
-shared_examples 'Rpush::Client::Gcm::Notification' do
-  let(:app) { Rpush::Gcm::App.create!(name: 'test', auth_key: 'abc') }
-  let(:notification) { described_class.new }
-
-  it "has a 'data' payload limit of 4096 bytes" do
-    notification.data = { key: "a" * 4096 }
-    expect(notification.valid?).to be_falsey
-    expect(notification.errors[:base]).to eq ["Notification payload data cannot be larger than 4096 bytes."]
-  end
-
-  it 'limits the number of registration ids to 1000' do
-    notification.registration_ids = ['a'] * (1000 + 1)
-    expect(notification.valid?).to be_falsey
-    expect(notification.errors[:base]).to eq ["Number of registration_ids cannot be larger than 1000."]
-  end
-
-  it 'validates expiry is present if collapse_key is set' do
-    notification.collapse_key = 'test'
-    notification.expiry = nil
-    expect(notification.valid?).to be_falsey
-    expect(notification.errors[:expiry]).to eq ['must be set when using a collapse_key']
-  end
-
-  it 'includes time_to_live in the payload' do
-    notification.expiry = 100
-    expect(notification.as_json['time_to_live']).to eq 100
-  end
-
-  it 'includes content_available in the payload' do
-    notification.content_available = true
-    expect(notification.as_json['content_available']).to eq true
-  end
-
-  it 'includes mutable_content in the payload' do
-    notification.mutable_content = true
-    expect(notification.as_json['mutable_content']).to eq true
-  end
-
-  it 'sets the priority to high when set to high' do
-    notification.priority = 'high'
-    expect(notification.as_json['priority']).to eq 'high'
-  end
-
-  it 'sets the priority to normal when set to normal' do
-    notification.priority = 'normal'
-    expect(notification.as_json['priority']).to eq 'normal'
-  end
-
-  it 'validates the priority is either "normal" or "high"' do
-    notification.priority = 'invalid'
-    expect(notification.errors[:priority]).to eq ['must be one of either "normal" or "high"']
-  end
-
-  it 'excludes the priority if it is not defined' do
-    expect(notification.as_json).not_to have_key 'priority'
-  end
-
-  it 'includes the notification payload if defined' do
-    notification.notification = { key: 'any key is allowed' }
-    expect(notification.as_json).to have_key 'notification'
-  end
-
-  it 'excludes the notification payload if undefined' do
-    expect(notification.as_json).not_to have_key 'notification'
-  end
-
-  it 'includes the dry_run payload if defined' do
-    notification.dry_run = true
-    expect(notification.as_json['dry_run']).to eq true
-  end
-
-  it 'excludes the dry_run payload if undefined' do
-    expect(notification.as_json).not_to have_key 'dry_run'
-  end
-end

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

@@ -1,108 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Daemon::Apns::Delivery do
-  let(:app) { double(name: 'MyApp') }
-  let(:notification1) { double.as_null_object }
-  let(:notification2) { double.as_null_object }
-  let(:batch) { double(mark_all_failed: nil, mark_all_delivered: nil, all_processed: nil) }
-  let(:logger) { double(error: nil, info: nil) }
-  let(:connection) { double(select: false, write: nil, reconnect: nil, close: nil, connect: nil) }
-  let(:delivery) { Rpush::Daemon::Apns::Delivery.new(app, connection, batch) }
-
-  before do
-    allow(batch).to receive(:each_notification) do |&blk|
-      [notification1, notification2].each(&blk)
-    end
-    allow(Rpush).to receive_messages(logger: logger)
-  end
-
-  it 'writes the binary batch' do
-    allow(notification1).to receive_messages(to_binary: 'binary1')
-    allow(notification2).to receive_messages(to_binary: 'binary2')
-    expect(connection).to receive(:write).with('binary1binary2')
-    delivery.perform
-  end
-
-  it 'logs the notification deliveries' do
-    allow(notification1).to receive_messages(id: 666, device_token: 'abc123')
-    allow(notification2).to receive_messages(id: 42, device_token: 'abc456')
-    expect(logger).to receive(:info).with('[MyApp] 666 sent to abc123')
-    expect(logger).to receive(:info).with('[MyApp] 42 sent to abc456')
-    delivery.perform
-  end
-
-  it 'marks all notifications as delivered' do
-    expect(delivery).to receive(:mark_batch_delivered)
-    delivery.perform
-  end
-
-  it 'notifies the batch all notifications have been processed' do
-    expect(batch).to receive(:all_processed)
-    delivery.perform
-  end
-
-  describe 'when an error is raised' do
-    it 'marks all notifications as failed' do
-      error = StandardError.new
-      allow(connection).to receive(:write).and_raise(error)
-      expect(delivery).to receive(:mark_batch_failed).with(error)
-      expect { delivery.perform }.to raise_error(error)
-    end
-  end
-
-  # describe "when delivery fails" do
-  #   before { connection.stub(select: true, read: [8, 4, 69].pack("ccN")) }
-  #
-  #   it "marks the notification as failed" do
-  #     delivery.should_receive(:mark_failed).with(4, "Unable to deliver notification 69, received error 4 (Missing payload)")
-  #     perform
-  #   end
-  #
-  #   it "logs the delivery error" do
-  #     # checking for the doublebed error doesn't work in jruby, but checking
-  #     # for the exception by class does.
-  #
-  #     # error = Rpush::DeliveryError.new(4, 12, "Missing payload")
-  #     # Rpush::DeliveryError.stub(new: error)
-  #     # expect { delivery.perform }.to raise_error(error)
-  #
-  #     expect { delivery.perform }.to raise_error(Rpush::DeliveryError)
-  #   end
-  #
-  #   it "reads 6 bytes from the socket" do
-  #     connection.should_receive(:read).with(6).and_return(nil)
-  #     perform
-  #   end
-  #
-  #   it "does 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)
-  #     perform
-  #   end
-  #
-  #   it "reconnects the socket" do
-  #     connection.should_receive(:reconnect)
-  #     perform
-  #   end
-  #
-  #   it "logs that the connection is being reconnected" do
-  #     Rpush.logger.should_receive(:error).with("[MyApp] Error received, reconnecting...")
-  #     perform
-  #   end
-  #
-  #   context "when the APNs disconnects without returning an error" do
-  #     before do
-  #       connection.stub(read: nil)
-  #     end
-  #
-  #     it 'raises a DisconnectError error if the connection is closed without an error being returned' do
-  #       expect { delivery.perform }.to raise_error(Rpush::DisconnectionError)
-  #     end
-  #
-  #     it 'marks the notification as failed' do
-  #       delivery.should_receive(:mark_failed).with(nil, "The APNs disconnected without returning an error. This may indicate you are using an invalid certificate for the host.")
-  #       perform
-  #     end
-  #   end
-  # end
-end

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

@@ -1,137 +0,0 @@
-require 'unit_spec_helper'
-require 'rpush/daemon/store/active_record'
-
-describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
-  let(:host) { 'feedback.push.apple.com' }
-  let(:port) { 2196 }
-  let(:frequency) { 60 }
-  let(:certificate) { double }
-  let(:password) { double }
-  let(:feedback_enabled) { true }
-  let(:app) do
-    double(
-      name: 'my_app',
-      password: password,
-      certificate: certificate,
-      feedback_enabled: feedback_enabled,
-      environment: 'production'
-    )
-  end
-  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, stop: nil) }
-  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, create_apns_feedback: feedback, release_connection: nil) }
-
-  before do
-    Rpush.config.apns.feedback_receiver.frequency = frequency
-    allow(Rpush::Daemon::InterruptibleSleep).to receive_messages(new: sleeper)
-    allow(Rpush).to receive_messages(logger: logger)
-    allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection)
-    receiver.instance_variable_set("@stop", false)
-    allow(Rpush::Daemon).to receive_messages(store: store)
-  end
-
-  def double_connection_read_with_tuple
-    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 frequency' do
-    expect(Rpush::Daemon::InterruptibleSleep).to receive_messages(new: sleeper)
-    Rpush::Daemon::Apns::FeedbackReceiver.new(app)
-  end
-
-  it 'instantiates a new connection' do
-    expect(Rpush::Daemon::TcpConnection).to receive(:new).with(app, host, port)
-    receiver.check_for_feedback
-  end
-
-  it 'connects to the feeback service' do
-    expect(connection).to receive(:connect)
-    receiver.check_for_feedback
-  end
-
-  it 'closes the connection' do
-    expect(connection).to receive(:close)
-    receiver.check_for_feedback
-  end
-
-  it 'reads from the connection' do
-    expect(connection).to receive(:read).with(38)
-    receiver.check_for_feedback
-  end
-
-  it 'logs the feedback' do
-    double_connection_read_with_tuple
-    expect(Rpush.logger).to receive(:info).with("[my_app] [FeedbackReceiver] Delivery failed at 2011-12-10 16:08:45 UTC for 834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17.")
-    receiver.check_for_feedback
-  end
-
-  it 'creates the feedback' do
-    expect(Rpush::Daemon.store).to receive(:create_apns_feedback).with(Time.at(1_323_533_325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
-    double_connection_read_with_tuple
-    receiver.check_for_feedback
-  end
-
-  it 'logs errors' do
-    error = StandardError.new('bork!')
-    allow(connection).to receive(:read).and_raise(error)
-    expect(Rpush.logger).to receive(:error).with(error)
-    receiver.check_for_feedback
-  end
-
-  describe 'start' do
-    before do
-      allow(Thread).to receive(:new).and_yield
-      allow(receiver).to receive(:loop).and_yield
-    end
-
-    it 'sleeps' do
-      allow(receiver).to receive(:check_for_feedback)
-      expect(sleeper).to receive(:sleep).at_least(:once)
-      receiver.start
-    end
-
-    it 'checks for feedback when started' do
-      expect(receiver).to receive(:check_for_feedback).at_least(:once)
-      receiver.start
-    end
-
-    context 'with feedback_enabled false' do
-      let(:feedback_enabled) { false }
-
-      it 'does not check for feedback when started' do
-        expect(receiver).not_to receive(:check_for_feedback)
-        receiver.start
-      end
-    end
-  end
-
-  describe 'stop' do
-    it 'interrupts sleep when stopped' do
-      allow(receiver).to receive(:check_for_feedback)
-      expect(sleeper).to receive(:stop)
-      receiver.stop
-    end
-
-    it 'releases the store connection' do
-      allow(Thread).to receive(:new).and_yield
-      allow(receiver).to receive(:loop).and_yield
-      expect(Rpush::Daemon.store).to receive(:release_connection)
-      receiver.start
-      receiver.stop
-    end
-  end
-
-  it 'reflects feedback was received' do
-    double_connection_read_with_tuple
-    expect(receiver).to receive(:reflect).with(:apns_feedback, feedback)
-    receiver.check_for_feedback
-  end
-end

data/spec/unit/daemon/dispatcher/tcp_spec.rb

@@ -1,32 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Daemon::Dispatcher::Tcp do
-  let(:app) { double }
-  let(:delivery) { double(perform: nil) }
-  let(:delivery_class) { double(new: delivery) }
-  let(:notification) { double }
-  let(:batch) { double }
-  let(:connection) { double(Rpush::Daemon::TcpConnection, connect: nil) }
-  let(:host) { 'localhost' }
-  let(:port) { 1234 }
-  let(:host_proc) { proc { [host, port] } }
-  let(:queue_payload) { Rpush::Daemon::QueuePayload.new(batch, notification) }
-  let(:dispatcher) { Rpush::Daemon::Dispatcher::Tcp.new(app, delivery_class, host: host_proc) }
-
-  before { allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection) }
-
-  describe 'dispatch' do
-    it 'delivers the notification' do
-      expect(delivery_class).to receive(:new).with(app, connection, notification, batch).and_return(delivery)
-      expect(delivery).to receive(:perform)
-      dispatcher.dispatch(queue_payload)
-    end
-  end
-
-  describe 'cleanup' do
-    it 'closes the connection' do
-      expect(connection).to receive(:close)
-      dispatcher.cleanup
-    end
-  end
-end