rpush 1.0.0-java → 2.0.0-java

data/spec/functional/wpns_spec.rb

@@ -1,6 +1,6 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
-describe 'GCM' do
+describe 'WPNs' do
   let(:app) { Rpush::Wpns::App.new }
   let(:notification) { Rpush::Wpns::Notification.new }
   let(:response) { double(Net::HTTPResponse, code: 200) }
@@ -15,14 +15,11 @@ describe 'GCM' do
     notification.alert = 'test'
     notification.save!
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
-
     Net::HTTP::Persistent.stub(new: http)
   end
 
   it 'delivers a notification successfully' do
-    response.stub(to_hash: {'x-notificationstatus' => ['Received']})
+    response.stub(to_hash: { 'x-notificationstatus' => ['Received'] })
 
     expect do
       Rpush.push

data/spec/functional_spec_helper.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+
+def functional_example?(example)
+  path = example.metadata[:example_group][:file_path]
+  path =~ /spec\/functional/
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Modis.with_connection do |redis|
+      redis.keys('rpush:*').each { |key| redis.del(key) }
+    end
+
+    if functional_example?(example)
+      Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
+      Rpush.config.logger = ::Logger.new(STDOUT)
+    end
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean if functional_example?(example)
+  end
+end

data/spec/integration/rpush_spec.rb

@@ -0,0 +1,13 @@
+# describe "Rpush" do
+
+#     before :all do
+#         `vagrant up`
+#         # TODO: Upload current directory.
+#         # TODO: Use Net::SSH
+#         `vagrant ssh 'cd rpush; git fetch origin; git reset --hard origin/master; sh tools/run_docker.sh'`
+#     end
+
+#     it 'can be installed and successfully delivers a notification' do
+#         # Can now SSH to the Docker instance with; ssh -i docker_key root@localhost -p 2100
+#     end
+# end

data/spec/integration/support/gcm_success_response.json

@@ -0,0 +1 @@
+{"results":[{"message_id": "123"}]}

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+ENV['RAILS_ENV'] = 'test'
+client = (ENV['CLIENT'] || :active_record).to_sym
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+unless ENV['TRAVIS'] && ENV['QUALITY'] == 'false'
+  begin
+    require './spec/support/simplecov_helper'
+    include SimpleCovHelper
+    start_simple_cov("rpush-#{client}-#{RUBY_VERSION}")
+  rescue LoadError
+    puts "Coverage disabled."
+  end
+end
+
+require 'rpush'
+require 'rpush/daemon'
+require 'rpush/client/redis'
+require 'rpush/client/active_record'
+require 'rpush/daemon/store/active_record'
+require 'rpush/daemon/store/redis'
+
+require 'support/active_record_setup'
+
+RAILS_ROOT = '/tmp/rails_root'
+
+Rpush.configure do |config|
+  config.client = client
+  config.log_dir = RAILS_ROOT
+end
+
+RPUSH_CLIENT = Rpush.config.client
+
+def active_record?
+  Rpush.config.client == :active_record
+end
+
+path = File.join(File.dirname(__FILE__), 'support')
+TEST_CERT = File.read(File.join(path, 'cert_without_password.pem'))
+TEST_CERT_WITH_PASSWORD = File.read(File.join(path, 'cert_with_password.pem'))
+
+def after_example_cleanup
+  Rpush.logger = nil
+  Rpush::Daemon.store = nil
+  Rpush::Deprecation.muted do
+    Rpush.config.set_defaults if Rpush.config.is_a?(Rpush::Configuration)
+    Rpush.config.client = RPUSH_CLIENT
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Rails.stub(root: RAILS_ROOT)
+  end
+
+  config.after(:each) do
+    after_example_cleanup
+  end
+end

data/spec/support/active_record_setup.rb

