rapns 2.0.5 → 3.0.0.beta.1

data/spec/acceptance_spec_helper.rb

@@ -0,0 +1,85 @@
+require 'unit_spec_helper'
+require 'fileutils'
+
+ENV['RAILS_ENV'] = 'test'
+require 'bundler'
+Bundler.require(:default)
+
+TMP_DIR = '/tmp'
+RAILS_DIR = File.join(TMP_DIR, 'rapns_test')
+if ENV['TRAVIS']
+  TRAVIS_BRANCH = 'gcm'
+  RAPNS_ROOT = 'git://github.com/ileitch/rapns.git'
+else
+  RAPNS_ROOT = File.expand_path(__FILE__ + '/../../')
+end
+
+def setup_rails
+  return if $rails_is_setup
+  `rm -rf #{RAILS_DIR}`
+  FileUtils.mkdir_p(RAILS_DIR)
+  cmd("bundle exec rails new #{RAILS_DIR} --skip-bundle")
+  branch = `git branch | grep '\*'`.split(' ').last
+  in_test_rails do
+    cmd('echo "gem \'rake\'" >> Gemfile')
+    if ENV['TRAVIS']
+      cmd("echo \"gem 'rapns', :git => '#{RAPNS_ROOT}', :branch => '#{TRAVIS_BRANCH}'\" >> Gemfile")
+    else
+      cmd("echo \"gem 'rapns', :git => '#{RAPNS_ROOT}', :branch => '#{branch}'\" >> Gemfile")
+    end
+
+    cmd("bundle install")
+  end
+end
+
+def as_test_rails_db(env='development')
+  orig_config = ActiveRecord::Base.connection_config
+  begin
+    in_test_rails do
+      config = YAML.load_file('config/database.yml')
+      ActiveRecord::Base.establish_connection(config[env])
+      yield
+    end
+  ensure
+    ActiveRecord::Base.establish_connection(orig_config)
+  end
+end
+
+def cmd(str, echo = true)
+  puts "* #{str.strip}" if echo
+  retval = Bundler.with_clean_env { `#{str}` }
+  puts retval.strip if echo
+  retval
+end
+
+def generate
+  in_test_rails { cmd('bundle exec rails g rapns') }
+end
+
+def migrate(*migrations)
+  in_test_rails do
+    if migrations.present?
+      migrations.each do |name|
+        migration = Dir.entries('db/migrate').find { |entry| entry =~ /#{name}/ }
+        version = migration.split('_').first
+        cmd("bundle exec rake db:migrate VERSION=#{version} RAILS_ENV=development")
+      end
+    else
+      cmd('bundle exec rake db:migrate RAILS_ENV=development')
+    end
+  end
+end
+
+def in_test_rails
+  pwd = Dir.pwd
+  begin
+    Dir.chdir(RAILS_DIR)
+    yield
+  ensure
+    Dir.chdir(pwd)
+  end
+end
+
+def runner(str)
+  in_test_rails { cmd("rails runner -e test '#{str}'").strip }
+end

data/spec/support/simplecov_helper.rb

@@ -0,0 +1,13 @@
+require 'simplecov'
+require './spec/support/simplecov_quality_formatter'
+
+module SimpleCovHelper
+  def start_simple_cov(name)
+    SimpleCov.start do
+      add_filter '/spec/'
+      add_filter '/lib/generators'
+      command_name name
+      formatter SimpleCov::Formatter::QualityFormatter
+    end
+  end
+end

data/spec/support/simplecov_quality_formatter.rb

@@ -0,0 +1,8 @@
+class SimpleCov::Formatter::QualityFormatter
+  def format(result)
+    SimpleCov::Formatter::HTMLFormatter.new.format(result)
+    File.open("coverage/covered_percent", "w") do |f|
+      f.puts result.source_files.covered_percent.to_f
+    end
+  end
+end

data/spec/unit/apns/app_spec.rb

@@ -0,0 +1,15 @@
+require 'unit_spec_helper'
+
+describe Rapns::App do
+  it 'does not validate an app with an invalid certificate' do
+    app = Rapns::Apns::App.new(:key => 'test', :environment => 'development', :certificate => 'foo')
+    app.valid?
+    app.errors[:certificate].should == ['Certificate value must contain a certificate and a private key.']
+  end
+
+  it 'validates a real certificate' do
+    app = Rapns::Apns::App.new :key => 'test', :environment => 'development', :certificate => TEST_CERT
+    app.valid?
+    app.errors[:certificate].should == []
+  end
+end

data/spec/unit/apns/feedback_spec.rb

@@ -0,0 +1,12 @@
+require "unit_spec_helper"
+
+describe Rapns::Apns::Feedback do
+  it { should validate_presence_of(:device_token) }
+  it { should validate_presence_of(:failed_at) }
+
+  it "should validate the format of the device_token" do
+    notification = Rapns::Apns::Feedback.new(:device_token => "{$%^&*()}")
+    notification.valid?.should be_false
+    notification.errors[:device_token].include?("is invalid").should be_true
+  end
+end

data/spec/{rapns → unit/apns}/notification_spec.rb

@@ -1,19 +1,24 @@
-require "spec_helper"
+require "unit_spec_helper"
+require 'unit/notification_shared.rb'
+
+describe Rapns::Apns::Notification do
+  it_should_behave_like 'an Notification subclass'
 
-describe Rapns::Notification do
-  it { should validate_presence_of(:app) }
   it { should validate_presence_of(:device_token) }
   it { should validate_numericality_of(:badge) }
-  it { should validate_numericality_of(:expiry) }
+
+  let(:notification_class) { Rapns::Apns::Notification }
+  let(:notification) { notification_class.new }
+  let(:data_setter) { 'attributes_for_device=' }
+  let(:data_getter) { 'attributes_for_device' }
 
   it "should validate the format of the device_token" do
-    notification = Rapns::Notification.new(:device_token => "{$%^&*()}")
+    notification = Rapns::Apns::Notification.new(:device_token => "{$%^&*()}")
     notification.valid?.should be_false
     notification.errors[:device_token].include?("is invalid").should be_true
   end
 
   it "should validate the length of the binary conversion of the notification" do
-    notification = Rapns::Notification.new
     notification.device_token = "a" * 64
     notification.alert = "way too long!" * 100
     notification.valid?.should be_false
@@ -21,90 +26,73 @@ describe Rapns::Notification do
   end
 
   it "should default the sound to 1.aiff" do
-    Rapns::Notification.new.sound.should == "1.aiff"
+    notification.sound.should == "1.aiff"
   end
 
   it "should default the expiry to 1 day" do
-    Rapns::Notification.new.expiry.should == 1.day.to_i
+    notification.expiry.should == 1.day.to_i
   end
 end
 
-describe Rapns::Notification, "when assigning the device token" do
+describe Rapns::Apns::Notification, "when assigning the device token" do
   it "should strip spaces from the given string" do
-    notification = Rapns::Notification.new(:device_token => "o m g")
+    notification = Rapns::Apns::Notification.new(:device_token => "o m g")
     notification.device_token.should == "omg"
   end
 
   it "should strip chevrons from the given string" do
-    notification = Rapns::Notification.new(:device_token => "<omg>")
+    notification = Rapns::Apns::Notification.new(:device_token => "<omg>")
     notification.device_token.should == "omg"
   end
 end
 
-describe Rapns::Notification, "when assigning the attributes for the device" do
-  it "should raise an ArgumentError if something other than a Hash is assigned" do
-    expect { Rapns::Notification.new(:attributes_for_device => Array.new) }.to \
-      raise_error(ArgumentError, "attributes_for_device must be a Hash")
-  end
-
-  it "should encode the given Hash as JSON" do
-    notification = Rapns::Notification.new(:attributes_for_device => {:hi => "mom"})
-    notification.read_attribute(:attributes_for_device).should == "{\"hi\":\"mom\"}"
-  end
-
-  it "should decode the JSON when using the reader method" do
-    notification = Rapns::Notification.new(:attributes_for_device => {:hi => "mom"})
-    notification.attributes_for_device.should == {"hi" => "mom"}
-  end
-end
-
-describe Rapns::Notification, "as_json" do
+describe Rapns::Apns::Notification, "as_json" do
   it "should include the alert if present" do
-    notification = Rapns::Notification.new(:alert => "hi mom")
+    notification = Rapns::Apns::Notification.new(:alert => "hi mom")
     notification.as_json["aps"]["alert"].should == "hi mom"
   end
 
   it "should not include the alert key if the alert is not present" do
-    notification = Rapns::Notification.new(:alert => nil)
+    notification = Rapns::Apns::Notification.new(:alert => nil)
     notification.as_json["aps"].key?("alert").should be_false
   end
 
   it "should encode the alert as JSON if it is a Hash" do
-    notification = Rapns::Notification.new(:alert => { 'body' => "hi mom", 'alert-loc-key' => "View" })
+    notification = Rapns::Apns::Notification.new(:alert => { 'body' => "hi mom", 'alert-loc-key' => "View" })
     notification.as_json["aps"]["alert"].should == { 'body' => "hi mom", 'alert-loc-key' => "View" }
   end
 
   it "should include the badge if present" do
-    notification = Rapns::Notification.new(:badge => 6)
+    notification = Rapns::Apns::Notification.new(:badge => 6)
     notification.as_json["aps"]["badge"].should == 6
   end
 
   it "should not include the badge key if the badge is not present" do
-    notification = Rapns::Notification.new(:badge => nil)
+    notification = Rapns::Apns::Notification.new(:badge => nil)
     notification.as_json["aps"].key?("badge").should be_false
   end
 
   it "should include the sound if present" do
-    notification = Rapns::Notification.new(:alert => "my_sound.aiff")
+    notification = Rapns::Apns::Notification.new(:alert => "my_sound.aiff")
     notification.as_json["aps"]["alert"].should == "my_sound.aiff"
   end
 
   it "should not include the sound key if the sound is not present" do
-    notification = Rapns::Notification.new(:sound => false)
+    notification = Rapns::Apns::Notification.new(:sound => false)
     notification.as_json["aps"].key?("sound").should be_false
   end
 
-  it "should include attrbutes for the device" do
-    notification = Rapns::Notification.new
+  it "should include attributes for the device" do
+    notification = Rapns::Apns::Notification.new
     notification.attributes_for_device = {:omg => :lol, :wtf => :dunno}
     notification.as_json["omg"].should == "lol"
     notification.as_json["wtf"].should == "dunno"
   end
 end
 
-describe Rapns::Notification, 'MDM' do
+describe Rapns::Apns::Notification, 'MDM' do
   let(:magic) { 'abc123' }
-  let(:notification) { Rapns::Notification.new }
+  let(:notification) { Rapns::Apns::Notification.new }
 
   it 'includes the mdm magic in the payload' do
     notification.mdm = magic
@@ -118,8 +106,8 @@ describe Rapns::Notification, 'MDM' do
   end
 end
 
-describe Rapns::Notification, 'content-available' do
-  let(:notification) { Rapns::Notification.new }
+describe Rapns::Apns::Notification, 'content-available' do
+  let(:notification) { Rapns::Apns::Notification.new }
 
   it 'includes content-available in the payload' do
     notification.content_available = true
@@ -136,43 +124,43 @@ describe Rapns::Notification, 'content-available' do
   end
 end
 
-describe Rapns::Notification, "to_binary" do
+describe Rapns::Apns::Notification, "to_binary" do
   it "should correctly convert the notification to binary" do
-    notification = Rapns::Notification.new
+    notification = Rapns::Apns::Notification.new
     notification.device_token = "a" * 64
     notification.sound = "1.aiff"
     notification.badge = 3
     notification.alert = "Don't panic Mr Mainwaring, don't panic!"
     notification.attributes_for_device = {:hi => :mom}
     notification.expiry = 86400 # 1 day, \x00\x01Q\x80
-    notification.app = 'my_app'
+    notification.app = Rapns::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT)
     notification.save!
     notification.stub(:id).and_return(1234)
     notification.to_binary.should == "\x01\x00\x00\x04\xD2\x00\x01Q\x80\x00 \xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\x00a{\"aps\":{\"alert\":\"Don't panic Mr Mainwaring, don't panic!\",\"badge\":3,\"sound\":\"1.aiff\"},\"hi\":\"mom\"}"
   end
 end
 
