jirapong-apn_on_rails 0.4.4

data/lib/generators/apn_on_rails/install/templates/011_make_device_token_index_nonunique.rb

@@ -0,0 +1,11 @@
+class MakeDeviceTokenIndexNonunique < ActiveRecord::Migration
+  def self.up
+    remove_index :apn_devices, :column => :token
+    add_index :apn_devices, :token
+  end
+
+  def self.down
+    remove_index :apn_devices, :column => :token
+    add_index :apn_devices, :token, :unique => true
+  end
+end

data/lib/generators/apn_on_rails/install/templates/012_add_launch_notification_to_apn_pull_notifications.rb

@@ -0,0 +1,9 @@
+class AddLaunchNotificationToApnPullNotifications < ActiveRecord::Migration
+  def self.up
+    add_column :apn_pull_notifications, :launch_notification, :boolean
+  end
+
+  def self.down
+    remove_column :apn_pull_notifications, :launch_notification
+  end
+end

data/spec/active_record/setup_ar.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'active_record'
+require 'logger'
+
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::INFO
+ActiveRecord::Base.logger = logger
+
+db_file = File.join(File.dirname(__FILE__), 'test.db')
+FileUtils.rm(db_file) if File.exists?(db_file)
+
+ActiveRecord::Base.establish_connection({
+  :adapter => 'sqlite3',
+  :database => db_file
+})
+
+ActiveRecord::Migrator.up(File.join(File.dirname(__FILE__), '..', '..', 'generators', 'templates', 'apn_migrations'))
+
+# raise hell

data/spec/apn_on_rails/app/models/apn/app_spec.rb

