rhoconnect 5.5.18 → 7.4.1

data/spec/ping/fcm_spec.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe "Ping Android FCM" do
+  include_examples "SharedRhoconnectHelper", :rhoconnect_data => false
+
+  before(:each) do
+    allow( Google::Auth).to receive(:get_application_default)
+    @params = {"device_pin" => @c.device_pin,
+               "sources" => [@s.name], "message" => 'hello world',
+               "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+    @response = double('response')
+    Rhoconnect.settings[:fcm_project_id] = 'valid_project_id'
+    Rhoconnect.settings[:package_name] = 'valid_package_name'
+  end
+
+  it "should ping fcm successfully" do
+    stub_request(:post, "https://fcm.googleapis.com/v1/projects/valid_project_id/messages:send").with { |request|
+      hash = JSON.parse request.body
+      valid = hash["message"]["token"] == "abcd"
+      valid = valid && hash["message"]["topic"] == nil
+      valid = valid && hash["message"]["android"]["restricted_package_name"] == "valid_package_name"
+      valid
+    }
+    Fcm.ping(@params)
+  end
+
+  it "should raise error on missing fcm_project_id setting" do
+    key = Rhoconnect.settings[:fcm_project_id.dup]
+    Rhoconnect.settings[:fcm_project_id] = nil
+    expect(lambda { Fcm.ping(@params) }).to raise_error(Fcm::InvalidProjectId, 'Missing `:fcm_project_id:` option in settings/settings.yml')
+    Rhoconnect.settings[:fcm_project_id] = key
+  end
+
+  it "should raise error on missing package_name setting" do
+    key = Rhoconnect.settings[:package_name.dup]
+    Rhoconnect.settings[:package_name] = nil
+    expect(lambda { Fcm.ping(@params) }).to raise_error(Fcm::InvalidPackageName, 'Missing `:package_name:` option in settings/settings.yml')
+    Rhoconnect.settings[:package_name] = key
+  end
+
+  it "should ping fcm with 503 connection error" do
+    stub_request(:post, "https://fcm.googleapis.com/v1/projects/valid_project_id/messages:send").to_raise(RestClient::Exception.new(nil,503))
+    expect(lambda { Fcm.ping(@params) }).to raise_error(RestClient::Exception)
+  end
+
+  xit "should ping fcm with 200 error message" do
+    allow( Google::Auth).to receive(:get_application_default)
+
+    error = 'error:DeviceMessageRateExceeded'
+    allow(@response).to receive(:code).and_return(200)
+    allow(@response).to receive(:body).and_return(error)
+    allow(@response).to receive(:headers).and_return(nil)
+    stub_request(:post, "https://fcm.googleapis.com/v1/projects/valid_project_id/messages:send").to_raise(RestClient::Exception.new(@response,200))
+    expect(lambda { Fcm.ping(@params) }).to raise_error(Fcm::FCMPingError, "FCM ping error: DeviceMessageRateExceeded")
+  end
+
+  xit "should fail to ping with bad authentication" do
+    error = 'Error=BadAuthentication'
+    allow(@response).to receive(:code).and_return(403)
+    allow(@response).to receive(:body).and_return(error)
+    allow(@response).to receive(:headers).and_return({})
+    setup_post_yield(@response)
+    expect(Fcm).to receive(:log).twice
+    expect(lambda { Fcm.ping(@params) }).to raise_error(
+                                                Fcm::InvalidProjectId, "Invalid FCM project id. Obtain new api key from FCM service."
+                                            )
+  end
+
+  xit "should ping fcm with 401 error message" do
+    allow(@response).to receive(:code).and_return(401)
+    allow(@response).to receive(:body).and_return('')
+    setup_post_yield(@response)
+    expect(Fcm).to receive(:log).twice
+    expect(lambda { Fcm.ping(@params) }).to raise_error(
+                                                Fcm::InvalidProjectId, "Invalid FCM project id. Obtain new api key from FCM service."
+                                            )
+  end
+
+  it "should compute fcm_message" do
+    expect(Google::Apis::Messages::Message).to receive(:new) do |options|
+      expect(options[:token]).to eq(@c.device_pin)
+      expect(options[:android]["priority"]).to eq("high")
+      expect(options[:android]["restricted_package_name"]).to eq(Rhoconnect.settings[:package_name])
+      expect(options[:android]["data"]["do_sync"]).to eq(@s.name)
+      expect(options[:android]["data"]["alert"]).to eq("hello world")
+      expect(options[:android]["data"]["vibrate"]).to eq("5")
+      expect(options[:android]["data"]["sound"]).to eq("hello.mp3")
+      expect(options[:android]["notification"]["body"]).to eq("hello world")
+    end
+
+    Fcm.fcm_message(Rhoconnect.settings[:package_name], @params)
+  end
+
+  it "should trim empty or nil params from fcm_message" do
+    expect(Google::Apis::Messages::Message).to receive(:new) do |options|
+      expect(options[:token]).to eq(@c.device_pin)
+      expect(options[:android]["priority"]).to eq("high")
+      expect(options[:android]["restricted_package_name"]).to eq(Rhoconnect.settings[:package_name])
+      expect(options[:android]["data"]["do_sync"]).to eq('')
+      expect(options[:android]["data"]["alert"]).to eq(nil)
+      expect(options[:android]["data"]["vibrate"]).to eq("5")
+      expect(options[:android]["data"]["sound"]).to eq("hello.mp3")
+      expect(options[:android]["notification"]["body"]).to eq(nil)
+    end
+
+    params = {
+        "device_pin" => @c.device_pin,
+        "sources" => [],
+        "message" => '',
+        "vibrate" => '5',
+        "sound" => 'hello.mp3'
+    }
+
+    Fcm.fcm_message(Rhoconnect.settings[:package_name], params)
+  end
+end

data/spec/ping/gcm_spec.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__),'..','spec_helper')
 