-describe Rapns::Notification, "bug #31" do
+describe Rapns::Apns::Notification, "bug #31" do
   it 'does not confuse a JSON looking string as JSON' do
-    notification = Rapns::Notification.new
+    notification = Rapns::Apns::Notification.new
     notification.alert = "{\"one\":2}"
     notification.alert.should == "{\"one\":2}"
   end
 
   it 'does confuse a JSON looking string as JSON if the alert_is_json attribute is not present' do
-    notification = Rapns::Notification.new
+    notification = Rapns::Apns::Notification.new
     notification.stub(:has_attribute? => false)
     notification.alert = "{\"one\":2}"
     notification.alert.should == {"one" => 2}
   end
 end
 
-describe Rapns::Notification, "bug #35" do
+describe Rapns::Apns::Notification, "bug #35" do
   it "should limit payload size to 256 bytes but not the entire packet" do
-    notification = Rapns::Notification.new do |n|
+    notification = Rapns::Apns::Notification.new do |n|
       n.device_token = "a" * 64
       n.alert = "a" * 210
-      n.app = 'my_app'
+      n.app = Rapns::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT)
     end
 
     notification.to_binary(:for_validation => true).bytesize.should > 256
@@ -181,36 +169,20 @@ describe Rapns::Notification, "bug #35" do
   end
 end
 
