rpush 1.0.0 → 2.0.0.beta1

data/lib/rpush/payload_data_size_validator.rb

@@ -1,10 +0,0 @@
-module Rpush
-  class PayloadDataSizeValidator < ActiveModel::Validator
-    def validate(record)
-      limit = options[:limit] || 1024
-      if !record.data.nil? && record.payload_data_size > limit
-        record.errors[:base] << "Notification payload data cannot be larger than #{limit} bytes."
-      end
-    end
-  end
-end

data/lib/rpush/railtie.rb

@@ -1,11 +0,0 @@
-require 'rails'
-
-module MyPlugin
-  class Railtie < Rails::Railtie
-    railtie_name :rpush
-
-    rake_tasks do
-      load "tasks/rpush.rake"
-    end
-  end
-end

data/lib/rpush/registration_ids_count_validator.rb

@@ -1,10 +0,0 @@
-module Rpush
-  class RegistrationIdsCountValidator < ActiveModel::Validator
-    def validate(record)
-      limit = options[:limit] || 100
-      if record.registration_ids && record.registration_ids.size > limit
-        record.errors[:base] << "Number of registration_ids cannot be larger than #{limit}."
-      end
-    end
-  end
-end

data/lib/rpush/wpns/app.rb

@@ -1,9 +0,0 @@
-module Rpush
-  module Wpns
-    class App < Rpush::App
-      def service_name
-        'wpns'
-      end
-    end
-  end
-end

data/lib/rpush/wpns/notification.rb

@@ -1,26 +0,0 @@
-module Rpush
-  module Wpns
-    class Notification < Rpush::Notification
-      validates :uri, presence: true
-      validates :uri, format: { with: /https?:\/\/[\S]+/ }
-      validates :alert, presence: true
-
-      def as_json
-        json = {
-          'message' => alert,
-          'uri'     => uri
-        }
-
-        if collapse_key
-          json['consolidationKey'] = collapse_key
-        end
-
-        json
-      end
-
-      def uri_is_valid?
-        return (/https?:\/\/[\S]+/.match(uri) != nil)
-      end
-    end
-  end
-end

data/lib/tasks/cane.rake

@@ -1,18 +0,0 @@
-begin
-  require 'cane/rake_task'
-
-  desc "Run cane to check quality metrics"
-  Cane::RakeTask.new(:quality) do |cane|
-    cane.add_threshold 'coverage/covered_percent', :>=, 98
-    cane.no_style = false
-    cane.style_measure = 1000
-    cane.no_doc = true
-    cane.abc_max = 20
-  end
-
-  namespace :spec do
-    task :cane => ['spec', 'quality']
-  end
-rescue LoadError
-  warn "cane not available, quality task not provided."
-end

data/lib/tasks/rpush.rake

@@ -1,16 +0,0 @@
-namespace :rpush do
-  namespace :notifications do
-    desc "Delete completed notifications older than number of days (DAYS > 0)"
-    task :clean => :environment do
-      date = (ENV['DAYS'].blank? || ENV['DAYS'].to_i <= 0)  ? nil : Time.zone.now.end_of_day - (ENV['DAYS'].to_i).days
-
-      if(date.nil?)
-        puts "DAYS is required and must be greater than 0"
-      else
-        puts "BEG: Delete completed notifications before '#{date}'\n"
-        deleted_count = Rpush::Notification.completed_and_older_than(date).delete_all
-        puts "END: Deleted #{deleted_count} notifications"
-      end
-    end
-  end
-end

data/spec/unit/apns/app_spec.rb

@@ -1,29 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::App do
-  it 'does not validate an app with an invalid certificate' do
-    app = Rpush::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::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::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::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/apns/feedback_spec.rb

@@ -1,9 +0,0 @@
-require "unit_spec_helper"
-
-describe Rpush::Apns::Feedback do
-  it "should validate the format of the device_token" do
-    notification = Rpush::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/apns/notification_spec.rb

