rpush 1.0.0-java

data/spec/unit/embed_spec.rb

@@ -0,0 +1,50 @@
+require 'unit_spec_helper'
+
+describe Rpush, 'embed' do
+  before do
+    Rpush::Daemon.stub(:start)
+    Kernel.stub(:at_exit)
+  end
+
+  it 'sets the embedded config option to true' do
+    Rpush.embed
+    Rpush.config.embedded.should be_true
+  end
+
+  it 'starts the daemon' do
+    Rpush::Daemon.should_receive(:start)
+    Rpush.embed
+  end
+
+  it 'overrides the default config options with those given as a hash' do
+    Rpush.config.push_poll = 4
+    expect { Rpush.embed(:push_poll => 2) }.to change(Rpush.config, :push_poll).to(2)
+  end
+end
+
+describe Rpush, 'shutdown' do
+  before { Rpush.config.embedded = true }
+
+  it 'shuts down the daemon' do
+    Rpush::Daemon.should_receive(:shutdown)
+    Rpush.shutdown
+  end
+end
+
+describe Rpush, 'sync' do
+  before { Rpush.config.embedded = true }
+
+  it 'syncs the AppRunner' do
+    Rpush::Daemon::AppRunner.should_receive(:sync)
+    Rpush.sync
+  end
+end
+
+describe Rpush, 'debug' do
+  before { Rpush.config.embedded = true }
+
+  it 'debugs the AppRunner' do
+    Rpush::Daemon::AppRunner.should_receive(:debug)
+    Rpush.debug
+  end
+end

data/spec/unit/gcm/app_spec.rb

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

data/spec/unit/gcm/notification_spec.rb

@@ -0,0 +1,36 @@
+require 'unit_spec_helper'
+require 'unit/notification_shared.rb'
+
+describe Rpush::Gcm::Notification do
+  it_should_behave_like 'an Notification subclass'
+
+  let(:app) { Rpush::Gcm::App.create!(:name => 'test', :auth_key => 'abc') }
+  let(:notification_class) { Rpush::Gcm::Notification }
+  let(:notification) { notification_class.new }
+  let(:data_setter) { 'data=' }
+  let(:data_getter) { 'data' }
+
+  it "has a 'data' payload limit of 4096 bytes" do
+    notification.data = { :key => "a" * 4096 }
+    notification.valid?.should be_false
+    notification.errors[:base].should eq ["Notification payload data cannot be larger than 4096 bytes."]
+  end
+
+  it 'limits the number of registration ids to 1000' do
+    notification.registration_ids = ['a']*(1000+1)
+    notification.valid?.should be_false
+    notification.errors[:base].should eq ["Number of registration_ids cannot be larger than 1000."]
+  end
+
+  it 'validates expiry is present if collapse_key is set' do
+    notification.collapse_key = 'test'
+    notification.expiry = nil
+    notification.valid?.should be_false
+    notification.errors[:expiry].should eq ['must be set when using a collapse_key']
+  end
+
+  it 'includes time_to_live in the payload' do
+    notification.expiry = 100
+    notification.as_json['time_to_live'].should eq 100
+  end
+end

data/spec/unit/logger_spec.rb