-describe Rapns::Notification, "multi_json usage" do
-  describe Rapns::Notification, "alert" do
+describe Rapns::Apns::Notification, "multi_json usage" do
+  describe Rapns::Apns::Notification, "alert" do
     it "should call MultiJson.load when multi_json version is 1.3.0" do
-      notification = Rapns::Notification.new(:alert => { :a => 1 }, :alert_is_json => true)
+      notification = Rapns::Apns::Notification.new(:alert => { :a => 1 }, :alert_is_json => true)
       Gem.stub(:loaded_specs).and_return( { 'multi_json' => Gem::Specification.new('multi_json', '1.3.0') } )
       MultiJson.should_receive(:load).with(any_args())
       notification.alert
     end
 
     it "should call MultiJson.decode when multi_json version is 1.2.9" do
-      notification = Rapns::Notification.new(:alert => { :a => 1 }, :alert_is_json => true)
+      notification = Rapns::Apns::Notification.new(:alert => { :a => 1 }, :alert_is_json => true)
       Gem.stub(:loaded_specs).and_return( { 'multi_json' => Gem::Specification.new('multi_json', '1.2.9') } )
       MultiJson.should_receive(:decode).with(any_args())
       notification.alert
     end
   end
-
-  describe Rapns::Notification, "attributes_for_device=" do
-    it "should call MultiJson.dump when multi_json responds to :dump" do
-      notification = Rapns::Notification.new
-      MultiJson.stub(:respond_to?).with(:dump).and_return(true)
-      MultiJson.should_receive(:dump).with(any_args())
-      notification.attributes_for_device = { :pirates => 1 }
-    end
-
-    it "should call MultiJson.encode when multi_json does not respond to :dump" do
-      notification = Rapns::Notification.new
-      MultiJson.stub(:respond_to?).with(:dump).and_return(false)
-      MultiJson.should_receive(:encode).with(any_args())
-      notification.attributes_for_device = { :ninjas => 1 }
-    end
-  end
-end
+end