-describe "Ping Android GCM" do
+xdescribe "Ping Android GCM" do
   include_examples "SharedRhoconnectHelper", :rhoconnect_data => false
 
   before(:each) do
@@ -13,59 +13,57 @@ describe "Ping Android GCM" do
 
   it "should ping gcm successfully" do
     result = 'id=0:34234234134254%abc123\n'
-    @response.stub(:code).and_return(200)
-    @response.stub(:body).and_return(result)
-    @response.stub(:headers).and_return({})
-    @response.stub(:return!).and_return(@response)
+    allow(@response).to receive(:code).and_return(200)
+    allow(@response).to receive(:body).and_return(result)
+    allow(@response).to receive(:headers).and_return({})
+    allow(@response).to receive(:return!).and_return(@response)
     setup_post_yield(@response)
-    Gcm.ping(@params).body.should == result
+    expect(Gcm.ping(@params).body).to eq(result)
   end
 
   it "should raise error on missing gcm_api_key setting" do
     key = Rhoconnect.settings[:gcm_api_key].dup
     Rhoconnect.settings[:gcm_api_key] = nil
-    lambda { Gcm.ping(@params) }.should raise_error(
-      Gcm::InvalidApiKey, 'Missing `:gcm_api_key:` option in settings/settings.yml'
-    )
+    expect(lambda { Gcm.ping(@params) }).to raise_error(Gcm::InvalidApiKey, 'Missing `:gcm_api_key:` option in settings/settings.yml')
     Rhoconnect.settings[:gcm_api_key] = key
   end
 
   it "should ping gcm with 503 connection error" do
     error = 'Connection refused'
-    @response.stub(:body).and_return(error)
-    RestClient.stub(:post).and_return { raise RestClient::Exception.new(@response,503) }
-    Gcm.should_receive(:log).twice
-    lambda { Gcm.ping(@params) }.should raise_error(RestClient::Exception)
+    allow(@response).to receive(:body).and_return(error)
+    allow(RestClient).to receive(:post).and_raise(RestClient::Exception.new(@response,503))
+    allow(Gcm).to receive(:log).twice
+    expect(lambda { Gcm.ping(@params) }).to raise_error(RestClient::Exception)
   end
 
   it "should ping gcm with 200 error message" do
     error = 'Error=QuotaExceeded'
-    @response.stub(:code).and_return(200)
-    @response.stub(:body).and_return(error)
-    @response.stub(:headers).and_return(nil)
+    allow(@response).to receive(:code).and_return(200)
+    allow(@response).to receive(:body).and_return(error)
+    allow(@response).to receive(:headers).and_return(nil)
     setup_post_yield(@response)
-    Gcm.should_receive(:log).twice
-    lambda { Gcm.ping(@params) }.should raise_error(Gcm::GCMPingError, "GCM ping error: QuotaExceeded")
+    expect(Gcm).to receive(:log).twice
+    expect(lambda { Gcm.ping(@params) }).to raise_error(Gcm::GCMPingError, "GCM ping error: QuotaExceeded")
   end
 
   it "should fail to ping with bad authentication" do
     error = 'Error=BadAuthentication'
