rpush_extended 3.2.5

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

@@ -0,0 +1,176 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Wns::Delivery do
+  let(:app) { Rpush::Wns::App.create!(name: "MyApp", client_id: "someclient", client_secret: "somesecret", access_token: "access_token", access_token_expiration: Time.now + (60 * 10)) }
+  let(:notification) { Rpush::Wns::Notification.create!(app: app, data: { title: "MyApp", body: "Example notification", param: "/param1" }, uri: "http://some.example/", deliver_after: Time.now) }
+  let(:logger) { double(error: nil, info: nil, warn: nil) }
+  let(:response) { double(code: 200, header: {}, body: '') }
+  let(:http) { double(shutdown: nil, request: response) }
+  let(:now) { Time.parse('2012-10-14 00:00:00') }
+  let(:batch) { double(mark_failed: nil, mark_delivered: nil, mark_retryable: nil, notification_processed: nil) }
+  let(:delivery) { Rpush::Daemon::Wns::Delivery.new(app, http, notification, batch) }
+  let(:store) { double(create_wpns_notification: double(id: 2), update_app: nil) }
+
+  def perform
+    delivery.perform
+  end
+
+  def perform_with_rescue
+    expect { perform }.to raise_error(StandardError)
+  end
+
+  before do
+    allow(delivery).to receive_messages(reflect: nil)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Time).to receive_messages(now: now)
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  shared_examples_for "an notification with some delivery faliures" do
+    let(:new_notification) { Rpush::Wns::Notification.where('id != ?', notification.id).first }
+
+    before { allow(response).to receive_messages(body: JSON.dump(body)) }
+
+    it "marks the original notification falied" do
+      expect(delivery).to receive(:mark_failed) do |error|
+        expect(error.message).to match(error_description)
+      end
+      perform_with_rescue
+    end
+
+    it "raises a DeliveryError" do
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe "an 200 response without an access token" do
+    before do
+      allow(app).to receive_messages(access_token_expired?: true)
+      allow(response).to receive_messages(to_hash: {}, code: 200, body: JSON.dump(access_token: "dummy_access_token", expires_in: 60))
+    end
+
+    it 'set the access token for the app' do
+      expect(delivery).to receive(:update_access_token).with("access_token" => "dummy_access_token", "expires_in" => 60)
+      expect(store).to receive(:update_app).with app
+      perform
+    end
+
+    it 'uses the PostRequest factory for creating the request' do
+      expect(Rpush::Daemon::Wns::PostRequest).to receive(:create).with(notification, "dummy_access_token")
+      perform
+    end
+  end
+
+  describe "an 200 response with a valid access token" do
+    before do
+      allow(response).to receive_messages(code: 200)
+    end
+
+    it "marks the notification as delivered if delivered successfully to all devices" do
+      allow(response).to receive_messages(body: JSON.dump("failure" => 0))
+      allow(response).to receive_messages(to_hash: { "X-WNS-Status" => ["received"] })
+      expect(batch).to receive(:mark_delivered).with(notification)
+      perform
+    end
+
+    it "retries the notification when the queue is full" do
+      allow(response).to receive_messages(body: JSON.dump("failure" => 0))
+      allow(response).to receive_messages(to_hash: { "X-WNS-Status" => ["channelthrottled"] })
+      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
+      allow(response).to receive_messages(body: JSON.dump("faliure" => 0))
+      allow(response).to receive_messages(to_hash: { "X-WNS-Status" => ["dropped"], "X-WNS-Error-Description" => "" })
+      error = Rpush::DeliveryError.new(200, notification.id, 'Notification was received but suppressed by the service ().')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 400 response" do
+    before { allow(response).to receive_messages(code: 400) }
+    it "marks notifications as failed" do
+      error = Rpush::DeliveryError.new(400, notification.id, 'One or more headers were specified incorrectly or conflict with another header.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 404 response" do
+    before { allow(response).to receive_messages(code: 404) }
+    it "marks notifications as failed" do
+      error = Rpush::DeliveryError.new(404, notification.id, 'The channel URI is not valid or is not recognized by WNS.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 405 response" do
+    before { allow(response).to receive_messages(code: 405) }
+    it "marks notifications as failed" do
+      error = Rpush::DeliveryError.new(405, notification.id, 'Invalid method (GET, CREATE); only POST (Windows or Windows Phone) or DELETE (Windows Phone only) is allowed.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 406 response" do
+    before { allow(response).to receive_messages(code: 406) }
+
+    it "retries the notification" do
+      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
+      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 { allow(response).to receive_messages(code: 412) }
+
+    it "retries the notification" do
+      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
+      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 { allow(response).to receive_messages(code: 503) }
+
+    it "retries the notification exponentially" do
+      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
+      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 { allow(response).to receive_messages(code: 418) }
+
+    it 'marks the notification as failed' do
+      error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+end

data/spec/unit/daemon/wns/post_request_spec.rb

@@ -0,0 +1,117 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Wns::PostRequest do
+  let(:app) do
+    Rpush::Wns::App.create!(
+      name: "MyApp",
+      client_id: "someclient",
+      client_secret: "somesecret",
+      access_token: "access_token",
+      access_token_expiration: Time.now + (60 * 10)
+    )
+  end
+
+  context 'Notification' do
+    let(:notification) do
+      Rpush::Wns::Notification.create!(
+        app: app,
+        data: {
+          title: "MyApp",
+          body: "Example notification"
+        },
+        uri: "http://some.example/"
+      )
+    end
+
+    it 'creates a request characteristic for toast notification' do
+      request = Rpush::Daemon::Wns::PostRequest.create(notification, 'token')
+      expect(request['X-WNS-Type']).to eq('wns/toast')
+      expect(request['Content-Type']).to eq('text/xml')
+      expect(request.body).to include('<toast>')
+      expect(request.body).to include('MyApp')
+      expect(request.body).to include('Example notification')
+    end
+
+    context 'with launch' do
+      let(:notification) do
+        Rpush::Wns::Notification.create!(
+          app: app,
+          data: {
+            title: "MyApp",
+            body: "Example notification",
+            launch: "MyLaunchArgument"
+          },
+          uri: "http://some.example/"
+        )
+      end
+
+      it 'creates a request characteristic for toast notification with launch' do
+        request = Rpush::Daemon::Wns::PostRequest.create(notification, 'token')
+        expect(request['X-WNS-Type']).to eq('wns/toast')
+        expect(request['Content-Type']).to eq('text/xml')
+        expect(request.body).to include("<toast launch='MyLaunchArgument'>")
+        expect(request.body).to include('MyApp')
+        expect(request.body).to include('Example notification')
+      end
+    end
+
+    context 'with sound' do
+      let(:notification) do
+        Rpush::Wns::Notification.create!(
+          app: app,
+          data: {
+            title: "MyApp",
+            body: "Example notification"
+          },
+          uri: "http://some.example/",
+          sound: "ms-appx:///examplesound.wav"
+        )
+      end
+
+      it 'creates a request characteristic for toast notification' do
+        request = Rpush::Daemon::Wns::PostRequest.create(notification, 'token')
+        expect(request['X-WNS-Type']).to eq('wns/toast')
+        expect(request['Content-Type']).to eq('text/xml')
+        expect(request.body).to include('<toast>')
+        expect(request.body).to include('MyApp')
+        expect(request.body).to include('Example notification')
+        expect(request.body).to include("<audio src='ms-appx:///examplesound.wav'/>")
+      end
+    end
+  end
+
+  context 'RawNotification' do
+    let(:notification) do
+      Rpush::Wns::RawNotification.create!(
+        app: app,
+        data: { foo: 'foo', bar: 'bar' },
+        uri: "http://some.example/"
+      )
+    end
+
+    it 'creates a request characteristic for raw notification' do
+      request = Rpush::Daemon::Wns::PostRequest.create(notification, 'token')
+      expect(request['X-WNS-Type']).to eq('wns/raw')
+      expect(request['Content-Type']).to eq('application/octet-stream')
+      expect(request.body).to eq("{\"foo\":\"foo\",\"bar\":\"bar\"}")
+    end
+  end
+
+  context 'BadgeNotification' do
+    let(:notification) do
+      Rpush::Wns::BadgeNotification.create!(
+        app: app,
+        uri: "http://some.example/",
+        badge: 42
+      )
+    end
+
+    it 'creates a request characteristic for badge notification' do
+      request = Rpush::Daemon::Wns::PostRequest.create(notification, 'token')
+      expect(request['X-WNS-Type']).to eq('wns/badge')
+      expect(request['Content-Type']).to eq('text/xml')
+      expect(request.body).to include('<badge')
+      expect(request.body).to include('42')
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Wpns::Delivery do
+  let(:app) { Rpush::Wpns::App.create!(name: "MyApp") }
+  let(:notification) { Rpush::Wpns::Notification.create!(app: app, data: { title: "MyApp", body: "Example notification", param: "/param1" }, uri: "http://some.example/", deliver_after: Time.now) }
+  let(:logger) { double(error: nil, info: nil, warn: nil) }
+  let(:response) { double(code: 200, header: {}) }
+  let(:http) { double(shutdown: nil, request: response) }
+  let(:now) { Time.parse('2012-10-14 00:00:00') }
+  let(:batch) { double(mark_failed: nil, mark_delivered: nil, mark_retryable: nil, notification_processed: nil) }
+  let(:delivery) { Rpush::Daemon::Wpns::Delivery.new(app, http, notification, batch) }
+  let(:store) { double(create_wpns_notification: double(id: 2)) }
+
+  def perform
+    delivery.perform
+  end
+
+  def perform_with_rescue
+    expect { perform }.to raise_error(StandardError)
+  end
+
+  before do
+    allow(delivery).to receive_messages(reflect: nil)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Time).to receive_messages(now: now)
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  shared_examples_for "an notification with some delivery faliures" do
+    let(:new_notification) { Rpush::Wpns::Notification.where('id != ?', notification.id).first }
+
+    before { allow(response).to receive_messages(body: JSON.dump(body)) }
+
+    it "marks the original notification falied" do
+      expect(delivery).to receive(:mark_failed) do |error|
+        expect(error.message).to match(error_description)
+      end
+      perform_with_rescue
+    end
+
+    it "raises a DeliveryError" do
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe "an 200 response" do
+    before do
+      allow(response).to receive_messages(code: 200)
+    end
+
+    it "marks the notification as delivered if delivered successfully to all devices" do
+      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
+      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
+      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.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 400 response" do
+    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.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 401 response" do
+    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.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 404 response" do
+    before { allow(response).to receive_messages(code: 404) }
+    it "marks notifications as failed" do
+      error = Rpush::DeliveryError.new(404, notification.id, 'Not Found')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 405 response" do
+    before { allow(response).to receive_messages(code: 405) }
+    it "marks notifications as failed" do
+      error = Rpush::DeliveryError.new(405, notification.id, 'Method Not Allowed')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe "an 406 response" do
+    before { allow(response).to receive_messages(code: 406) }
+
+    it "retries the notification" do
+      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
+      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 { allow(response).to receive_messages(code: 412) }
+
+    it "retries the notification" do
+      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
+      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 { allow(response).to receive_messages(code: 503) }
+
+    it "retries the notification exponentially" do
+      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
+      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 { allow(response).to receive_messages(code: 418) }
+
+    it 'marks the notification as failed' do
+      error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+end

data/spec/unit/daemon_spec.rb

@@ -0,0 +1,138 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
+
+describe Rpush::Daemon, "when starting" do
+  module Rails; end
+
+  let(:certificate) { double }
+  let(:password) { double }
+  let(:logger) { double(:logger, info: nil, error: nil, warn: nil, internal_logger: nil) }
+
+  before do
+    allow(Rpush).to receive(:logger) { logger }
+    allow(Rpush::Daemon::Feeder).to receive(:start)
+    allow(Rpush::Daemon::Synchronizer).to receive(:sync)
+    allow(Rpush::Daemon::AppRunner).to receive(:stop)
+    allow(Rpush::Daemon::Rpc::Server).to receive(:start)
+    allow(Rpush::Daemon::Rpc::Server).to receive(:stop)
+    allow(Rpush::Daemon).to receive(:exit)
+    allow(Rpush::Daemon).to receive(:puts)
+    allow(Rpush::Daemon::SignalHandler).to receive(:start)
+    allow(Rpush::Daemon::SignalHandler).to receive(:stop)
+    allow(Rpush::Daemon::SignalHandler).to receive(:handle_shutdown_signal)
+    allow(Process).to receive(:daemon)
+    allow(File).to receive(:open)
+  end
+
+  unless Rpush.jruby?
+    it "forks into a daemon if the foreground option is false" do
+      Rpush.config.foreground = false
+      Rpush::Daemon.common_init
+      expect(Process).to receive(:daemon)
+      Rpush::Daemon.start
+    end
+
+    it "does not fork into a daemon if the foreground option is true" do
+      Rpush.config.foreground = true
+      expect(Process).to_not receive(:daemon)
+      Rpush::Daemon.start
+    end
+
+    it "does not fork into a daemon if the push option is true" do
+      Rpush.config.push = true
+      expect(Process).to_not receive(:daemon)
+      Rpush::Daemon.start
+    end
+
+    it "does not fork into a daemon if the embedded option is true" do
+      Rpush.config.embedded = true
+      expect(Process).to_not receive(:daemon)
+      Rpush::Daemon.start
+    end
+  end
+
+  it 'releases the store connection' do
+    Rpush::Daemon.store = double
+    expect(Rpush::Daemon.store).to receive(:release_connection)
+    Rpush::Daemon.start
+  end
+
+  it 'sets up setup signal traps' do
+    expect(Rpush::Daemon::SignalHandler).to receive(:start)
+    Rpush::Daemon.start
+  end
+
+  it 'instantiates the store' do
+    Rpush.config.client = :active_record
+    Rpush::Daemon.start
+    expect(Rpush::Daemon.store).to be_kind_of(Rpush::Daemon::Store::ActiveRecord)
+  end
+
+  it 'initializes plugins' do
+    plugin = Rpush.plugin(:test)
+    did_init = false
+    plugin.init { did_init = true }
+    Rpush::Daemon.common_init
+    expect(did_init).to eq(true)
+  end
+
+  it 'logs an error if the store cannot be loaded' do
+    Rpush.config.client = :foo_bar
+    expect(Rpush.logger).to receive(:error).with(kind_of(LoadError))
+    allow(Rpush::Daemon).to receive(:exit) { Rpush::Daemon.store = double.as_null_object }
+    Rpush::Daemon.start
+  end
+
+  it "writes the process ID to the PID file" do
+    expect(Rpush::Daemon).to receive(:write_pid_file)
+    Rpush::Daemon.start
+  end
+
+  it "logs an error if the PID file could not be written" do
+    Rpush.config.pid_file = '/rails_root/rpush.pid'
+    allow(File).to receive(:open).and_raise(Errno::ENOENT)
+    expect(logger).to receive(:error).with(%r{Failed to write PID to '/rails_root/rpush\.pid'})
+    Rpush::Daemon.start
+  end
+
+  it "starts the feeder" do
+    expect(Rpush::Daemon::Feeder).to receive(:start)
+    Rpush::Daemon.start
+  end
+
+  it "syncs apps" do
+    expect(Rpush::Daemon::Synchronizer).to receive(:sync)
+    Rpush::Daemon.start
+  end
+
+  describe "shutdown" do
+    it "stops the feeder" do
+      expect(Rpush::Daemon::Feeder).to receive(:stop)
+      Rpush::Daemon.shutdown
+    end
+
+    it "stops the app runners" do
+      expect(Rpush::Daemon::AppRunner).to receive(:stop)
+      Rpush::Daemon.shutdown
+    end
+
+    it "removes the PID file if one was written" do
+      Rpush.config.pid_file = "/rails_root/rpush.pid"
+      allow(File).to receive(:exist?) { true }
+      expect(File).to receive(:delete).with("/rails_root/rpush.pid")
+      Rpush::Daemon.shutdown
+    end
+
+    it "does not attempt to remove the PID file if it does not exist" do
+      allow(File).to receive(:exist?) { false }
+      expect(File).to_not receive(:delete)
+      Rpush::Daemon.shutdown
+    end
+
+    it "does not attempt to remove the PID file if one was not written" do
+      Rpush.config.pid_file = nil
+      expect(File).to_not receive(:delete)
+      Rpush::Daemon.shutdown
+    end
+  end
+end

data/spec/unit/deprecatable_spec.rb

@@ -0,0 +1,32 @@
+require 'unit_spec_helper'
+
+describe Rpush::Deprecatable do
+  class HasDeprecatedMethod
+    include Rpush::Deprecatable
+
+    def original_called?
+      @called == true
+    end
+
+    def deprecated_method
+      @called = true
+    end
+    deprecated(:deprecated_method, '4.0')
+  end
+
+  let(:klass) { HasDeprecatedMethod.new }
+
+  before do
+    allow(Rpush::Deprecation).to receive(:warn)
+  end
+
+  it 'warns the method is deprecated when called' do
+    expect(Rpush::Deprecation).to receive(:warn).with(/deprecated_method is deprecated and will be removed from Rpush 4\.0\./)
+    klass.deprecated_method
+  end
+
+  it 'calls the original method' do
+    klass.deprecated_method
+    expect(klass.original_called?).to eq(true)
+  end
+end

data/spec/unit/deprecation_spec.rb

@@ -0,0 +1,15 @@
+require 'unit_spec_helper'
+
+describe Rpush::Deprecation do
+  it 'prints a warning' do
+    expect(STDERR).to receive(:puts).with("DEPRECATION WARNING: msg")
+    Rpush::Deprecation.warn("msg")
+  end
+
+  it 'does not print a warning when muted' do
+    expect(STDERR).not_to receive(:puts)
+    Rpush::Deprecation.muted do
+      Rpush::Deprecation.warn("msg")
+    end
+  end
+end

data/spec/unit/embed_spec.rb

@@ -0,0 +1,47 @@
+require 'unit_spec_helper'
+
+describe Rpush, 'embed' do
+  before do
+    allow(Rpush::Daemon).to receive_messages(start: nil, shutdown: nil)
+    allow(Kernel).to receive(:at_exit)
+  end
+
+  after { Rpush.shutdown }
+
+  it 'sets the embedded config option to true' do
+    Rpush.embed
+    expect(Rpush.config.embedded).to eq(true)
+  end
+
+  it 'starts the daemon' do
+    expect(Rpush::Daemon).to receive(:start)
+    Rpush.embed
+  end
+end
+
+describe Rpush, 'shutdown' do
+  before { Rpush.config.embedded = true }
+
+  it 'shuts down the daemon' do
+    expect(Rpush::Daemon).to receive(:shutdown)
+    Rpush.shutdown
+  end
+end
+
+describe Rpush, 'sync' do
+  before { Rpush.config.embedded = true }
+
+  it 'syncs' do
+    expect(Rpush::Daemon::Synchronizer).to receive(:sync)
+    Rpush.sync
+  end
+end
+
+describe Rpush, 'status' do
+  before { Rpush.config.embedded = true }
+
+  it 'returns the AppRunner status' do
+    expect(Rpush::Daemon::AppRunner).to receive_messages(status: { status: true })
+    expect(Rpush.status).to eq(status: true)
+  end
+end