data/spec/unit/app_spec.rb

@@ -0,0 +1,18 @@
+require "unit_spec_helper"
+
+describe Rapns::App do
+  it { should validate_numericality_of(:connections) }
+
+  it 'validates the uniqueness of name within type and environment' do
+    Rapns::Apns::App.create!(:name => 'test', :environment => 'production', :certificate => TEST_CERT)
+    app = Rapns::Apns::App.new(:name => 'test', :environment => 'production', :certificate => TEST_CERT)
+    app.valid?.should be_false
+    app.errors[:name].should == ['has already been taken']
+
+    app = Rapns::Apns::App.new(:name => 'test', :environment => 'development', :certificate => TEST_CERT)
+    app.valid?.should be_true
+
+    app = Rapns::Gcm::App.new(:name => 'test', :environment => 'production', :auth_key => TEST_CERT)
+    app.valid?.should be_true
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'unit_spec_helper'
+require File.dirname(__FILE__) + '/../app_runner_shared.rb'
+
+describe Rapns::Daemon::Apns::AppRunner do
+  it_behaves_like 'an AppRunner subclass'
+
+  let(:app_class) { Rapns::Apns::App }
+  let(:app) { app_class.create!(:name => 'my_app', :environment => 'development',
+                                :certificate => TEST_CERT, :password => 'pass') }
+  let(:runner) { Rapns::Daemon::Apns::AppRunner.new(app) }
+  let(:handler) { stub(:start => nil, :stop => nil, :queue= => nil) }
+  let(:receiver) { stub(:start => nil, :stop => nil) }
+  let(:config) { {:feedback_poll => 60 } }
+
+  before do
+    Rapns::Daemon::Apns::DeliveryHandler.stub(:new => handler)
+    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => receiver)
+    Rapns::Daemon.stub(:config => config)
+  end
+
+  it 'instantiates a new feedback receiver when started' do
+    Rapns::Daemon::Apns::FeedbackReceiver.should_receive(:new).with(app, 'feedback.sandbox.push.apple.com',
+                                                                    2196, 60)
+    runner.start
+  end
+
+  it 'starts the feedback receiver' do
+    receiver.should_receive(:start)
+    runner.start
+  end
+
+  it 'stops the feedback receiver' do
+    runner.start
+    receiver.should_receive(:stop)
+    runner.stop
+  end
+end