@@ -0,0 +1,127 @@
+require "unit_spec_helper"
+
+module Rails
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end
+
+module HoptoadNotifier
+  def self.notify(e)
+  end
+end
+
+describe Rpush::Logger do
+  let(:log) { double(:sync= => true) }
+
+  before do
+    Rails.stub(:root).and_return("/rails_root")
+
+    @logger_class = if defined?(ActiveSupport::BufferedLogger)
+      ActiveSupport::BufferedLogger
+    else
+      ActiveSupport::Logger
+    end
+
+    @logger = double(@logger_class.name, :info => nil, :error => nil, :level => 0, :auto_flushing => 1, :auto_flushing= => nil)
+    @logger_class.stub(:new).and_return(@logger)
+    Rails.logger = @logger
+    File.stub(:open => log)
+    FileUtils.stub(:mkdir_p => nil)
+    STDERR.stub(:puts)
+  end
+
+  it "disables logging if the log file cannot be opened" do
+    File.stub(:open).and_raise(Errno::ENOENT)
+    STDERR.should_receive(:puts).with(/No such file or directory/)
+    STDERR.should_receive(:puts).with(/Logging disabled/)
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it 'creates the log directory' do
+    FileUtils.should_receive(:mkdir_p).with('/rails_root/log')
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it "should open the a log file in the Rails log directory" do
+    File.should_receive(:open).with('/rails_root/log/rpush.log', 'a')
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it 'sets sync mode on the log descriptor' do
+    log.should_receive(:sync=).with(true)
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it 'uses the user-defined logger' do
+    my_logger = double
+    Rpush.config.logger = my_logger
+    logger = Rpush::Logger.new({})
+    my_logger.should_receive(:info)
+    logger.info('test')
+  end
+
+  it 'uses ActiveSupport::BufferedLogger if a user-defined logger is not set' do
+    if ActiveSupport.const_defined?('BufferedLogger')
+      ActiveSupport::BufferedLogger.should_receive(:new).with(log, Rails.logger.level)
+      Rpush::Logger.new(:foreground => true)
+    end
+  end
+
+  it 'uses ActiveSupport::Logger if BufferedLogger does not exist' do
+    stub_const('ActiveSupport::Logger', double)
+    ActiveSupport.stub(:const_defined? => false)
+    ActiveSupport::Logger.should_receive(:new).with(log, Rails.logger.level)
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it "should print out the msg if running in the foreground" do
+    logger = Rpush::Logger.new(:foreground => true)
+    STDOUT.should_receive(:puts).with(/hi mom/)
+    logger.info("hi mom")
+  end
+
+  it "should not print out the msg if not running in the foreground" do
+    logger = Rpush::Logger.new(:foreground => false)
+    STDOUT.should_not_receive(:puts).with(/hi mom/)
+    logger.info("hi mom")
+  end
+
+  it "should prefix log lines with the current time" do
+    now = Time.now
+    Time.stub(:now).and_return(now)
+    logger = Rpush::Logger.new(:foreground => false)
+    @logger.should_receive(:info).with(/#{Regexp.escape("[#{now.to_s(:db)}]")}/)
+    logger.info("blah")
+  end
+
+  it "should prefix error logs with the ERROR label" do
+    logger = Rpush::Logger.new(:foreground => false)
+    @logger.should_receive(:error).with(/#{Regexp.escape("[ERROR]")}/)
+    logger.error("eeek")
+  end
+
+  it "should prefix warn logs with the WARNING label" do
+    logger = Rpush::Logger.new(:foreground => false)
+    @logger.should_receive(:warn).with(/#{Regexp.escape("[WARNING]")}/)
+    logger.warn("eeek")
+  end
+
+  it "should handle an Exception instance" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rpush::Logger.new(:foreground => false)
+    @logger.should_receive(:error).with(/RuntimeError, hi mom/)
+    logger.error(e)
+  end
+
+  it 'defaults auto_flushing to true if the Rails logger does not respond to auto_flushing' do
+    rails_logger = double(:info => nil, :error => nil, :level => 0)
+    Rails.logger = rails_logger
+    @logger.auto_flushing.should be_true
+  end
+end

data/spec/unit/notification_shared.rb

@@ -0,0 +1,105 @@
+shared_examples_for "an Notification subclass" do
+  describe "when assigning data for the device" do
+    before { Rpush::Deprecation.stub(:warn) }
+
+    it "calls MultiJson.dump when multi_json responds to :dump" do
+      notification = notification_class.new
+      MultiJson.stub(:respond_to?).with(:dump).and_return(true)
+      MultiJson.should_receive(:dump).with(any_args())
+      notification.send(data_setter, { :pirates => 1 })
+    end
+
+    it "calls MultiJson.encode when multi_json does not respond to :dump" do
+      notification = notification_class.new
+      MultiJson.stub(:respond_to?).with(:dump).and_return(false)
+      MultiJson.should_receive(:encode).with(any_args())
+      notification.send(data_setter, { :ninjas => 1 })
+    end
+
+    it "raises an ArgumentError if something other than a Hash is assigned" do
+      expect do
+        notification.send(data_setter, Array.new)
+      end.to raise_error(ArgumentError, "must be a Hash")
+    end
+
+    it "encodes the given Hash as JSON" do
+      notification.send(data_setter, { :hi => "mom" })
+      notification.read_attribute(:data).should eq "{\"hi\":\"mom\"}"
+    end
+
+    it "decodes the JSON when using the reader method" do
+      notification.send(data_setter, { :hi => "mom" })
+      notification.send(data_getter).should eq ({"hi" => "mom"})
+    end
+
+    describe 'scopes' do
+      before do
+        Timecop.freeze(Time.now)
+
+        (@delivered_notification = notification_class.new(:app => app, :delivered => true, :failed => false)).save!(:validate => false)
+        (@failed_notification = notification_class.new(:app => app, :delivered => false, :failed => true)).save!(:validate => false)
+        (@new_notification = notification_class.new(:app => app, :delivered => false, :failed => false)).save!(:validate => false)
+      end
+
+      after do
+        Timecop.return
+      end
+
+      describe '.completed' do
+        it 'should return notifications that have been delivered or failed' do
+          completed_notification_ids = Rpush::Notification.completed.map(&:id)
+
+          completed_notification_ids.size.should eq 2
+          completed_notification_ids.should include(@delivered_notification.id, @failed_notification.id)
+          completed_notification_ids.should_not include(@new_notification.id)
+        end
+      end
+
+      describe '.created_before' do
+        it 'should return notifications that were created before the specified date' do
+          @delivered_notification.created_at = Time.now - 30.days - 1.second
+          @delivered_notification.save!(:validate => false)
+
+          notification_ids = Rpush::Notification.created_before(Time.now - 30.days).map(&:id)
+
+          notification_ids.size.should eq 1
+          notification_ids.should include(@delivered_notification.id)
+        end
+      end
+
+      describe '.completed_and_older_than' do
+        before do
+          @delivered_notification.created_at = Time.now - 30.days - 1.second
+          @delivered_notification.save!(:validate => false)
+
+          @failed_notification.created_at = Time.now - 20.days - 1.second
+          @failed_notification.save!(:validate => false)
+
+          @new_notification.created_at = Time.now - 30.days - 1.second
+          @new_notification.save!(:validate => false)
+        end
+
+        it 'should only include completed notifications' do
+          notification_ids = Rpush::Notification.completed_and_older_than(Time.now - 30.days).map(&:id)
+
+          notification_ids.size.should eq 1
+          notification_ids.should include(@delivered_notification.id)
+        end
+
+        it 'should not include completed notifications if not older than specified date' do
+          notification_ids = Rpush::Notification.completed_and_older_than(Time.now - 30.days).map(&:id)
+
+          notification_ids.size.should eq 1
+          notification_ids.should_not include(@failed_notification.id)
+        end
+
+        it 'should return notifications that are completed and created before the specified date' do
+          notification_ids = Rpush::Notification.completed_and_older_than(Time.now - 20.days).map(&:id)
+
+          notification_ids.size.should eq 2
+          notification_ids.should include(@delivered_notification.id, @failed_notification.id)
+        end
+      end
+    end
+  end
+end

data/spec/unit/notification_spec.rb

@@ -0,0 +1,15 @@
+require "unit_spec_helper"
+
+describe Rpush::Notification do
+  let(:notification) { Rpush::Notification.new }
+
+  it 'allows assignment of many registration IDs' do
+    notification.registration_ids = ['a', 'b']
+    notification.registration_ids.should eq ['a', 'b']
+  end
+
+  it 'allows assignment of a single registration ID' do
+    notification.registration_ids = 'a'
+    notification.registration_ids.should eq ['a']
+  end
+end

data/spec/unit/notifier_spec.rb

@@ -0,0 +1,49 @@
+require 'unit_spec_helper'
+require 'rpush/notifier'
+
+describe Rpush::Notifier do
+
+  before(:each) { @port = 5000 }
+  subject { Rpush::Notifier.new('127.0.0.1', @port) }
+  its(:socket) { should_not be_nil }
+
+  context "when connected" do
+    before :each do
+      @reader = UDPSocket.new
+      @reader.bind('127.0.0.1', 0)
+      @port = @reader.addr[1]
+    end
+
+    describe "notify" do
+      it "calls write on the socket" do
+        UDPSocket.any_instance.should_receive(:write)
+        subject.notify
+      end
+
+      it "writes data that can be read from socket" do
+        subject.notify
+        expect(@reader.recv(1)).to eq 'x'
+      end
+    end
+  end
+
+  describe "default notifier" do
+    it "creates using :connect first" do
+      Rpush.config.stub :wakeup => { :connect => '127.0.0.1', :port => 1234 }
+      Rpush::Notifier.should_receive(:new).with('127.0.0.1', 1234)
+      Rpush.notifier
+    end
+
+    it "creates using :host next" do
+      Rpush.config.stub :wakeup => { :host => '127.0.0.1', :port => 1234 }
+      Rpush::Notifier.should_receive(:new).with('127.0.0.1', 1234)
+      Rpush.notifier
+    end
+
+    it "returns nil when wakeup is not specified" do
+      Rpush.config.stub :wakeup => nil
+      Rpush::Notifier.should_not_receive(:new)
+      expect(Rpush.notifier).to be_nil
+    end
+  end
+end

data/spec/unit/push_spec.rb

@@ -0,0 +1,43 @@
+require 'unit_spec_helper'
+
+describe Rpush, 'push' do
+  before do
+    Rpush::Daemon::AppRunner.stub(:sync => nil, :wait => nil)
+    Rpush::Daemon::Feeder.stub(:start => nil)
+  end
+
+  it 'sets the push config option to true' do
+    Rpush.push
+    Rpush.config.push.should be_true
+  end
+
+  it 'initializes the store' do
+    Rpush::Daemon.should_receive(:initialize_store)
+    Rpush.push
+  end
+
+  it 'syncs the app runner' do
+    Rpush::Daemon::AppRunner.should_receive(:sync)
+    Rpush.push
+  end
+
+  it 'starts the feeder' do
+    Rpush::Daemon::Feeder.should_receive(:start)
+    Rpush.push
+  end
+
+  it 'waits on the app runner' do
+    Rpush::Daemon::AppRunner.should_receive(:wait)
+    Rpush.push
+  end
+
+  it 'stops on the app runner' do
+    Rpush::Daemon::AppRunner.should_receive(:stop)
+    Rpush.push
+  end
+
+  it 'overrides the default config options with those given as a hash' do
+    Rpush.config.batch_size = 20
+    expect { Rpush.push(:batch_size => 10) }.to change(Rpush.config, :batch_size).to(10)
+  end
+end

data/spec/unit/reflection_spec.rb

@@ -0,0 +1,30 @@
+ require 'unit_spec_helper'
+
+describe Rpush do
+  it 'yields reflections for configuration' do
+    did_yield = false
+    Rpush.reflect { |on| did_yield = true }
+    did_yield.should be_true
+  end
+
+  it 'returns all reflections' do
+    Rpush.reflections.should be_kind_of(Rpush::Reflections)
+  end
+end
+
+describe Rpush::Reflections do
+  it 'dispatches the given reflection' do
+    did_yield = false
+    Rpush.reflect do |on|
+      on.error { did_yield = true }
+    end
+    Rpush.reflections.__dispatch(:error)
+    did_yield.should be_true
+  end
+
+  it 'raises an error when trying to dispatch and unknown reflection' do
+    expect do
+      Rpush.reflections.__dispatch(:unknown)
+    end.to raise_error(Rpush::Reflections::NoSuchReflectionError)
+  end
+end

data/spec/unit/rpush_spec.rb

@@ -0,0 +1,9 @@
+require 'unit_spec_helper'
+
+describe Rpush do
+  it "lazy initializes the logger" do
+    Rpush.config.stub(:foreground => true)
+    Rpush::Logger.should_receive(:new).with(:foreground => true)
+    Rpush.logger
+  end
+end

data/spec/unit/wpns/app_spec.rb

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

data/spec/unit/wpns/notification_spec.rb

@@ -0,0 +1,30 @@
+require 'unit_spec_helper'
+require 'unit/notification_shared.rb'
+
+describe Rpush::Wpns::Notification do
+  it_should_behave_like 'an Notification subclass'
+  let(:app) { Rpush::Wpns::App.create!(:name => 'test', :auth_key => 'abc') }
+  let(:notification_class) { Rpush::Wpns::Notification }
+  let(:notification) { notification_class.new }
+  let(:data_setter) { 'data=' }
+  let(:data_getter) { 'data' }
+
+  it "should have an url in the uri parameter" do
+    notification = Rpush::Wpns::Notification.new(:uri => "somthing")
+    notification.valid?
+    notification.errors[:uri].include?("is invalid").should be_true
+  end
+
+  it "should be invalid if there's no message" do
+    notification = Rpush::Wpns::Notification.new(:alert => "")
+    notification.valid?
+    notification.errors[:alert].include?("can't be blank").should be_true
+  end
+end
+
+describe Rpush::Wpns::Notification, "when assigning the url" do
+  it "should be a valid url" do
+    notification = Rpush::Wpns::Notification.new(:alert => "abc", :uri => "some")
+    notification.uri_is_valid?.should be_false
+  end
+end

data/spec/unit_spec_helper.rb

@@ -0,0 +1,101 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'bundler'
+Bundler.require(:default)
+
+require 'active_record'
+
+unless ENV['TRAVIS'] && ENV['QUALITY'] == 'false'
+  begin
+    require './spec/support/simplecov_helper'
+    include SimpleCovHelper
+    start_simple_cov("unit-#{RUBY_VERSION}")
+  rescue LoadError
+    puts "Coverage disabled."
+  end
+end
+
+jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+$adapter = ENV['ADAPTER'] || 'postgresql'
+$adapter = 'jdbc' + $adapter if jruby
+
+DATABASE_CONFIG = YAML.load_file(File.expand_path("../config/database.yml", File.dirname(__FILE__)))
+
+if DATABASE_CONFIG[$adapter].nil?
+  puts "No such adapter '#{$adapter}'. Valid adapters are #{DATABASE_CONFIG.keys.join(', ')}."
+  exit 1
+end
+
+if ENV['TRAVIS']
+  DATABASE_CONFIG[$adapter]['username'] = 'postgres'
+else
+  require 'etc'
+  username = $adapter =~ /mysql/ ? 'root' : Etc.getlogin
+  DATABASE_CONFIG[$adapter]['username'] = username
+end
+
+puts "Using #{$adapter} adapter."
+
+ActiveRecord::Base.configurations = {"test" => DATABASE_CONFIG[$adapter]}
+ActiveRecord::Base.establish_connection(DATABASE_CONFIG[$adapter])
+
+require 'generators/templates/add_rpush'
+
+migrations = [AddRpush]
+
+migrations.reverse.each do |m|
+  begin
+    m.down
+  rescue ActiveRecord::StatementInvalid => e
+    p e
+  end
+end
+
+migrations.each(&:up)
+
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+
+require 'rpush'
+require 'rpush/daemon'
+
+Rpush::Daemon.initialize_store
+Rpush::Notification.reset_column_information
+Rpush::App.reset_column_information
+Rpush::Apns::Feedback.reset_column_information
+
+RSpec.configure do |config|
+  # config.before :suite do
+  #   PerfTools::CpuProfiler.start('/tmp/rpush_profile')
+  # end
+  # config.after :suite do
+  #   PerfTools::CpuProfiler.stop
+  # end
+
+  config.before(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.after(:each) do
+    Rpush.logger = nil
+    Rpush::Daemon.store = nil
+    Rpush::Deprecation.muted do
+      Rpush.config.set_defaults if Rpush.config.kind_of?(Rpush::Configuration)
+    end
+  end
+end
+
+# a test certificate that contains both an X509 certificate and
+# a private key, similar to those used for connecting to Apple
+# push notification servers.
+#
+# Note that we cannot validate the certificate and private key
+# because we are missing the certificate chain used to validate
+# the certificate, and this is private to Apple. So if the app
+# has a certificate and a private key in it, the only way to find
+# out if it really is valid is to connect to Apple's servers.
+
+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'))