@@ -0,0 +1,230 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper.rb')
+
+describe APN::App do
+
+  describe 'send_notifications' do
+  
+    it 'should send the unsent notifications' do
+    
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      notifications = [NotificationFactory.create({:device_id => device.id}), 
+                       NotificationFactory.create({:device_id => device.id})]
+                       
+     notifications.each_with_index do |notify, i|
+       notify.stub(:message_for_sending).and_return("message-#{i}")
+       notify.should_receive(:sent_at=).with(instance_of(Time))
+       notify.should_receive(:save)
+     end
+      
+      APN::App.should_receive(:all).once.and_return([app])                 
+      app.should_receive(:cert).twice.and_return(app.apn_dev_cert)
+      
+      APN::Device.should_receive(:find_each).twice.and_yield(device)
+      
+      device.should_receive(:unsent_notifications).and_return(notifications,[])
+      
+      
+      ssl_mock = mock('ssl_mock')
+      ssl_mock.should_receive(:write).with('message-0')
+      ssl_mock.should_receive(:write).with('message-1')
+      APN::Connection.should_receive(:open_for_delivery).twice.and_yield(ssl_mock, nil)
+      APN::App.send_notifications
+    
+    end
+  
+  end
+  
+  describe 'send_notifications_not_associated_with_an_app' do 
+    
+    it 'should send unsent notifications that are associated with devices that are not with any app' do 
+      RAILS_ENV = 'staging'
+      device = DeviceFactory.create
+      device.app_id = nil
+      device.save
+      APN::App.all.each { |a| a.destroy }
+      notifications = [NotificationFactory.create({:device_id => device.id}), 
+                       NotificationFactory.create({:device_id => device.id})]
+                   
+       notifications.each_with_index do |notify, i|
+         notify.stub(:message_for_sending).and_return("message-#{i}")
+         notify.should_receive(:sent_at=).with(instance_of(Time))
+         notify.should_receive(:save)
+       end  
+   
+       APN::Device.should_receive(:find_each).and_yield(device)
+       device.should_receive(:unsent_notifications).and_return(notifications)
+  
+       ssl_mock = mock('ssl_mock')
+       ssl_mock.should_receive(:write).with('message-0')
+       ssl_mock.should_receive(:write).with('message-1')
+       APN::Connection.should_receive(:open_for_delivery).and_yield(ssl_mock, nil)
+       APN::App.send_notifications
+    end
+  end               
+  
+  describe 'send_group_notifications' do
+  
+    it 'should send the unsent group notifications' do
+    
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      group =   GroupFactory.create({:app_id => app.id})
+      device_grouping = DeviceGroupingFactory.create({:group_id => group.id,:device_id => device.id})
+      gnotys = [GroupNotificationFactory.create({:group_id => group.id}), 
+                GroupNotificationFactory.create({:group_id => group.id})]
+      gnotys.each_with_index do |gnoty, i|
+        gnoty.stub!(:message_for_sending).and_return("message-#{i}")
+        gnoty.should_receive(:sent_at=).with(instance_of(Time))
+        gnoty.should_receive(:save)
+      end
+    
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:unsent_group_notifications).at_least(:once).and_return(gnotys)
+      app.should_receive(:cert).twice.and_return(app.apn_dev_cert)
+      
+      ssl_mock = mock('ssl_mock')
+      ssl_mock.should_receive(:write).with('message-0')
+      ssl_mock.should_receive(:write).with('message-1')
+      APN::Connection.should_receive(:open_for_delivery).and_yield(ssl_mock, nil)
+    
+      APN::App.send_group_notifications
+    
+    end
+  
+  end
+  
+  describe 'send single group notification' do 
+    
+    it 'should send the argument group notification' do 
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      group =   GroupFactory.create({:app_id => app.id})
+      device_grouping = DeviceGroupingFactory.create({:group_id => group.id,:device_id => device.id})
+      gnoty = GroupNotificationFactory.create({:group_id => group.id})
+      gnoty.stub!(:message_for_sending).and_return("message-0")
+      gnoty.should_receive(:sent_at=).with(instance_of(Time))
+      gnoty.should_receive(:save)
+    
+      app.should_receive(:cert).at_least(:once).and_return(app.apn_dev_cert)
+      
+      ssl_mock = mock('ssl_mock')
+      ssl_mock.should_receive(:write).with('message-0')
+      APN::Connection.should_receive(:open_for_delivery).and_yield(ssl_mock, nil)
+    
+      app.send_group_notification(gnoty)   
+    end
+    
+  end
+  
+  describe 'nil cert when sending notifications' do 
+    
+    it 'should raise an exception for sending notifications for an app with no cert' do
+      app = AppFactory.create
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        APN::App.send_notifications
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'nil cert when sending group notifications' do 
+    
+    it 'should raise an exception for sending group notifications for an app with no cert' do
+      app = AppFactory.create
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        APN::App.send_group_notifications
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'nil cert when sending single group notification' do 
+    
+    it 'should raise an exception for sending group notifications for an app with no cert' do
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      group =   GroupFactory.create({:app_id => app.id})
+      device_grouping = DeviceGroupingFactory.create({:group_id => group.id,:device_id => device.id})
+      gnoty = GroupNotificationFactory.create({:group_id => group.id})
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        app.send_group_notification(gnoty)
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'process_devices' do
+    
+    it 'should destroy devices that have a last_registered_at date that is before the feedback_at date' do
+      app = AppFactory.create
+      devices = [DeviceFactory.create(:app_id => app.id, :last_registered_at => 1.week.ago, :feedback_at => Time.now),
+                 DeviceFactory.create(:app_id => app.id, :last_registered_at => 1.week.from_now, :feedback_at => Time.now)]
+      puts "device ids are #{devices[0].id} and #{devices[1].id}"
+      devices[0].last_registered_at = 1.week.ago
+      devices[0].save
+      devices[1].last_registered_at = 1.week.from_now
+      devices[1].save
+      APN::Feedback.should_receive(:devices).twice.and_return(devices)
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).twice.and_return(app.apn_dev_cert)
+      lambda {
+        APN::App.process_devices
+      }.should change(APN::Device, :count).by(-1)
+    end
+    
+  end
+  
+  describe 'process_devices for global app' do 
+    
+    it 'should destroy devices that have a last_registered_at date that is before the feedback_at date that have no app' do 
+      device = DeviceFactory.create(:app_id => nil, :last_registered_at => 1.week.ago, :feedback_at => Time.now)
+      device.app_id = nil
+      device.last_registered_at = 1.week.ago
+      device.save
+      APN::Feedback.should_receive(:devices).and_return([device])
+      APN::App.should_receive(:all).and_return([])
+      lambda { 
+        APN::App.process_devices
+      }.should change(APN::Device, :count).by(-1)
+    end
+  end
+  
+  describe 'nil cert when processing devices' do 
+    
+    it 'should raise an exception for processing devices for an app with no cert' do
+      app = AppFactory.create
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        APN::App.process_devices
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'cert for production environment' do 
+    
+    it 'should return the production cert for the app' do 
+      app = AppFactory.create
+      RAILS_ENV = 'production'
+      app.cert.should == app.apn_prod_cert
+    end
+    
+  end
+  
+  describe 'cert for development and staging environment' do 
+    
+    it 'should return the development cert for the app' do 
+      app = AppFactory.create
+      RAILS_ENV = 'staging'
+      app.cert.should == app.apn_dev_cert
+    end
+  end
+
+end