data/spec/{rapns/daemon → unit/daemon/apns}/connection_spec.rb

@@ -1,6 +1,6 @@
-require "spec_helper"
+require "unit_spec_helper"
 
-describe Rapns::Daemon::Connection do
+describe Rapns::Daemon::Apns::Connection do
   let(:ssl_context) { stub(:key= => nil, :cert= => nil) }
   let(:rsa_key) { stub }
   let(:certificate) { stub }
@@ -11,7 +11,7 @@ describe Rapns::Daemon::Connection do
   let(:tcp_socket) { stub(:setsockopt => nil, :close => nil) }
   let(:ssl_socket) { stub(:sync= => nil, :connect => nil, :close => nil, :write => nil, :flush => nil) }
   let(:logger) { stub(:info => nil, :error => nil) }
-  let(:connection) { Rapns::Daemon::Connection.new('Connection 0', host, port, certificate, password) }
+  let(:connection) { Rapns::Daemon::Apns::Connection.new('Connection 0', host, port, certificate, password) }
 
   before do
     OpenSSL::SSL::SSLContext.stub(:new => ssl_context)
@@ -125,7 +125,7 @@ describe Rapns::Daemon::Connection do
       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
+      rescue Rapns::Daemon::Apns::ConnectionError
       end
     end
 