@@ -0,0 +1,48 @@
+require 'active_record'
+
+jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+SPEC_ADAPTER = ENV['ADAPTER'] || 'postgresql'
+SPEC_ADAPTER = 'jdbc' + SPEC_ADAPTER if jruby
+
+require 'yaml'
+db_config = YAML.load_file(File.expand_path("config/database.yml", File.dirname(__FILE__)))
+
+if db_config[SPEC_ADAPTER].nil?
+  puts "No such adapter '#{SPEC_ADAPTER}'. Valid adapters are #{db_config.keys.join(', ')}."
+  exit 1
+end
+
+if ENV['TRAVIS']
+  db_config[SPEC_ADAPTER]['username'] = 'postgres'
+else
+  require 'etc'
+  username = SPEC_ADAPTER =~ /mysql/ ? 'root' : Etc.getlogin
+  db_config[SPEC_ADAPTER]['username'] = username
+end
+
+puts "Using #{SPEC_ADAPTER} adapter."
+
+ActiveRecord::Base.configurations = { "test" => db_config[SPEC_ADAPTER] }
+ActiveRecord::Base.establish_connection(db_config[SPEC_ADAPTER])
+
+require 'generators/templates/add_rpush'
+require 'generators/templates/rpush_2_0_0_updates'
+
+migrations = [AddRpush, Rpush200Updates]
+
+unless ENV['TRAVIS']
+  migrations.reverse.each do |m|
+    begin
+      m.down
+    rescue ActiveRecord::StatementInvalid => e
+      p e
+    end
+  end
+end
+
+migrations.each(&:up)
+
+Rpush::Client::ActiveRecord::Notification.reset_column_information
+Rpush::Client::ActiveRecord::App.reset_column_information
+Rpush::Client::ActiveRecord::Apns::Feedback.reset_column_information

data/spec/support/install.sh

@@ -1,20 +1,33 @@
+set -ev
 cp -R /mnt/rpush /rpush
-gem install --no-ri --no-rdoc rails
 cd /tmp
 export HOME=/
 export RAILS_NAME=rpush_`date +"%Y%m%d%H%M%S"`
+mysqladmin create `echo $RAILS_NAME`_development
+gem install --no-ri --no-rdoc rails bundler
 rails new $RAILS_NAME -BJTS -d mysql
 cd $RAILS_NAME
 for gem in sdoc coffee-rails uglifier sass-rails jquery-rails jbuilder turbolinks
 do
-  sed -i.bak -e "s/^gem '$gem'/\# gem '$gem'/g" Gemfile
+  sed -i.bak -e "s/^[ \t]*gem '$gem'/\# gem '$gem'/g" Gemfile
 done
+
 echo 'gem "rpush", path: "/rpush"' >> Gemfile
 bundle
-/etc/init.d/mysql start
-mysqladmin create `echo $RAILS_NAME`_development
 rails g rpush
 rake db:migrate
+
+cat > gcm_server.rb <<EOF
+require 'webrick'
+server = WEBrick::HTTPServer.new(:Port => 80)
+server.mount_proc '/' do |req, res|
+  res["Content-Type"] = 'application/json'
+  res.body = File.read('/rpush/spec/integration/support/gcm_success_response.json')
+end
+server.start
+EOF
+rails runner gcm_server.rb &
+
 cat > create_app.rb <<EOF
 app = Rpush::Gcm::App.new
 app.name = "android_app"
@@ -26,7 +39,30 @@ n.app = app
 n.registration_ids = ["abc"]
 n.data = {:message => "hi mom!"}
 n.save!
+puts n.id
+EOF
+
+export NOTIFICATION_ID=`rails runner create_app.rb`
+export RPUSH_GCM_HOST='http://localhost'
+rpush development
+
+cat > check_notification_status.rb <<EOF
+n = Rpush::Gcm::Notification.find(ENV["NOTIFICATION_ID"])
+
+while true do
+  if n.failed
+    puts "FAILED"
+    break
+  elsif n.delivered
+    puts "DELIVERED"
+    break
+  else
+    STDOUT.write(".")
+    STDOUT.flush
+  end
+
+  sleep 0.2
+  n.reload
+end
 EOF
-rails runner create_app.rb
-export RPUSH_GCM_HOST=http://`/sbin/ip route | awk '/default/ { print $3 }'`
-rpush development -f
+rails runner check_notification_status.rb

data/spec/support/simplecov_helper.rb

@@ -8,13 +8,17 @@ module SimpleCovHelper
       add_filter '/lib/generators'
       command_name name
 
+      formatters = [SimpleCov::Formatter::QualityFormatter]
+
       if ENV['TRAVIS']
-        require 'coveralls'
-        formatter SimpleCov::Formatter::MultiFormatter[SimpleCov::Formatter::QualityFormatter,
-                                                       Coveralls::SimpleCov::Formatter]
-      else
-        formatter SimpleCov::Formatter::QualityFormatter
+        require 'codeclimate-test-reporter'
+
+        if CodeClimate::TestReporter.run?
+          formatters << CodeClimate::TestReporter::Formatter
+        end
       end
+
+      formatter SimpleCov::Formatter::MultiFormatter[*formatters]
     end
   end
 end

data/spec/support/simplecov_quality_formatter.rb