data/spec/apn_on_rails/app/models/apn/device_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper.rb')
+
+describe APN::Device do
+  
+  describe 'token' do
+    
+    it 'should be unique' do
+      t = APN::Device.first.token
+      device = DeviceFactory.new(:token => t)
+      device.should_not be_valid
+      device.errors['token'].should include('has already been taken')
+      
+      device = DeviceFactory.new(:token => device.token.succ)
+      device.should be_valid
+    end
+    
+    it 'should get cleansed if it contains brackets' do
+      token = DeviceFactory.random_token
+      device = DeviceFactory.new(:token => "<#{token}>")
+      device.token.should == token
+      device.token.should_not == "<#{token}>"
+    end
+    
+    it 'should be in the correct pattern' do
+      device = DeviceFactory.new(:token => '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7qz')
+      device.should be_valid
+      device.token = '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6'
+      device.should_not be_valid
+      device.token = '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7!!'
+      device.should_not be_valid
+    end
+    
+  end
+  
+  describe 'to_hexa' do
+    
+    it 'should convert the text string to hexadecimal' do
+      device = DeviceFactory.new(:token => '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7qz')
+      device.to_hexa.should == fixture_value('hexa.bin')
+    end
+    
+  end
+  
+  describe 'before_create' do
+    
+    it 'should set the last_registered_at date to Time.now' do
+      time = Time.now
+      Time.stub(:now).and_return(time)
+      device = DeviceFactory.create
+      device.last_registered_at.should_not be_nil
+      device.last_registered_at.to_s.should == time.to_s
+      
+      # ago = 1.week.ago
+      # device = DeviceFactory.create(:last_registered_at => ago)
+      # device.last_registered_at.should_not be_nil
+      # device.last_registered_at.to_s.should == ago.to_s
+    end
+    
+  end
+  
+end

