rhoconnect 5.5.18 → 7.4.1

data/spec/jobs/ping_job_spec.rb

@@ -1,189 +1,313 @@
-require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
-describe "PingJob" do
-  include_examples "SharedRhoconnectHelper", :rhoconnect_data => true
+describe 'PingJob' do
+  include_examples 'SharedRhoconnectHelper', :rhoconnect_data => true
 
   before(:each) do
     @u1_fields = {:login => 'testuser1'}
     @u1 = User.create(@u1_fields)
     @u1.password = 'testpass1'
     @c1_fields = {
-      :device_type => 'Apple',
-      :device_pin => 'abcde',
-      :device_port => '3333',
-      :user_id => @u1.id,
-      :app_id => @a.id
+        :device_type => 'Apple',
+        :device_pin => 'abcde',
+        :device_port => '3333',
+        :user_id => @u1.id,
+        :app_id => @a.id
     }
-    @c1 = Client.create(@c1_fields,{:source_name => @s_fields[:name]})
+    @c1 = Client.create(@c1_fields, {:source_name => @s_fields[:name]})
     @a.users << @u1.id
   end
 
-  it "should perform apple ping with integer parameters" do
-    params = {"user_id" => @u.id, "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => 5, "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+  it 'should perform apple ping with integer parameters' do
+    params = {'user_id' => @u.id,
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => 5,
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
 
     scrubbed_params = params.dup
     scrubbed_params['vibrate'] = '5'
 
-    Apple.should_receive(:ping).once.with({'device_pin' => @c.device_pin,
-      'device_port' => @c.device_port}.merge!(scrubbed_params))
+    expect(Apple).to receive(:ping).once.with({
+                                                  'device_pin' => @c.device_pin,
+                                                  'device_port' => @c.device_port
+                                              }.merge!(scrubbed_params))
     PingJob.perform(params)
   end
 
-  it "should perform apple ping" do
-    params = {"user_id" => @u.id, "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
-    Apple.should_receive(:ping).once.with({'device_pin' => @c.device_pin,
-      'device_port' => @c.device_port}.merge!(params))
+  it 'should perform apple ping' do
+    params = {'user_id' => @u.id,
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil}
+    expect(Apple).to receive(:ping).once.with({'device_pin' => @c.device_pin,
+                                           'device_port' => @c.device_port}.merge!(params))
     PingJob.perform(params)
   end
 
-  it "should skip ping for the unknown platform" do
-    params = {"user_id" => @u.id, "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+  it 'should skip ping for the unknown platform' do
+    params = {'user_id' => @u.id,
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil}
     @c.device_type = 'unknown_device_type'
-    PingJob.should_receive(:log).once.with("Dropping ping request for unsupported platform '#{@c.device_type}'")
+    expect(PingJob).to receive(:log).once.with("Dropping ping request for unsupported platform '#{@c.device_type}'")
     PingJob.perform(params)
   end
 
-  it "should skip ping for empty device_type" do
-    params = {"user_id" => @u.id, "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+  it 'should skip ping for empty device_type' do
+    params = {'user_id' => @u.id,
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'device_app_id' => nil,
+              'device_app_version' => nil}
     @c.device_type = nil
-    PingJob.should_receive(:log).once.with("Skipping ping for non-registered client_id '#{@c.id}'...")
-    lambda { PingJob.perform(params) }.should_not raise_error
+    expect(PingJob).to receive(:log).once.with("Skipping ping for non-registered client_id '#{@c.id}'...")
+    expect {PingJob.perform(params)}.not_to raise_error
   end
 
-  it "should skip ping for empty device_pin" do
-    params = {"user_id" => @u.id, "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+  it 'should skip ping for empty device_pin' do
+    params = {'user_id' => @u.id,
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
     @c.device_type = 'Android'
     @c.device_pin = nil
-    PingJob.should_receive(:log).once.with("Skipping ping for non-registered client_id '#{@c.id}'...")
-    lambda { PingJob.perform(params) }.should_not raise_error
+    expect(PingJob).to receive(:log).once.with("Skipping ping for non-registered client_id '#{@c.id}'...")
+    expect {PingJob.perform(params)}.not_to raise_error
   end
 
-  it "should drop ping if it's already in user's device pin list" do
-    params = {"user_id" => @u.id, "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+  it 'should drop ping if it\'s already in user\'s device pin list' do
+    params = {'user_id' => @u.id,
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil}
     # another client with the same device pin ...
     @c_fields.delete(:id)
-    @c1 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+    @c1 = Client.create(@c_fields, {:source_name => @s_fields[:name]})
     # and yet another one ...
     @c_fields.delete(:id)
-    @c2 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+    @c2 = Client.create(@c_fields, {:source_name => @s_fields[:name]})
 
-    Apple.should_receive(:ping).with({'device_pin' => @c.device_pin, 'device_port' => @c.device_port}.merge!(params))
-    PingJob.should_receive(:log).twice.with(/Dropping ping request for client/)
-    lambda { PingJob.perform(params) }.should_not raise_error
+    expect(Apple).to receive(:ping).with({'device_pin' => @c.device_pin, 'device_port' => @c.device_port}.merge!(params))
+    expect(PingJob).to receive(:log).twice.with(/Dropping ping request for client/)
+    expect {PingJob.perform(params)}.not_to raise_error
   end
 
-  it "should drop ping if it's already in user's phone id list and device pin is different" do
-    params = {"user_id" => @u.id, "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+  it 'should drop ping if it\'s already in user\'s phone id list and device pin is different' do
+    params = {'user_id' => @u.id,
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
     @c.phone_id = '3'
     @c_fields.merge!(:phone_id => '3')
     # another client with the same phone id..
     @c_fields.delete(:id)
-    @c1 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+    @c1 = Client.create(@c_fields, {:source_name => @s_fields[:name]})
     #  yet another...
     @c_fields.delete(:id)
-    @c2 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+    @c2 = Client.create(@c_fields, {:source_name => @s_fields[:name]})
 
-    Apple.should_receive(:ping).with({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}.merge!(params))
-    PingJob.should_receive(:log).twice.with(/Dropping ping request for client/)
-    lambda { PingJob.perform(params) }.should_not raise_error
+    expect(Apple).to receive(:ping).with({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}.merge!(params))
+    expect(PingJob).to receive(:log).twice.with(/Dropping ping request for client/)
+    expect {PingJob.perform(params)}.not_to raise_error
   end
 
-  it "should ping two different users from two different devices - Apple and GCM" do
-    params = {"user_id" => [ @u.id, @u1.id], "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3', 'phone_id' => nil }
+  xit 'should ping two different users from two different devices - Apple and GCM' do
+    params = {'user_id' => [@u.id, @u1.id],
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
     @c.phone_id = '3'
 
     scrubbed_params = params.dup
     scrubbed_params['vibrate'] = '5'
     @c1.device_push_type = 'Gcm'
 
-    Apple.should_receive(:ping).with(params.merge!({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}))
-    Gcm.should_receive(:ping).with({'device_pin' => @c1.device_pin, 'device_port' => @c1.device_port}.merge!(scrubbed_params))
+    expect(Apple).to receive(:ping).with(params.merge!({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}))
+    expect(Gcm).to receive(:ping).with({'device_pin' => @c1.device_pin, 'device_port' => @c1.device_port}.merge!(scrubbed_params))
     PingJob.perform(params)
   end
 
-  it "should drop ping with two different users from the same device" do
-    params = {"user_id" => [ @u.id, @u1.id], "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+  it 'should ping two different users from two different devices - Apple and FCM' do
+    params = {'user_id' => [@u.id, @u1.id],
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
+    @c.phone_id = '3'
+
+    scrubbed_params = params.dup
+    scrubbed_params['vibrate'] = '5'
+    @c1.device_push_type = 'Fcm'
+
+    expect(Apple).to receive(:ping).with(params.merge!({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}))
+    expect(Fcm).to receive(:ping).with({'device_pin' => @c1.device_pin, 'device_port' => @c1.device_port}.merge!(scrubbed_params))
+    PingJob.perform(params)
+  end
+
+  it 'should drop ping with two different users from the same device' do
+    params = {'user_id' => [@u.id, @u1.id],
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
     @c.phone_id = '3'
     @c1.phone_id = '3'
 
-    Apple.should_receive(:ping).with({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}.merge!(params))
-    PingJob.should_receive(:log).once.with(/Dropping ping request for client/)
-    lambda { PingJob.perform(params) }.should_not raise_error
+    expect(Apple).to receive(:ping).with({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}.merge!(params))
+    expect(PingJob).to receive(:log).once.with(/Dropping ping request for client/)
+    expect {PingJob.perform(params)}.not_to raise_error
   end
 
-  it "should drop ping with two different users with the same pin" do
-    params = {"user_id" => [ @u.id, @u1.id], "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world', "phone_id" => nil,
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+  it 'should drop ping with two different users with the same pin' do
+    params = {'user_id' => [@u.id, @u1.id],
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'phone_id' => nil,
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
     @c1.device_pin = @c.device_pin
 
-    Apple.should_receive(:ping).with({'device_pin' => @c.device_pin, 'device_port' => @c.device_port}.merge!(params))
-    PingJob.should_receive(:log).once.with(/Dropping ping request for client/)
-    lambda { PingJob.perform(params) }.should_not raise_error
+    expect(Apple).to receive(:ping).with({'device_pin' => @c.device_pin, 'device_port' => @c.device_port}.merge!(params))
+    expect(PingJob).to receive(:log).once.with(/Dropping ping request for client/)
+    expect {PingJob.perform(params)}.not_to raise_error
   end
 
-  it "should process all pings even if some of them are failing" do
-    params = {"user_id" => [ @u.id, @u1.id], "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3', 'phone_id' => nil }
+  xit 'should process all pings even if some of them are failing' do
+    params = {'user_id' => [@u.id, @u1.id],
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
     @c.phone_id = '3'
 
     scrubbed_params = params.dup
     scrubbed_params['vibrate'] = '5'
     @c1.device_push_type = 'Gcm'
 
-    Apple.should_receive(:ping).with(params.merge!({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port})).and_return { raise SocketError.new("Socket failure") }
-    Gcm.should_receive(:ping).with({'device_pin' => @c1.device_pin, 'device_port' => @c1.device_port}.merge!(scrubbed_params))
-    exception_raised = false
-    begin
-      PingJob.perform(params)
-    rescue Exception => e
-      exception_raised = true
-    end
-    exception_raised.should == true
-  end
-
-  it "should skip ping for unknown user or user with no clients" do
-    params = {"user_id" => [ 'fake_user' ], "api_token" => @api_token,
-      "sources" => [@s.name], "message" => 'hello world',
-      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3', 'phone_id' => nil }
-    PingJob.should_receive(:log).once.with(/Skipping ping for unknown user 'fake_user' or 'fake_user' has no registered clients.../)
+    params.merge!({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port})
+    allow(Apple).to receive(:ping).with(params).and_raise(SocketError.new("Socket failure"))
+    allow(Gcm).to receive(:ping).with({'device_pin' => @c1.device_pin, 'device_port' => @c1.device_port}.merge!(scrubbed_params))
+    expect{ PingJob.perform(params)}.to raise_error
+  end
+
+  it 'should process all pings even if some of them are failing' do
+    params = {'user_id' => [@u.id, @u1.id],
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
+    @c.phone_id = '3'
+
+    scrubbed_params = params.dup
+    scrubbed_params['vibrate'] = '5'
+    @c1.device_push_type = 'Fcm'
+
+    params.merge!({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port})
+    allow(Apple).to receive(:ping).with(params).and_raise(SocketError.new("Socket failure"))
+    allow(Fcm).to receive(:ping).with({'device_pin' => @c1.device_pin, 'device_port' => @c1.device_port}.merge!(scrubbed_params))
+    expect{ PingJob.perform(params)}.to raise_error
+  end
+
+  it 'should skip ping for unknown user or user with no clients' do
+    params = {'user_id' => ['fake_user'],
+              'api_token' => @api_token,
+              'sources' => [@s.name],
+              'message' => 'hello world',
+              'vibrate' => '5',
+              'badge' => '5',
+              'sound' => 'hello.mp3',
+              'phone_id' => nil,
+              'device_app_id' => nil,
+              'device_app_version' => nil, }
+    expect(PingJob).to receive(:log).once.with(/Skipping ping for unknown user 'fake_user' or 'fake_user' has no registered clients.../)
     PingJob.perform(params)
   end
 
-  it "should process ping for device_push_type if available" do
+  it 'should process ping for device_push_type if available' do
     @c.device_push_type = 'rhoconnect_push'
     @c.device_port = nil
     params = {
-      'user_id'  => @u.id,
-      'message'  => 'hello world',
-      'device_port' => '',
-      'vibrate'  => '',
-      'phone_id' => nil
+        'user_id' => @u.id,
+        'message' => 'hello world',
+        'device_port' => '',
+        'vibrate' => '',
+        'phone_id' => nil,
+        'device_app_id' => nil,
+        'device_app_version' => nil,
     }
     scrubbed_params = params.dup
 
-    RhoconnectPush.should_receive(:ping).once.with(
-      {'device_pin' => @c.device_pin}.merge!(scrubbed_params)
+    expect(RhoconnectPush).to receive(:ping).once.with(
+        {'device_pin' => @c.device_pin}.merge!(scrubbed_params)
     )
     PingJob.perform(params)
   end
-end
+end

data/spec/perf/perf_spec_helper.rb

@@ -41,12 +41,12 @@ def generate_fake_data(num=1000,unique=false)
       unique_prefix = "#{n}-#{Time.now.to_s}"
     end
     res[n.to_s] = {
-      "FirstName" => Faker::Name.first_name + unique_prefix,
-      "LastName" => Faker::Name.last_name + unique_prefix,
-      "Email" =>  Faker::Internet.free_email + unique_prefix,
-      "Company" => Faker::Company.name + unique_prefix,
+      "FirstName" => FFaker::Name.first_name + unique_prefix,
+      "LastName" => FFaker::Name.last_name + unique_prefix,
+      "Email" =>  FFaker::Internet.free_email + unique_prefix,
+      "Company" => FFaker::Company.name + unique_prefix,
       "JobTitle" => title + unique_prefix,
-      "Phone1" => Faker::PhoneNumber.phone_number + unique_prefix
+      "Phone1" => FFaker::PhoneNumber.phone_number + unique_prefix
     }
   end
   res

data/spec/ping/apple_spec.rb

@@ -9,22 +9,22 @@ describe "Ping Apple" do
       "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',
       "device_pin" => @c.device_pin, "device_port" => @c.device_port}
     ssl_ctx = double("ssl_ctx")
-    ssl_ctx.stub(:key=).and_return('key')
-    ssl_ctx.stub(:cert=).and_return('cert')
-    OpenSSL::SSL::SSLContext.stub(:new).and_return(ssl_ctx)
-    OpenSSL::PKey::RSA.stub(:new)
-    OpenSSL::X509::Certificate.stub(:new)
+    allow(ssl_ctx).to receive(:key=).and_return('key')
+    allow(ssl_ctx).to receive(:cert=).and_return('cert')
+    allow(OpenSSL::SSL::SSLContext).to receive(:new).and_return(ssl_ctx)
+    allow(OpenSSL::PKey::RSA).to receive(:new)
+    allow(OpenSSL::X509::Certificate).to receive(:new)
 
     tcp_socket = double("tcp_socket")
-    tcp_socket.stub(:close)
-    TCPSocket.stub(:new).and_return(tcp_socket)
+    allow(tcp_socket).to receive(:close)
+    allow(TCPSocket).to receive(:new).and_return(tcp_socket)
 
     @ssl_socket = double("ssl_socket")
-    @ssl_socket.stub(:sync=)
-    @ssl_socket.stub(:connect)
-    @ssl_socket.stub(:write)
-    @ssl_socket.stub(:close)
-    OpenSSL::SSL::SSLSocket.stub(:new).and_return(@ssl_socket)
+    allow(@ssl_socket).to receive(:sync=)
+    allow(@ssl_socket).to receive(:connect)
+    allow(@ssl_socket).to receive(:write)
+    allow(@ssl_socket).to receive(:close)
+    allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@ssl_socket)
   end
 
   # TODO: This should really test SSLSocket.write
@@ -33,9 +33,7 @@ describe "Ping Apple" do
   end
 
   it "should log deprecation on iphone ping" do
-    Iphone.should_receive(
-      :log
-    ).once.with("DEPRECATION WARNING: 'iphone' is a deprecated device_type, use 'apple' instead")
+    expect(Iphone).to receive(:log).once.with("DEPRECATION WARNING: 'iphone' is a deprecated device_type, use 'apple' instead")
     Iphone.ping(@params)
   end
 
@@ -45,8 +43,8 @@ describe "Ping Apple" do
       "do_sync"=>["SampleAdapter"]
     }
     apn_message = Apple.apn_message(@params)
-    apn_message[0, 7].inspect.gsub("\"", "").should == "\\x00\\x00 \\xAB\\xCD\\x00g"
-    JSON.parse(apn_message[7, apn_message.length]).should ==  expected_hash
+    expect(apn_message[0, 7].inspect.gsub("\"", "")).to  eq("\\x00\\x00 \\xAB\\xCD\\x00g")
+    expect(JSON.parse(apn_message[7, apn_message.length])).to eq(expected_hash)
   end
 
   it "should compute apn_message with source array" do
@@ -56,21 +54,21 @@ describe "Ping Apple" do
       "do_sync"=>["SampleAdapter", "SimpleAdapter"]
     }
     apn_message = Apple.apn_message(@params)
-    apn_message[0, 7].inspect.gsub("\"", "").should == "\\x00\\x00 \\xAB\\xCD\\x00w"
-    JSON.parse(apn_message[7, apn_message.length]).should ==  expected_hash
+    expect(apn_message[0, 7].inspect.gsub("\"", "")).to eq("\\x00\\x00 \\xAB\\xCD\\x00w")
+    expect(JSON.parse(apn_message[7, apn_message.length])).to eq(expected_hash)
   end
 
   it "should raise SocketError if socket fails" do
     error = 'socket error'
-    @ssl_socket.stub(:write).and_return { raise SocketError.new(error) }
-    Apple.should_receive(:log).once.with("Error while sending ping: #{error}")
-    lambda { Apple.ping(@params) }.should raise_error(SocketError,error)
+    allow(@ssl_socket).to receive(:write).and_raise(SocketError.new(error))
+    expect(Apple).to receive(:log).once.with("Error while sending ping: #{error}")
+    expect(lambda { Apple.ping(@params) }).to raise_error(SocketError, error)
   end
 
   it "should do nothing if no cert or host or port" do
-     Rhoconnect::Apple.stub(:get_config).and_return({:test => {:iphonecertfile=>"none"}})
-     Rhoconnect::Apple.should_receive(:get_config).once
-     OpenSSL::SSL::SSLContext.should_receive(:new).exactly(0).times
+     allow(Rhoconnect::Apple).to receive(:get_config).and_return({:test => {:iphonecertfile=>"none"}})
+     expect(Rhoconnect::Apple).to receive(:get_config).once
+     expect(OpenSSL::SSL::SSLContext).to receive(:new).exactly(0).times
      Apple.ping(@params)
   end
-end
+end