-    @response.stub(:code).and_return(403)
-    @response.stub(:body).and_return(error)
-    @response.stub(:headers).and_return({})
+    allow(@response).to receive(:code).and_return(403)
+    allow(@response).to receive(:body).and_return(error)
+    allow(@response).to receive(:headers).and_return({})
     setup_post_yield(@response)
-    Gcm.should_receive(:log).twice
-    lambda { Gcm.ping(@params) }.should raise_error(
+    expect(Gcm).to receive(:log).twice
+    expect(lambda { Gcm.ping(@params) }).to  raise_error(
       Gcm::InvalidApiKey, "Invalid GCM api key. Obtain new api key from GCM service."
     )
   end
 
   it "should ping gcm with 401 error message" do
-    @response.stub(:code).and_return(401)
-    @response.stub(:body).and_return('')
+    allow(@response).to receive(:code).and_return(401)
+    allow(@response).to receive(:body).and_return('')
     setup_post_yield(@response)
-    Gcm.should_receive(:log).twice
-    lambda { Gcm.ping(@params) }.should raise_error(
+    expect(Gcm).to receive(:log).twice
+    expect(lambda { Gcm.ping(@params) }).to raise_error(
       Gcm::InvalidApiKey, "Invalid GCM api key. Obtain new api key from GCM service."
     )
   end
@@ -83,7 +81,7 @@ describe "Ping Android GCM" do
     }
     actual = Gcm.gcm_message(@params)
     actual['collapse_key'] = "RAND_KEY" unless actual['collapse_key'].nil?
-    actual.should == expected
+    expect(actual).to eq(expected)
   end
 
   it "should trim empty or nil params from gcm_message" do
@@ -93,6 +91,6 @@ describe "Ping Android GCM" do
       "sources" => [], "message" => '', "vibrate" => '5', "sound" => 'hello.mp3'}
     actual = Gcm.gcm_message(params)
     actual['collapse_key'] = "RAND_KEY" unless actual['collapse_key'].nil?
-    actual.should == expected
+    expect(actual).to eq(expected)
   end
 end

data/spec/ping/rhoconnect_push_spec.rb

@@ -13,18 +13,18 @@ describe "Ping using RhoConnect push" do
 
   it "should ping rhoconnect push successfully" do
     result = ''
-    @response.stub(:code).and_return(204)
-    @response.stub(:body).and_return(result)
-    @response.stub(:return!).and_return(@response)
-    RestClient.stub(:post).and_return(@response)
+    allow(@response).to receive(:code).and_return(204)
+    allow(@response).to receive(:body).and_return(result)
+    allow(@response).to receive(:return!).and_return(@response)
+    allow(RestClient).to receive(:post).and_return(@response)
     res = RhoconnectPush.ping(@params)
-    res.body.should == result
-    res.code.should == 204
+    expect(res.body).to eq(result)
+    expect(res.code).to eq(204)
   end
 
   it "should ping rhoconnect push with missing push_server property" do
-    RhoconnectPush.stub(:get_config).and_return({:test => {}})
-    lambda { RhoconnectPush.ping(@params) }.should raise_error(
+    allow(RhoconnectPush).to receive(:get_config).and_return({:test => {}})
+    expect(lambda { RhoconnectPush.ping(@params) }).to raise_error(
       RhoconnectPush::InvalidPushServer, "Missing or invalid `:push_server` in settings/settings.yml."
     )
   end
@@ -32,11 +32,11 @@ describe "Ping using RhoConnect push" do
 
   it "should ping rhoconnect push with 400 response" do
     result = ''
-    @response.stub(:code).and_return(400)
-    @response.stub(:body).and_return(result)
-    @response.stub(:return!).and_return(@response)
+    allow(@response).to receive(:code).and_return(400)
+    allow(@response).to receive(:body).and_return(result)
+    allow(@response).to receive(:return!).and_return(@response)
     setup_post_yield(@response)
-    lambda { RhoconnectPush.ping(@params) }.should raise_error(
+    expect(lambda { RhoconnectPush.ping(@params) }).to raise_error(
       RhoconnectPush::InvalidPushRequest, "Invalid push request."
     )
   end
@@ -52,6 +52,6 @@ describe "Ping using RhoConnect push" do
       }
     }
     actual = RhoconnectPush.push_message(@params)