@@ -1,208 +0,0 @@
-# encoding: US-ASCII
-
-require "unit_spec_helper"
-require 'unit/notification_shared.rb'
-
-describe Rpush::Apns::Notification do
-  it_should_behave_like 'an Notification subclass'
-
-  let(:app) { Rpush::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
-  let(:notification_class) { Rpush::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 = Rpush::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::Apns::Notification, "when assigning the device token" do
-  it "should strip spaces from the given string" do
-    notification = Rpush::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::Apns::Notification.new(:device_token => "<omg>")
-    notification.device_token.should eq "omg"
-  end
-end
-
-describe Rpush::Apns::Notification, "as_json" do
-  it "should include the alert if present" do
-    notification = Rpush::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::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::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::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::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::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::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::Apns::Notification.new
-    notification.attributes_for_device = {: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::Apns::Notification.new
-    notification.attributes_for_device = {:omg => {:ilike => :hashes}}
-    notification.as_json["omg"]["ilike"].should eq "hashes"
-  end
-
-end
-
-describe Rpush::Apns::Notification, 'MDM' do
-  let(:magic) { 'abc123' }
-  let(:notification) { Rpush::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::Apns::Notification, 'content-available' do
-  let(:notification) { Rpush::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::Apns::Notification, "to_binary" do
-  it "should correctly convert the notification to binary" do
-    notification = Rpush::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 = Rpush::Apns::App.new(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT)
-    notification.stub(:id).and_return(1234)
-    notification.to_binary.should eq "\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 Rpush::Apns::Notification, "bug #31" do
-  it 'does not confuse a JSON looking string as JSON' do
-    notification = Rpush::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::Apns::Notification.new
-    notification.stub(:has_attribute? => false)
-    notification.alert = "{\"one\":2}"
-    notification.alert.should eq ({"one" => 2})
-  end
-end
-
-describe Rpush::Apns::Notification, "bug #35" do
-  it "should limit payload size to 256 bytes but not the entire packet" do
-    notification = Rpush::Apns::Notification.new do |n|
-      n.device_token = "a" * 64
-      n.alert = "a" * 210
-      n.app = Rpush::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT)
-    end
-
-    notification.to_binary(:for_validation => true).bytesize.should > 256
-    notification.payload_size.should < 256
-    notification.should be_valid
-  end
-end
-
-describe Rpush::Apns::Notification, "multi_json usage" do
-  describe Rpush::Apns::Notification, "alert" do
-    it "should call MultiJson.load when multi_json version is 1.3.0" do
-      notification = Rpush::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::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/app_spec.rb

@@ -1,30 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::App do
-  it 'validates the uniqueness of name within type and environment' do
-    Rpush::Apns::App.create!(:name => 'test', :environment => 'production', :certificate => TEST_CERT)
-    app = Rpush::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::Apns::App.new(:name => 'test', :environment => 'development', :certificate => TEST_CERT)
-    app.valid?.should be_true
-
-    app = Rpush::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::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::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/daemon/apns/disconnection_error_spec.rb

@@ -1,18 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Apns::DisconnectionError do
-  let(:error) { Rpush::Apns::DisconnectionError.new }
-
-  it 'returns a nil error code' do
-    error.code.should be_nil
-  end
-
-  it 'contains an error description' do
-    error.description
-  end
-
-  it 'returns a message' do
-    error.message
-    error.to_s
-  end
-end

data/spec/unit/daemon/interruptible_sleep_spec.rb

@@ -1,68 +0,0 @@
-require "unit_spec_helper"
-
-describe Rpush::Daemon::InterruptibleSleep do
-
-  let(:rd) { double(:close => nil) }
-  let(:wr) { double(:close => nil) }
-
-  subject { Rpush::Daemon::InterruptibleSleep.new }
-
-  it 'creates a new pipe' do
-    IO.should_receive(:pipe)
-    subject
-  end
-
-  it 'selects on the reader' do
-    IO.stub(:pipe => [rd, wr])
-    IO.should_receive(:select).with([rd], nil, nil, 1)
-    subject.sleep(1)
-  end
-
-  it 'closes the writer' do
-    IO.stub(:pipe => [rd, wr])
-    rd.should_receive(:close)
-    wr.should_receive(:close)
-    subject.close
-  end
-
-  it 'returns false when timeout occurs' do
-    expect(subject.sleep(0.01)).to be_false
-  end
-
-  it 'returns true when sleep does not timeout' do
-    subject.interrupt_sleep
-    expect(subject.sleep(0.01)).to be_true
-  end
-
-  context 'with UDP socket connected' do
-    before :each do
-      @host, @port = subject.enable_wake_on_udp('127.0.0.1', 0)
-    end
-
-    it 'times out with no udp activity' do
-      expect(subject.sleep(0.01)).to be_false
-    end
-
-    unless defined? JRUBY_VERSION
-      it 'wakes on UDPSocket' do
-        waker = UDPSocket.new
-        waker.connect(@host, @port)
-        waker.write('x')
-        expect(subject.sleep(0.01)).to be_true
-      end
-
-      it 'consumes all data on udp socket' do
-        waker = UDPSocket.new
-        waker.connect(@host, @port)
-        waker.send('x', 0)
-        waker.send('x', 0)
-        waker.send('x', 0)
-        # true since there is data to be read => no timeout
-        expect(subject.sleep(0.01)).to be_true
-        # false since data is consumed => wait for full timeout
-        expect(subject.sleep(0.01)).to be_false
-      end
-    end
-  end
-
-end