@@ -133,21 +133,21 @@ describe Rapns::Daemon::Connection do
       connection.should_receive(:reconnect).exactly(3).times
       begin
         connection.write(nil)
-      rescue Rapns::Daemon::ConnectionError
+      rescue Rapns::Daemon::Apns::ConnectionError
       end
     end
 
     it "raises a ConnectionError after 3 attempts at reconnecting" do
       expect do
         connection.write(nil)
-      end.to raise_error(Rapns::Daemon::ConnectionError, "Connection 0 tried 3 times to reconnect but failed (#{error_type.name}).")
+      end.to raise_error(Rapns::Daemon::Apns::ConnectionError, "Connection 0 tried 3 times to reconnect but failed (#{error_type.name}).")
     end
 
     it "sleeps 1 second before retrying the connection" do
       connection.should_receive(:sleep).with(1)
       begin
         connection.write(nil)
-      rescue Rapns::Daemon::ConnectionError
+      rescue Rapns::Daemon::Apns::ConnectionError
       end
     end
   end
@@ -206,7 +206,7 @@ describe Rapns::Daemon::Connection do
     before { connection.connect }
 
     it 'reconnects if the connection has been idle for more than the defined period' do
-      Rapns::Daemon::Connection.stub(:idle_period => 0.1)
+      Rapns::Daemon::Apns::Connection.stub(:idle_period => 0.1)
       sleep 0.2
       connection.should_receive(:reconnect)
       connection.write('blah')
@@ -225,7 +225,7 @@ describe Rapns::Daemon::Connection do
     end
 
     it 'logs the the connection is idle' do
-      Rapns::Daemon::Connection.stub(:idle_period => 0.1)
+      Rapns::Daemon::Apns::Connection.stub(:idle_period => 0.1)
       sleep 0.2
       Rapns::Daemon.logger.should_receive(:info).with('[Connection 0] Idle period exceeded, reconnecting...')
       connection.write('blah')

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

@@ -0,0 +1,48 @@
+require 'unit_spec_helper'
+require File.dirname(__FILE__) + '/../delivery_handler_shared.rb'
+
+describe Rapns::Daemon::Apns::DeliveryHandler do
+  it_should_behave_like 'an DeliveryHandler subclass'
+
+  let(:host) { 'localhost' }
+  let(:port) { 2195 }
+  let(:certificate) { stub }
+  let(:password) { stub }
+  let(:app) { stub(:password => password, :certificate => certificate, :name => 'MyApp')}
+  let(:delivery_handler) { Rapns::Daemon::Apns::DeliveryHandler.new(app, host, port) }
+  let(:connection) { stub('Connection', :select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
+  let(:notification) { stub }
+  let(:http) { stub(:shutdown => nil)}
+  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+
+  before do
+    Rapns::Daemon::Apns::Connection.stub(:new => connection)
+    Rapns::Daemon::Apns::Delivery.stub(:perform)
+    delivery_handler.queue = queue
+    queue.push(notification)
+  end
+
+  it "instantiates a new connection" do
+    Rapns::Daemon::Apns::Connection.should_receive(:new).with(app.name, host, port, certificate, password)
+    Rapns::Daemon::Apns::DeliveryHandler.new(app, host, port)
+  end
+
+  it 'performs delivery of an notification' do
+    Rapns::Daemon::Apns::Delivery.should_receive(:perform).with(app, connection, notification)
+    delivery_handler.start
+    delivery_handler.stop
+  end
+
+  it "connects the socket when instantiated" do
+    connection.should_receive(:connect)
+    Rapns::Daemon::Apns::DeliveryHandler.new(app, host, port)
+    delivery_handler.start
+    delivery_handler.stop
+  end
+
+  it 'closes the connection stopped' do
+    connection.should_receive(:close)
+    delivery_handler.start
+    delivery_handler.stop
+  end
+end