data/spec/apn_on_rails/app/models/apn/group_notification_spec.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper.rb')
+
+describe APN::GroupNotification do
+  
+  describe 'alert' do
+    
+    it 'should trim the message to 150 characters' do
+      noty = APN::GroupNotification.new
+      noty.alert = 'a' * 200
+      noty.alert.should == ('a' * 147) + '...'
+    end
+    
+  end
+  
+  describe 'apple_hash' do
+    
+    it 'should return a hash of the appropriate params for Apple' do
+      noty = APN::GroupNotification.first
+      noty.apple_hash.should == {"aps" => {"badge" => 5, "sound" => "my_sound.aiff", "alert" => "Hello!"},"typ" => "1"}
+      noty.custom_properties = nil
+      noty.apple_hash.should == {"aps" => {"badge" => 5, "sound" => "my_sound.aiff", "alert" => "Hello!"}}
+      noty.badge = nil
+      noty.apple_hash.should == {"aps" => {"sound" => "my_sound.aiff", "alert" => "Hello!"}}
+      noty.alert = nil
+      noty.apple_hash.should == {"aps" => {"sound" => "my_sound.aiff"}}
+      noty.sound = nil
+      noty.apple_hash.should == {"aps" => {}}
+      noty.sound = true
+      noty.apple_hash.should == {"aps" => {"sound" => "1.aiff"}}
+    end
+    
+  end
+  
+  describe 'to_apple_json' do
+    
+    it 'should return the necessary JSON for Apple' do
+      noty = APN::GroupNotification.first
+      noty.to_apple_json.should == %{{"typ":"1","aps":{"badge":5,"sound":"my_sound.aiff","alert":"Hello!"}}}
+    end
+    
+  end
+  
+  describe 'message_for_sending' do
+    
+    it 'should create a binary message to be sent to Apple' do
+      noty = APN::GroupNotification.first
+      noty.custom_properties = nil
+      device = DeviceFactory.new(:token => '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7qz')
+      noty.message_for_sending(device).should == fixture_value('message_for_sending.bin')
+    end
+    
+    it 'should raise an APN::Errors::ExceededMessageSizeError if the message is too big' do
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      group =   GroupFactory.create({:app_id => app.id})
+      device_grouping = DeviceGroupingFactory.create({:group_id => group.id,:device_id => device.id})
+      noty = GroupNotificationFactory.new(:group_id => group.id, :sound => true, :badge => nil)
+      noty.send(:write_attribute, 'alert', 'a' * 183)
+      lambda {
+        noty.message_for_sending(device)
+      }.should raise_error(APN::Errors::ExceededMessageSizeError)
+    end
+    
+  end
+  
+end

data/spec/apn_on_rails/app/models/apn/notification_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper.rb')
+
+describe APN::Notification do
+  
+  describe 'alert' do
+    
+    it 'should trim the message to 150 characters' do
+      noty = APN::Notification.new
+      noty.alert = 'a' * 200
+      noty.alert.should == ('a' * 147) + '...'
+    end
+    
+  end
+  
+  describe 'apple_hash' do
+    
+    it 'should return a hash of the appropriate params for Apple' do
+      noty = APN::Notification.first
+      noty.apple_hash.should == {"aps" => {"badge" => 5, "sound" => "my_sound.aiff", "alert" => "Hello!"},"typ" => "1"}
+      noty.custom_properties = nil
+      noty.apple_hash.should == {"aps" => {"badge" => 5, "sound" => "my_sound.aiff", "alert" => "Hello!"}}
+      noty.badge = nil
+      noty.apple_hash.should == {"aps" => {"sound" => "my_sound.aiff", "alert" => "Hello!"}}
+      noty.alert = nil
+      noty.apple_hash.should == {"aps" => {"sound" => "my_sound.aiff"}}
+      noty.sound = nil
+      noty.apple_hash.should == {"aps" => {}}
+      noty.sound = true
+      noty.apple_hash.should == {"aps" => {"sound" => "1.aiff"}}
+    end
+    
+  end
+  
+  describe 'to_apple_json' do
+    
+    it 'should return the necessary JSON for Apple' do
+      noty = APN::Notification.first
+      noty.to_apple_json.should == %{{"typ":"1","aps":{"badge":5,"sound":"my_sound.aiff","alert":"Hello!"}}}
+    end
+    
+  end
+  
+  describe 'message_for_sending' do
+    
+    it 'should create a binary message to be sent to Apple' do
+      noty = APN::Notification.first
+      noty.custom_properties = nil
+      noty.device = DeviceFactory.new(:token => '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7qz')
+      noty.message_for_sending.should == fixture_value('message_for_sending.bin')
+    end
+    
+    it 'should raise an APN::Errors::ExceededMessageSizeError if the message is too big' do
+      noty = NotificationFactory.new(:device_id => DeviceFactory.create, :sound => true, :badge => nil)
+      noty.send(:write_attribute, 'alert', 'a' * 183)
+      lambda {
+        noty.message_for_sending
+      }.should raise_error(APN::Errors::ExceededMessageSizeError)
+    end
+    
+  end
+  
+  describe 'send_notifications' do 
+    
+    it 'should warn the user the method is deprecated and call the corresponding method on APN::App' do
+      ActiveSupport::Deprecation.should_receive(:warn)
+      APN::App.should_receive(:send_notifications)
+      APN::Notification.send_notifications
+    end
+  end
+  
+end