-    JSON.parse(actual).should == expected
+    expect(JSON.parse(actual)).to eq(expected)
   end
 end

data/spec/rhoconnect_spec.rb

@@ -22,7 +22,7 @@ describe "Rhoconnect" do
     Rhoconnect.environment.should == :test
     Rhoconnect.stats.should == false
     Rhoconnect.cookie_expire.should == 9999999
-    App.is_exist?(test_app_name).should be_true
+    App.is_exist?(test_app_name).should be  true
   end
 
   it "should bootstrap Rhoconnect with RHO_ENV provided" do
@@ -69,4 +69,4 @@ describe "Rhoconnect" do
     s = Source.load('SampleAdapter',{:app_id => test_app_name,:user_id => '*'})
     s.has_many.should == "FixedSchemaAdapter,brand"
   end
-end
+end

data/spec/server/cors_spec.rb

@@ -53,9 +53,9 @@ describe "CORS middleware" do
             allow.resource nil,   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
           rescue Exception => e
             exception_happens = true
-            e.is_a?(TypeError).should == true
+            expect(e.is_a?(TypeError)).to be true
           end
-          exception_happens.should == true
+          expect(exception_happens).to be true
 
           allow.resource "/*", :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
         end
@@ -68,8 +68,8 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
     }
     status, headers, body = mv.call(env)
-    200.should == status
-    headers['Access-Control-Allow-Origin'].should == '*'
+    expect(200).to eq(status)
+    expect(headers['Access-Control-Allow-Origin']).to eq('*')
   end
 
   it "preflight check should disable unknown origins" do
@@ -80,8 +80,8 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
-    headers['Access-Control-Allow-Origin'].should_not == 'wrong_origin'
+    expect(200).to eq(status)
+    expect(headers['Access-Control-Allow-Origin']).not_to eq('wrong_origin')
   end
 
   it "preflight check should allow known origins" do
@@ -92,8 +92,8 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
-    headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
+    expect(200).to eq(status)
+    expect(headers['Access-Control-Allow-Origin']).to eq('allowed_origin')
   end
 
   it "able to use fallback X-ORIGIN request header if ORIGIN header is undefined" do
@@ -104,8 +104,8 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
-    headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
+    expect(200).to eq(status)
+    expect(headers['Access-Control-Allow-Origin']).to eq('allowed_origin')
   end
 
   it "preflight check treats empty 'null' origin as 'file://' one" do
@@ -116,8 +116,8 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
-    headers['Access-Control-Allow-Origin'].should == 'file://'
+    expect(200).to eq(status)
+    expect(headers['Access-Control-Allow-Origin']).to eq('file://')
   end
 
   it "preflight check should enable allowed request headers" do
@@ -129,9 +129,9 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_HEADERS' => 'allowed_header'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
+    expect(200).to eq(status)
     #headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
-    headers['Access-Control-Allow-Headers'].should == 'allowed_header'
+    expect(headers['Access-Control-Allow-Headers']).to eq('allowed_header')
   end
 
   it "preflight check should disable not allowed request headers" do
@@ -143,9 +143,9 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_HEADERS' => 'not_allowed_header'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
+    expect(200).to eq(status)
     #headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
-    headers['Access-Control-Allow-Headers'].should_not == 'not_allowed_header'
+    expect(headers['Access-Control-Allow-Headers']).not_to eq('not_allowed_header')
   end
 
   it "preflight check should allow any request headers if configured so" do
@@ -157,9 +157,9 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_HEADERS' => 'not_allowed_header'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
+    expect(200).to eq(status)
     #headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
-    headers['Access-Control-Allow-Headers'].should == 'not_allowed_header'
+    expect(headers['Access-Control-Allow-Headers']).to eq('not_allowed_header')
   end
 
 
@@ -171,8 +171,8 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
-    headers['Access-Control-Expose-Headers'].should == 'Content-Length'
+    expect(200).to eq(status)
+    expect(headers['Access-Control-Expose-Headers']).to eq('Content-Length')
   end
 
   it "no response headers should be exposed by default" do
@@ -183,8 +183,8 @@ describe "CORS middleware" do
         'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
     }
     status, headers, body = @middleware.call(env)
-    200.should == status
-    headers['Access-Control-Expose-Headers'].should == ''
+    expect(200).to eq(status)
+    expect(headers['Access-Control-Expose-Headers']).to eq('')
   end