rpush 1.0.0-java → 2.0.0-java

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/dispatcher_loop_collection_spec.rb

@@ -1,37 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Daemon::DispatcherLoopCollection do
-  let(:dispatcher_loop) { double.as_null_object }
-  let(:collection) { Rpush::Daemon::DispatcherLoopCollection.new }
-
-  it 'returns the size of the collection' do
-    collection.push(dispatcher_loop)
-    collection.size.should eq 1
-  end
-
-  it 'pops a dispatcher loop from the collection' do
-    collection.push(dispatcher_loop)
-    dispatcher_loop.should_receive(:stop)
-    dispatcher_loop.should_receive(:wakeup)
-    dispatcher_loop.should_receive(:wait)
-    collection.pop
-    collection.size.should eq 0
-  end
-
-  it 'wakes up all dispatcher loops when popping a single dispatcher_loop' do
-    collection.push(dispatcher_loop)
-    dispatcher_loop2 = double.as_null_object
-    collection.push(dispatcher_loop2)
-    dispatcher_loop.should_receive(:wakeup)
-    dispatcher_loop2.should_receive(:wakeup)
-    collection.pop
-  end
-
-  it 'stops all dispatcher  detetcloops' do
-    collection.push(dispatcher_loop)
-    dispatcher_loop.should_receive(:stop)
-    dispatcher_loop.should_receive(:wakeup)
-    dispatcher_loop.should_receive(:wait)
-    collection.stop
-  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

data/spec/unit/daemon/too_many_requests_error_spec.rb

@@ -1,14 +0,0 @@
-require "unit_spec_helper"
-
-describe Rpush::TooManyRequestsError do
-  let(:response) { double(:code => 429, :header => { 'retry-after' => 3600 }) }
-  let(:error) { Rpush::TooManyRequestsError.new(429, 12, "Too Many Requests", response) }
-
-  it "returns an informative message" do
-    error.to_s.should eq "Too many requests for 12, received error 429 (Too Many Requests) - retry after 3600"
-  end
-
-  it "returns the error code" do
-    error.code.should eq 429
-  end
-end

data/spec/unit/gcm/app_spec.rb

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

data/spec/unit/notification_spec.rb

@@ -1,15 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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/wpns/app_spec.rb

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

data/spec/unit/wpns/notification_spec.rb

@@ -1,30 +0,0 @@
-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