@@ -1,8 +1,12 @@
-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
+module SimpleCov
+  module Formatter
+    class 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
   end
-end
+end

data/spec/unit/apns_feedback_spec.rb

@@ -1,11 +1,11 @@
 require 'unit_spec_helper'
 
 describe Rpush, 'apns_feedback' do
-  let!(:app) { Rpush::Apns::App.create!(:name => 'test', :environment => 'production', :certificate => TEST_CERT) }
-  let(:receiver) { double(:check_for_feedback => nil) }
+  let!(:app) { Rpush::Apns::App.create!(name: 'test', environment: 'production', certificate: TEST_CERT) }
+  let(:receiver) { double(check_for_feedback: nil) }
 
   before do
-    Rpush::Daemon::Apns::FeedbackReceiver.stub(:new => receiver)
+    Rpush::Daemon::Apns::FeedbackReceiver.stub(new: receiver)
   end
 
   it 'initializes the store' do

data/spec/unit/{adm → client/active_record/adm}/app_spec.rb

@@ -1,8 +1,8 @@
 require 'unit_spec_helper'
 
-describe Rpush::Adm::App do
-  subject { Rpush::Adm::App.new(:name => 'test', :environment => 'development', :client_id => 'CLIENT_ID', :client_secret => 'CLIENT_SECRET') }
-  let(:existing_app) { Rpush::Adm::App.create!(:name => 'existing', :environment => 'development', :client_id => 'CLIENT_ID', :client_secret => 'CLIENT_SECRET') }
+describe Rpush::Client::ActiveRecord::Adm::App do
+  subject { Rpush::Client::ActiveRecord::Adm::App.new(name: 'test', environment: 'development', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
+  let(:existing_app) { Rpush::Client::ActiveRecord::Adm::App.create!(name: 'existing', environment: 'development', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
 
   it 'should be valid if properly instantiated' do
     subject.should be_valid

data/spec/unit/{adm → client/active_record/adm}/notification_spec.rb

@@ -1,23 +1,21 @@
 require 'unit_spec_helper'
 require 'unit/notification_shared.rb'
 
-describe Rpush::Adm::Notification do
+describe Rpush::Client::ActiveRecord::Adm::Notification do
   it_should_behave_like 'an Notification subclass'
 
-  let(:app) { Rpush::Adm::App.create!(:name => 'test', :client_id => 'CLIENT_ID', :client_secret => 'CLIENT_SECRET') }
-  let(:notification_class) { Rpush::Adm::Notification }
+  let(:app) { Rpush::Client::ActiveRecord::Adm::App.create!(name: 'test', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
+  let(:notification_class) { Rpush::Client::ActiveRecord::Adm::Notification }
   let(:notification) { notification_class.new }
-  let(:data_setter) { 'data=' }
-  let(:data_getter) { 'data' }
 
   it "has a 'data' payload limit of 6144 bytes" do
-    notification.data = { :key => "a" * 6144 }
+    notification.data = { key: "a" * 6144 }
     notification.valid?.should be_false
     notification.errors[:base].should eq ["Notification payload data cannot be larger than 6144 bytes."]
   end
 
   it 'limits the number of registration ids to 100' do
-    notification.registration_ids = ['a']*(100+1)
+    notification.registration_ids = ['a'] * (100 + 1)
     notification.valid?.should be_false
     notification.errors[:base].should eq ["Number of registration_ids cannot be larger than 100."]
   end

data/spec/unit/client/active_record/apns/app_spec.rb

@@ -0,0 +1,29 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::App do
+  it 'does not validate an app with an invalid certificate' do
+    app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: 'foo')
+    app.valid?
+    app.errors[:certificate].should eq ['Certificate value must contain a certificate and a private key.']
+  end
+
+  it 'validates a certificate without a password' do
+    app = Rpush::Client::ActiveRecord::Apns::App.new name: 'test', environment: 'development', certificate: TEST_CERT
+    app.valid?
+    app.errors[:certificate].should eq []
+  end
+
+  it 'validates a certificate with a password' do
+    app = Rpush::Client::ActiveRecord::Apns::App.new name: 'test', environment: 'development',
+                                                     certificate: TEST_CERT_WITH_PASSWORD, password: 'fubar'
+    app.valid?
+    app.errors[:certificate].should eq []
+  end
+
+  it 'validates a certificate with an incorrect password' do
+    app = Rpush::Client::ActiveRecord::Apns::App.new name: 'test', environment: 'development',
+                                                     certificate: TEST_CERT_WITH_PASSWORD, password: 'incorrect'
+    app.valid?
+    app.errors[:certificate].should eq ["Certificate value must contain a certificate and a private key."]
+  end
+end

data/spec/unit/client/active_record/apns/feedback_spec.rb

@@ -0,0 +1,9 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Apns::Feedback do
+  it 'validates the format of the device_token' do
+    notification = Rpush::Client::ActiveRecord::Apns::Feedback.new(device_token: "{$%^&*()}")
+    notification.valid?.should be_false
+    notification.errors[:device_token].include?("is invalid").should be_true
+  end
+end

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

@@ -0,0 +1,231 @@
+# encoding: US-ASCII
+
+require "unit_spec_helper"
+require 'unit/notification_shared.rb'
+
+describe Rpush::Client::ActiveRecord::Apns::Notification do
+  it_should_behave_like 'an Notification subclass'
+
+  let(:app) { Rpush::Client::ActiveRecord::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
+  let(:notification_class) { Rpush::Client::ActiveRecord::Apns::Notification }
+  let(:notification) { notification_class.new }
+
+  it "should validate the format of the device_token" do
+    notification = Rpush::Client::ActiveRecord::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.device_token = "a" * 64
+    notification.alert = "way too long!" * 100
+    notification.valid?.should be_false
+    notification.errors[:base].include?("APN notification cannot be larger than 256 bytes. Try condensing your alert and device attributes.").should be_true
+  end
+
+  it "should default the sound to 'default'" do
+    notification.sound.should eq('default')
+  end
+
+  it "should default the expiry to 1 day" do
+    notification.expiry.should eq 1.day.to_i
+  end
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, "when assigning the device token" do
+  it "should strip spaces from the given string" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(device_token: "o m g")
+    notification.device_token.should eq "omg"
+  end
+
+  it "should strip chevrons from the given string" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(device_token: "<omg>")
+    notification.device_token.should eq "omg"
+  end
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, "as_json" do
+  it "should include the alert if present" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: "hi mom")
+    notification.as_json["aps"]["alert"].should eq "hi mom"
+  end
+
+  it "should not include the alert key if the alert is not present" do
+    notification = Rpush::Client::ActiveRecord::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 = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: { 'body' => "hi mom", 'alert-loc-key' => "View" })
+    notification.as_json["aps"]["alert"].should eq('body' => "hi mom", 'alert-loc-key' => "View")
+  end
+
+  it "should include the badge if present" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(badge: 6)
+    notification.as_json["aps"]["badge"].should eq 6
+  end
+
+  it "should not include the badge key if the badge is not present" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(badge: nil)
+    notification.as_json["aps"].key?("badge").should be_false
+  end
+
+  it "should include the sound if present" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: "my_sound.aiff")
+    notification.as_json["aps"]["alert"].should eq "my_sound.aiff"
+  end
+
+  it "should not include the sound key if the sound is not present" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(sound: false)
+    notification.as_json["aps"].key?("sound").should be_false
+  end
+
+  it "should include attributes for the device" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
+    notification.data = { omg: :lol, wtf: :dunno }
+    notification.as_json["omg"].should eq "lol"
+    notification.as_json["wtf"].should eq "dunno"
+  end
+
+  it "should allow attributes to include a hash" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
+    notification.data = { omg: { ilike: :hashes } }
+    notification.as_json["omg"]["ilike"].should eq "hashes"
+  end
+
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, 'MDM' do
+  let(:magic) { 'abc123' }
+  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
+
+  it 'includes the mdm magic in the payload' do
+    notification.mdm = magic
+    notification.as_json.should eq('mdm' => magic)
+  end
+
+  it 'does not include aps attribute' do
+    notification.alert = "i'm doomed"
+    notification.mdm = magic
+    notification.as_json.key?('aps').should be_false
+  end
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, 'content-available' do
+  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
+
+  it 'includes content-available in the payload' do
+    notification.content_available = true
+    notification.as_json['aps']['content-available'].should eq 1
+  end
+
+  it 'does not include content-available in the payload if not set' do
+    notification.as_json['aps'].key?('content-available').should be_false
+  end
+
+  it 'does not include content-available as a non-aps attribute' do
+    notification.content_available = true
+    notification.as_json.key?('content-available').should be_false
+  end
+
+  it 'does not overwrite existing attributes for the device' do
+    notification.data = { hi: :mom }
+    notification.content_available = true
+    notification.as_json['aps']['content-available'].should eq 1
+    notification.as_json['hi'].should eq 'mom'
+  end
+
+  it 'does not overwrite the content-available flag when setting attributes for the device' do
+    notification.content_available = true
+    notification.data = { hi: :mom }
+    notification.as_json['aps']['content-available'].should eq 1
+    notification.as_json['hi'].should eq 'mom'
+  end
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, 'to_binary' do
+  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
+
+  before do
+    notification.device_token = "a" * 64
+    notification.id = 1234
+  end
+
+  it 'uses APNS_PRIORITY_CONSERVE_POWER if content-available is the only key' do
+    notification.alert = nil
+    notification.badge = nil
+    notification.sound = nil
+    notification.content_available = true
+    bytes = notification.to_binary.bytes.to_a[-4..-1]
+    bytes.first.should eq 5 # priority item ID
+    bytes.last.should eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_CONSERVE_POWER
+  end
+
+  it 'uses APNS_PRIORITY_IMMEDIATE if content-available is not the only key' do
+    notification.alert = "New stuff!"
+    notification.badge = nil
+    notification.sound = nil
+    notification.content_available = true
+    bytes = notification.to_binary.bytes.to_a[-4..-1]
+    bytes.first.should eq 5 # priority item ID
+    bytes.last.should eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_IMMEDIATE
+  end
+
+  it "should correctly convert the notification to binary" do
+    notification.sound = "1.aiff"
+    notification.badge = 3
+    notification.alert = "Don't panic Mr Mainwaring, don't panic!"
+    notification.data = { hi: :mom }
+    notification.expiry = 86_400 # 1 day, \x00\x01Q\x80
+    notification.priority = Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_IMMEDIATE
+    notification.app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'my_app', environment: 'development', certificate: TEST_CERT)
+    notification.to_binary.should eq "\x02\x00\x00\x00\x99\x01\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\x02\x00a{\"aps\":{\"alert\":\"Don't panic Mr Mainwaring, don't panic!\",\"badge\":3,\"sound\":\"1.aiff\"},\"hi\":\"mom\"}\x03\x00\x04\x00\x00\x04\xD2\x04\x00\x04\x00\x01Q\x80\x05\x00\x01\n"
+  end
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, "bug #31" do
+  it 'does not confuse a JSON looking string as JSON' do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
+    notification.alert = "{\"one\":2}"
+    notification.alert.should eq "{\"one\":2}"
+  end
+
+  it 'does confuse a JSON looking string as JSON if the alert_is_json attribute is not present' do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
+    notification.stub(:has_attribute? => false)
+    notification.alert = "{\"one\":2}"
+    notification.alert.should eq('one' => 2)
+  end
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, "bug #35" do
+  it "should limit payload size to 256 bytes but not the entire packet" do
+    notification = Rpush::Client::ActiveRecord::Apns::Notification.new do |n|
+      n.device_token = "a" * 64
+      n.alert = "a" * 210
+      n.app = Rpush::Client::ActiveRecord::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT)
+    end
+
+    notification.to_binary(for_validation: true).bytesize.should be > 256
+    notification.payload_size.should be < 256
+    notification.should be_valid
+  end
+end
+
+describe Rpush::Client::ActiveRecord::Apns::Notification, "multi_json usage" do
+  describe Rpush::Client::ActiveRecord::Apns::Notification, "alert" do
+    it "should call MultiJson.load when multi_json version is 1.3.0" do
+      notification = Rpush::Client::ActiveRecord::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 = Rpush::Client::ActiveRecord::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
+end

data/spec/unit/client/active_record/app_spec.rb

@@ -0,0 +1,30 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::App do
+  it 'validates the uniqueness of name within type and environment' do
+    Rpush::Client::ActiveRecord::Apns::App.create!(name: 'test', environment: 'production', certificate: TEST_CERT)
+    app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'production', certificate: TEST_CERT)
+    app.valid?.should be_false
+    app.errors[:name].should eq ['has already been taken']
+
+    app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: TEST_CERT)
+    app.valid?.should be_true
+
+    app = Rpush::Client::ActiveRecord::Gcm::App.new(name: 'test', environment: 'production', auth_key: TEST_CERT)
+    app.valid?.should be_true
+  end
+
+  context 'validating certificates' do
+    it 'rescues from certificate error' do
+      app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: 'bad')
+      expect { app.valid? }.not_to raise_error
+      expect(app.valid?).to be_false
+    end
+
+    it 'raises other errors' do
+      app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: 'bad')
+      OpenSSL::X509::Certificate.stub(:new).and_raise(NameError, 'simulating no openssl')
+      expect { app.valid? }.to raise_error(NameError)
+    end
+  end
+end

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

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