rhoconnect 6.0.11 → 6.2.0

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

data/spec/ping/gcm_spec.rb

@@ -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
 
 

data/spec/server/server_spec.rb

@@ -1,7 +1,7 @@
 require 'rack/test'
 
-require File.join(File.dirname(__FILE__),'..','spec_helper')
-require File.join(File.dirname(__FILE__),'..','..','lib','rhoconnect','server.rb')
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'rhoconnect', 'server.rb')
 
 describe "Server" do
   include Rack::Test::Methods
@@ -11,7 +11,7 @@ describe "Server" do
   before(:each) do
     Rhoconnect::Server.set :secret, "secure!"
     Rhoconnect::Server.use Rack::Static, :urls => ["/data"],
-      :root =>  File.expand_path(File.join(File.dirname(__FILE__),'..','apps','rhotestapp'))
+                           :root => File.expand_path(File.join(File.dirname(__FILE__), '..', 'apps', 'rhotestapp'))
   end
 
   def app
@@ -20,36 +20,36 @@ describe "Server" do
 
   it "should show status page" do
     get '/'
-    last_response.status.should == 302
+    expect(last_response.status).to eq(302)
   end
 
   it "should login if content-type contains extra parameters" do
-    post "/rc/#{Rhoconnect::API_VERSION}/system/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE'=>'application/json; charset=UTF-8'}
-    last_response.should be_ok
+    post "/rc/#{Rhoconnect::API_VERSION}/system/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE' => 'application/json; charset=UTF-8'}
+    expect(last_response).to be_ok
   end
 
   it "should fail to login if wrong content-type" do
-    post "/rc/#{Rhoconnect::API_VERSION}/system/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE'=>'application/x-www-form-urlencoded'}
-    last_response.should_not be_ok
+    post "/rc/#{Rhoconnect::API_VERSION}/system/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE' => 'application/x-www-form-urlencoded'}
+    expect(last_response).not_to be_ok
   end
 
   it "should login as rhoadmin user" do
     post "/rc/#{Rhoconnect::API_VERSION}/system/login", "login" => 'rhoadmin', "password" => ''
-    last_response.should be_ok
+    expect(last_response).to be_ok
   end
 
   it "should respond with 404 if controller name is not specified" do
     get "/app/#{Rhoconnect::API_VERSION}/"
-    last_response.status.should == 404
+    expect(last_response.status).to eq(404)
   end
 
   it "should have default session secret" do
-    Rhoconnect::Server.secret.should == "secure!"
+    expect(Rhoconnect::Server.secret).to eq("secure!")
   end
 
   it "should update session secret to default" do
     Rhoconnect::Server.set :secret, "<changeme>"
-    Rhoconnect::Server.secret.should == "<changeme>"
+    expect(Rhoconnect::Server.secret).to eq("<changeme>")
     allow(Rhoconnect::Server).to receive(:log).with(any_args())
     check_default_secret!("<changeme>")
     Rhoconnect::Server.set :secret, "secure!"
@@ -62,57 +62,57 @@ describe "Server" do
 
     it "should return nil if params[:source_name] is missing" do
       get "/application"
-      last_response.status.should == 500
+      expect(last_response.status).to eq(500)
     end
   end
 
   describe "auth routes" do
     it "should login user with correct username,password" do
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
-      last_response.should be_ok
+      expect(last_response).to be_ok
     end
 
     it "should login user with correct username,password old route and deprecation warning" do
       do_post "/application/clientlogin", "login" => @u.login, "password" => 'testpass'
-      last_response.should be_ok
-      last_response.headers["Warning"].index('deprecated').should_not == nil
+      expect(last_response).to be_ok
+      expect(last_response.headers["Warning"].index('deprecated')).not_to be_nil
     end
 
     it "should login user with correct username,password if backend service defined" do
       stub_request(:post, "http://test.com/rhoconnect/authenticate").to_return(:body => "lucas")
       Rhoconnect.appserver = 'http://test.com'
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'lucas', "password" => 'testpass'
-      last_response.should be_ok
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => 'lucas', "password" => 'testpass'
+      expect(last_response).to be_ok
     end
 
     it "should return 401 and LoginException messsage from authenticate" do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'wrongpass'
-      last_response.status.should == 401
-      last_response.body.should == 'login exception'
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'wrongpass'
+      expect(last_response.status).to eq(401)
+      expect(last_response.body).to eq('login exception')
     end
 
     it "should return 500 and Exception messsage from authenticate" do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'server error'
-      last_response.status.should == 500
-      last_response.body.should == 'server error'
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'server error'
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq('server error')
     end
 
     it "should return 401 and no messsage from authenticate if no exception raised" do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'wrongpassnomsg'
-      last_response.status.should == 401
-      last_response.body.should == "Unable to authenticate '#{@u.login}'"
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'wrongpassnomsg'
+      expect(last_response.status).to eq(401)
+      expect(last_response.body).to eq("Unable to authenticate '#{@u.login}'")
     end
 
     it "should create unknown user through delegated authentication" do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'newuser', "password" => 'testpass'
-      User.is_exist?('newuser').should == true
-      @a.users.members.sort.should == ['newuser','testuser']
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => 'newuser', "password" => 'testpass'
+      expect(User.is_exist?('newuser')).to be true
+      expect(@a.users.members.sort).to eq(['newuser', 'testuser'])
     end
 
     it "should create a different username through delegated authentication" do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'newuser', "password" => 'diffuser'
-      User.is_exist?('different').should == true
-      @a.users.members.sort.should == ['different','testuser']
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => 'newuser', "password" => 'diffuser'
+      expect(User.is_exist?('different')).to be true
+      expect(@a.users.members.sort).to eq(['different', 'testuser'])
     end
 
     context "rps authenticate" do
@@ -121,7 +121,7 @@ describe "Server" do
         do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
         authorize 'rpsuser', 'secret'
         get "/rc/#{Rhoconnect::API_VERSION}/app/rps_login", {}
-        last_response.status.should == 204
+        expect(last_response.status).to eq(204)
       end
     end
 
@@ -131,24 +131,24 @@ describe "Server" do
         # :push_server: http://user:pwd@localhost:8675
         authorize 'user', 'pwd'
         get "/rc/#{Rhoconnect::API_VERSION}/system/rps_login", {}
-        last_response.status.should == 204
+        expect(last_response.status).to eq(204)
       end
       it "should not authenticate rhoconnect app with invalid rhoconnect push server credentials" do
         authorize 'someappname', ''
         get "/rc/#{Rhoconnect::API_VERSION}/system/rps_login", {}
-        last_response.status.should == 401
+        expect(last_response.status).to eq(401)
       end
       it "should not authenticate rhoconnect app with invalid basic Authorization header in request" do
         # Basic Authorization header is missing
         get "/rc/#{Rhoconnect::API_VERSION}/system/rps_login", {}
-        last_response.status.should == 401
+        expect(last_response.status).to eq(401)
       end
     end
   end
 
   describe "controller custom routes" do
     before(:each) do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
     end
 
     it "should register custom_route in DefaultServer and process it" do
@@ -157,7 +157,7 @@ describe "Server" do
       end
 
       get "/my_custom_route", {}
-      last_response.body.should == "Hello World!"
+      expect(last_response.body).to eq("Hello World!")
     end
 
     it "should register custom_route in SimpleAdapter controller and process it" do
@@ -165,7 +165,7 @@ describe "Server" do
         "Hello World!"
       end
       get "/app/#{Rhoconnect::API_VERSION}/SimpleAdapter/my_custom_route", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.body.should == "Hello World!"
+      expect(last_response.body).to eq("Hello World!")
     end
 
     it "should register custom_route in SimpleAdapter controller, require client condition and return error if client is missing" do
@@ -173,50 +173,48 @@ describe "Server" do
         "Hello World!"
       end
       get "/app/#{Rhoconnect::API_VERSION}/SimpleAdapter/my_custom_route_with_client", {}
-      last_response.body.should == "Unknown client"
-      last_response.status.should == 500
+      expect(last_response.body).to eq("Unknown client")
+      expect(last_response.status).to eq(500)
     end
   end
 
   describe "client management routes" do
     before(:each) do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
     end
 
     it "should respond to clientcreate" do
       do_post "/rc/#{Rhoconnect::API_VERSION}/clients", 'device_type' => 'Android'
-      last_response.should be_ok
-      last_response.content_type.should =~ /application\/json/
+      expect(last_response).to be_ok
+      expect(last_response.content_type).to match /application\/json/
       id = JSON.parse(last_response.body)['client']['client_id']
-      id.length.should == 32
-      JSON.parse(last_response.body).should ==
-        {"client"=>{"client_id"=>id}}
-      c = Client.load(id,{:source_name => '*'})
-      c.user_id.should == 'testuser'
-      c.device_type.should == 'Android'
+      expect(id.length).to eq(32)
+      expect(JSON.parse(last_response.body)).to eq({"client" => {"client_id" => id}})
+      c = Client.load(id, {:source_name => '*'})
+      expect(c.user_id).to eq('testuser')
+      expect(c.device_type).to eq('Android')
     end
 
     it "should respond to clientcreate with old route and deprecation warning" do
       get "/application/clientcreate?device_type=Android"
-      last_response.should be_ok
-      last_response.headers["Warning"].index('deprecated').should_not == nil
-      last_response.content_type.should =~ /application\/json/
+      expect(last_response).to be_ok
+      expect(last_response.headers["Warning"].index('deprecated')).not_to be_nil
+      expect(last_response.content_type).to match /application\/json/
       id = JSON.parse(last_response.body)['client']['client_id']
-      id.length.should == 32
-      JSON.parse(last_response.body).should ==
-        {"client"=>{"client_id"=>id}}
-      c = Client.load(id,{:source_name => '*'})
-      c.user_id.should == 'testuser'
-      c.device_type.should == 'Android'
+      expect(id.length).to eq(32)
+      expect(JSON.parse(last_response.body)).to eq({"client" => {"client_id" => id}})
+      c = Client.load(id, {:source_name => '*'})
+      expect(c.user_id).to eq('testuser')
+      expect(c.device_type).to eq('Android')
     end
 
     it "should respond to clientregister" do
       do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{@c.id}/register",
-        "device_type" => "iPhone", "device_pin" => 'abcd'
-      last_response.should be_ok
-      @c.device_type.should == 'Apple'
-      @c.device_pin.should == 'abcd'
-      @c.id.length.should == 32
+              "device_type" => "iPhone", "device_pin" => 'abcd'
+      expect(last_response).to be_ok
+      expect(@c.device_type).to eq('Apple')
+      expect(@c.device_pin).to eq('abcd')
+      expect(@c.id.length).to eq(32)
     end
 
     it "should respond to clientregister without clientcreate" do
@@ -224,12 +222,12 @@ describe "Server" do
       client_id = @c.id.clone
       @c = nil
       do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{client_id}/register",
-        "device_type" => "iPhone", "device_pin" => 'abcd'
-      last_response.should be_ok
+              "device_type" => "iPhone", "device_pin" => 'abcd'
+      expect(last_response).to be_ok
       @c = Client.load(client_id, {:source_name => '*'})
-      @c.device_type.should == 'iPhone'
-      @c.device_pin.should == 'abcd'
-      @c.id.length.should == 32
+      expect(@c.device_type).to eq('iPhone')
+      expect(@c.device_pin).to eq('abcd')
+      expect(@c.id.length).to eq(32)
     end
 
     it "should respond to clientreset" do
@@ -241,7 +239,7 @@ describe "Server" do
     it "should respond to clientreset with old route and deprecation warning" do
       set_doc_state(@c, :cd => @data)
       get "/application/clientreset", 'client_id' => @c.id
-      last_response.headers["Warning"].index('deprecated').should_not == nil
+      expect(last_response.headers["Warning"].index('deprecated')).not_to be_nil
       verify_doc_result(@c, :cd => {})
     end
 
@@ -252,7 +250,7 @@ describe "Server" do
       set_doc_state(@c, :cd => @data)
       sources = [{'name' => 'SimpleAdapter'}]
       do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{@c.id}/reset", 'sources' => sources
-      last_response.should be_ok
+      expect(last_response).to be_ok
       @c.source_name = 'SampleAdapter'
       verify_doc_result(@c, :cd => @data)
       @c.source_name = 'SimpleAdapter'
@@ -260,327 +258,327 @@ describe "Server" do
     end
 
     it "should switch client user if client user_id doesn't match session user" do
-      set_test_data('test_db_storage',@data)
+      set_test_data('test_db_storage', @data)
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).last['insert'].should == @data
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'user2', "password" => 'testpass'
-      data = {'1'=>@product1,'2'=>@product2}
-      set_test_data('test_db_storage',data)
+      expect(JSON.parse(last_response.body).last['insert']).to eq(@data)
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => 'user2', "password" => 'testpass'
+      data = {'1' => @product1, '2' => @product2}
+      set_test_data('test_db_storage', data)
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).last['insert'].should == data
+      expect(JSON.parse(last_response.body).last['insert']).to eq(data)
     end
 
     it "should return error on routes if client doesn't exist" do
-      get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",{}, {Rhoconnect::CLIENT_ID_HEADER => "BrokenClient"}
-      last_response.body.should == "Unknown client"
-      last_response.status.should == 500
+      get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => "BrokenClient"}
+      expect(last_response.body).to eq("Unknown client")
+      expect(last_response.status).to eq(500)
     end
   end
 
   describe "source routes" do
     before(:each) do
-     do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
     end
 
     it "should post records for create" do
       @product1['_id'] = '1'
-      params = {'create'=>{'1'=>@product1}}
+      params = {'create' => {'1' => @product1}}
       do_post "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.body.should == ''
-      verify_result("test_create_storage" => {'1'=>@product1})
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('')
+      verify_result("test_create_storage" => {'1' => @product1})
     end
 
     it "should post records for update" do
       params = {'update' => @product1}
       do_put "/app/#{Rhoconnect::API_VERSION}/#{@s.name}/1", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.body.should == ''
-      verify_result("test_update_storage" => {'1'=>@product1})
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('')
+      verify_result("test_update_storage" => {'1' => @product1})
     end
 
     it "should post records for update using the old route and have the deprecation warning" do
-      params = {'update'=>{'1'=>@product1},:client_id => @c.id,:source_name => @s.name,
-        :version => Rhoconnect::SYNC_VERSION}
+      params = {'update' => {'1' => @product1}, :client_id => @c.id, :source_name => @s.name,
+                :version => Rhoconnect::SYNC_VERSION}
       do_post "/application", params
-      last_response.should be_ok
-      last_response.body.should == ''
-      last_response.headers["Warning"].index('deprecated').should_not == nil
-      verify_result("test_update_storage" => {'1'=>@product1})
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('')
+      expect(last_response.headers["Warning"].index('deprecated')).not_to be_nil
+      verify_result("test_update_storage" => {'1' => @product1})
     end
 
     it "should post records for delete" do
       set_doc_state(@c, :cd => @data)
-      delete "/app/#{Rhoconnect::API_VERSION}/#{@s.name}/1", {}, { Rhoconnect::CLIENT_ID_HEADER => @c.id }
-      last_response.should be_ok
-      last_response.body.should == ''
-      verify_result("test_delete_storage" => {'1'=>@product1})
+      delete "/app/#{Rhoconnect::API_VERSION}/#{@s.name}/1", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('')
+      verify_result("test_delete_storage" => {'1' => @product1})
     end
 
     it "should post records for delete using the old route with deprecation warning" do
-      params = {'delete'=>{'1'=>@product1},:client_id => @c.id,:source_name => @s.name,
-        :version => Rhoconnect::SYNC_VERSION}
+      params = {'delete' => {'1' => @product1}, :client_id => @c.id, :source_name => @s.name,
+                :version => Rhoconnect::SYNC_VERSION}
       do_post "/api/application/queue_updates", params
-      last_response.should be_ok
-      last_response.headers["Warning"].index('deprecated').should_not == nil
-      last_response.body.should == ''
-      verify_result("test_delete_storage" => {'1'=>@product1})
+      expect(last_response).to be_ok
+      expect(last_response.headers["Warning"].index('deprecated')).not_to be_nil
+      expect(last_response.body).to eq('')
+      verify_result("test_delete_storage" => {'1' => @product1})
     end
 
     it "should handle client posting broken json" do
       broken_json = "{\"foo\":\"bar\"\"}"
       do_post "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", broken_json, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.status.should == 500
-      last_response.body.should == "Server error while processing client data"
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq("Server error while processing client data")
     end
 
     it "should not login if login is empty" do
-      post "/rc/#{Rhoconnect::API_VERSION}/app/login",  ''
-      last_response.status.should == 401
-      last_response.body.should == "Unable to authenticate ''"
+      post "/rc/#{Rhoconnect::API_VERSION}/app/login", ''
+      expect(last_response.status).to eq(401)
+      expect(last_response.body).to eq("Unable to authenticate ''")
     end
 
-    it "should resend page if page exists and no token provided" do
-      expected = {'1'=>@product1}
-      set_test_data('test_db_storage',{'1'=>@product1,'2'=>@product2,'4'=>@product4})
+    xit "should resend page if page exists and no token provided" do
+      expected = {'1' => @product1}
+      set_test_data('test_db_storage', {'1' => @product1, '2' => @product2, '4' => @product4})
       params = {'name' => 'iPhone'}
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:query => params}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.content_type.should =~ /application\/json/
+      expect(last_response).to be_ok
+      expect(last_response.content_type).to match /application\/json/
       token = @c.get_value(:page_token)
-      last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
+      expect(last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER]).to eq(token)
       last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 1.to_s
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>token},
-        {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},{'insert'=>expected}]
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token},
+                                                {"count" => 1}, {"progress_count" => 0}, {"total_count" => 1}, {'insert' => expected}])
       # this should re-send the page
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:query => params}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.content_type.should =~ /application\/json/
+      expect(last_response).to be_ok
+      expect(last_response.content_type).to match /application\/json/
       token1 = @c.get_value(:page_token)
-      token1.should == token
-      last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token1
+      expect(token1).to eq(token)
+      expect(last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER]).to eq(token)
       last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 1.to_s
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>token1},
-        {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},{'insert'=>expected}]
+      JSON.parse(last_response.body).should == [{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token1},
+                                                {"count" => 1}, {"progress_count" => 0}, {"total_count" => 1}, {'insert' => expected}]
       # this should ack_token
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:token => token, :query => params}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.content_type.should =~ /application\/json/
+      expect(last_response).to be_ok
+      expect(last_response.content_type).to match /application\/json/
       last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == ""
       last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 0.to_s
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>""},
-        {"count"=>0}, {"progress_count"=>0},{"total_count"=>1},{}]
+      JSON.parse(last_response.body).should == [{'version' => Rhoconnect::SYNC_VERSION}, {"token" => ""},
+                                                {"count" => 0}, {"progress_count" => 0}, {"total_count" => 1}, {}]
       @c.get_data(:page).should == {}
       @c.get_value(:page_token).should be_nil
     end
 
     it "should get inserts json" do
-      data = {'1'=>@product1,'2'=>@product2}
-      set_test_data('test_db_storage',data)
+      data = {'1' => @product1, '2' => @product2}
+      set_test_data('test_db_storage', data)
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.content_type.should =~ /application\/json/
+      expect(last_response).to be_ok
+      expect(last_response.content_type).to match /application\/json/
       token = @c.get_value(:page_token)
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>token},
-        {"count"=>2}, {"progress_count"=>0},{"total_count"=>2},{'insert'=>data}]
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token},
+                                                {"count" => 2}, {"progress_count" => 0}, {"total_count" => 2}, {'insert' => data}])
     end
 
     it "should get inserts json with the old route and show deprecation warning" do
-      data = {'1'=>@product1,'2'=>@product2}
-      set_test_data('test_db_storage',data)
-      get "/application",:client_id => @c.id,:source_name => @s.name,:version => Rhoconnect::SYNC_VERSION
-      last_response.should be_ok
-      last_response.headers["Warning"].index('deprecated').should_not == nil
-      last_response.content_type.should =~ /application\/json/
+      data = {'1' => @product1, '2' => @product2}
+      set_test_data('test_db_storage', data)
+      get "/application", :client_id => @c.id, :source_name => @s.name, :version => Rhoconnect::SYNC_VERSION
+      expect(last_response).to be_ok
+      expect(last_response.headers["Warning"].index('deprecated')).not_to be_nil
+      expect(last_response.content_type).to match /application\/json/
       token = @c.get_value(:page_token)
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token},
-        {"count"=>2}, {"progress_count"=>0},{"total_count"=>2},{'insert'=>data}]
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token},
+                                                {"count" => 2}, {"progress_count" => 0}, {"total_count" => 2}, {'insert' => data}])
     end
 
     it "should get inserts json and confirm token" do
-      data = {'1'=>@product1,'2'=>@product2}
-      set_test_data('test_db_storage',data)
+      data = {'1' => @product1, '2' => @product2}
+      set_test_data('test_db_storage', data)
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
+      expect(last_response).to be_ok
       token = @c.get_value(:page_token)
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token},
-        {"count"=>2}, {"progress_count"=>0}, {"total_count"=>2},{'insert'=>data}]
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token},
+                                                {"count" => 2}, {"progress_count" => 0}, {"total_count" => 2}, {'insert' => data}])
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:token => token}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>''},
-        {"count"=>0}, {"progress_count"=>0}, {"total_count"=>2},{}]
+      expect(last_response).to be_ok
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => ''},
+                                                {"count" => 0}, {"progress_count" => 0}, {"total_count" => 2}, {}])
     end
 
     # check custom partitions
     it "should return data for user with custom partition name" do
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => 'cus_user1', "password" => 'testpass'
       @c_fields = {
-        :device_type => 'Apple',
-        :device_pin => 'abcd',
-        :device_port => '3333',
-        :user_id => 'cus_user1',
-        :app_id => @a.id
+          :device_type => 'Apple',
+          :device_pin => 'abcd',
+          :device_port => '3333',
+          :user_id => 'cus_user1',
+          :app_id => @a.id
       }
-      @c = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+      @c = Client.create(@c_fields, {:source_name => @s_fields[:name]})
       @s = Source.load('SampleAdapter', {:user_id => 'cus_user1', :app_id => APP_NAME})
 
-      data = {'1'=>@product1,'2'=>@product2}
-      set_test_data('test_db_storage',data)
+      data = {'1' => @product1, '2' => @product2}
+      set_test_data('test_db_storage', data)
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
+      expect(last_response).to be_ok
       token = @c.get_value(:page_token)
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token},
-        {"count"=>2}, {"progress_count"=>0}, {"total_count"=>2},{'insert'=>data}]
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token},
+                                                {"count" => 2}, {"progress_count" => 0}, {"total_count" => 2}, {'insert' => data}])
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:token => token}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>''},
-        {"count"=>0}, {"progress_count"=>0}, {"total_count"=>2},{}]
-      @s.docname(:md).should == "source:#{@s.app.id}:custom_partition:SampleAdapter:md"
+      expect(last_response).to be_ok
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => ''},
+                                                {"count" => 0}, {"progress_count" => 0}, {"total_count" => 2}, {}])
+      expect(@s.docname(:md)).to eq("source:#{@s.app.id}:custom_partition:SampleAdapter:md")
       verify_doc_result(@s, :md => data)
     end
 
     it "should create source for dynamic adapter if source_name is unknown" do
       get "/app/#{Rhoconnect::API_VERSION}/Broken", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.status.should == 200
+      expect(last_response.status).to eq(200)
     end
 
     it "should create source for dynamic adapter if source_name is unknown using the old route" do
       get "/api/application/query", {:source_name => @s_fields[:name], :client_id => @c.id}
-      last_response.status.should == 200
+      expect(last_response.status).to eq(200)
     end
 
     it "should get deletes json" do
-      @s = Source.load(@s_fields[:name],@s_params)
-      data = {'1'=>@product1,'2'=>@product2}
-      set_test_data('test_db_storage',data)
+      @s = Source.load(@s_fields[:name], @s_params)
+      data = {'1' => @product1, '2' => @product2}
+      set_test_data('test_db_storage', data)
 
       get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
+      expect(last_response).to be_ok
       token = @c.get_value(:page_token)
-      last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
-      last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 2.to_s
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token},
-        {"count"=>2}, {"progress_count"=>0}, {"total_count"=>2},{'insert'=>data}]
+      expect(last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER]).to eq(token)
+      expect(last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER]).to eq(2.to_s)
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token},
+                                                {"count" => 2}, {"progress_count" => 0}, {"total_count" => 2}, {'insert' => data}])
 
       Store.flush_data('test_db_storage')
       @s.read_state.refresh_time = Time.now.to_i
 
-      get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",{:token => token}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
+      get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:token => token}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(last_response).to be_ok
       token = @c.get_value(:page_token)
-      last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
-      last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 2.to_s
-      JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token},
-        {"count"=>2}, {"progress_count"=>0}, {"total_count"=>0},{'delete'=>data}]
+      expect(last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER]).to eq(token)
+      expect(last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER]).to eq(2.to_s)
+      expect(JSON.parse(last_response.body)).to eq([{'version' => Rhoconnect::SYNC_VERSION}, {"token" => token},
+                                                {"count" => 2}, {"progress_count" => 0}, {"total_count" => 0}, {'delete' => data}])
     end
 
     it "should get search results using the old route with deprecation warning" do
-      sources = [{:name=>'SampleAdapter'}]
-      Store.put_data('test_db_storage',@data)
-      params = {:client_id => @c.id,:sources => sources,:search => {'name' => 'iPhone'},
-        :version => Rhoconnect::SYNC_VERSION}
-      get "/api/application/search",params
-      last_response.headers['Warning'].index('deprecated').should_not == nil
-      last_response.content_type.should =~ /application\/json/
+      sources = [{:name => 'SampleAdapter'}]
+      Store.put_data('test_db_storage', @data)
+      params = {:client_id => @c.id, :sources => sources, :search => {'name' => 'iPhone'},
+                :version => Rhoconnect::SYNC_VERSION}
+      get "/api/application/search", params
+      expect(last_response.headers['Warning'].index('deprecated')).not_to be_nil
+      expect(last_response.content_type).to match /application\/json/
       token = @c.get_value(:search_token)
-      last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
-      last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 1.to_s
-      JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
-        {'source'=>sources[0][:name]},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
+      expect(last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER]).to eq(token)
+      expect(last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER]).to eq(1.to_s)
+      expect(JSON.parse(last_response.body)).to eq([[{'version' => Rhoconnect::SYNC_VERSION}, {'token' => token},
+                                                 {'source' => sources[0][:name]}, {'count' => 1}, {'insert' => {'1' => @product1}}]])
     end
 
     it "should get search results" do
-      sources = [{:name=>'SampleAdapter'}]
-      Store.put_data('test_db_storage',@data)
-      params = {:sources => sources,:search => {'name' => 'iPhone'}}
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/search",params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.content_type.should =~ /application\/json/
+      sources = [{:name => 'SampleAdapter'}]
+      Store.put_data('test_db_storage', @data)
+      params = {:sources => sources, :search => {'name' => 'iPhone'}}
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(last_response.content_type).to match /application\/json/
       token = @c.get_value(:search_token)
-      JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
-        {'source'=>sources[0][:name]},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
+      expect(JSON.parse(last_response.body)).to eq([[{'version' => Rhoconnect::SYNC_VERSION}, {'token' => token},
+                                                 {'source' => sources[0][:name]}, {'count' => 1}, {'insert' => {'1' => @product1}}]])
     end
 
     it "should get search results with error" do
-      sources = [{:name=>'SampleAdapter'}]
+      sources = [{:name => 'SampleAdapter'}]
       msg = "Error during search"
-      error = set_test_data('test_db_storage',@data,msg,'search error')
-      params = {:sources => sources,:search => {'name' => 'iPhone'}}
+      error = set_test_data('test_db_storage', @data, msg, 'search error')
+      params = {:sources => sources, :search => {'name' => 'iPhone'}}
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::SYNC_VERSION},{'source'=>sources[0][:name]},
-            {'search-error'=>{'search-error'=>{'message'=>msg}}}]]
+      expect(JSON.parse(last_response.body)).to eq([[{'version' => Rhoconnect::SYNC_VERSION}, {'source' => sources[0][:name]},
+                                                 {'search-error' => {'search-error' => {'message' => msg}}}]])
       verify_doc_result(@c, :search => {})
     end
 
     it "should get multiple source search results" do
-      Store.put_data('test_db_storage',@data)
-      sources = [{:name=>'SimpleAdapter'},{:name=>'SampleAdapter'}]
-      params = {:sources => sources,:search => {'search' => 'bar'}}
+      Store.put_data('test_db_storage', @data)
+      sources = [{:name => 'SimpleAdapter'}, {:name => 'SampleAdapter'}]
+      params = {:sources => sources, :search => {'search' => 'bar'}}
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
       @c.source_name = 'SimpleAdapter'
       token1 = @c.get_value(:search_token)
       @c.source_name = 'SampleAdapter'
       token = @c.get_value(:search_token)
-      JSON.parse(last_response.body).should == [
-        [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token1},{"source"=>"SimpleAdapter"},
-         {"count"=>1}, {"insert"=>{'obj'=>{'foo'=>'bar'}}}],
-        [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},{"source"=>"SampleAdapter"},
-         {"count"=>1}, {"insert"=>{'1'=>@product1}}]]
-      verify_doc_result(@c, {:search => {'1'=>@product1},
+      expect(JSON.parse(last_response.body)).to eq([
+          [{'version' => Rhoconnect::SYNC_VERSION}, {'token' => token1}, {"source" => "SimpleAdapter"},
+           {"count" => 1}, {"insert" => {'obj' => {'foo' => 'bar'}}}],
+          [{'version' => Rhoconnect::SYNC_VERSION}, {'token' => token}, {"source" => "SampleAdapter"},
+           {"count" => 1}, {"insert" => {'1' => @product1}}]])
+      verify_doc_result(@c, {:search => {'1' => @product1},
                              :search_errors => {}})
     end
 
     it "should handle search for pass through" do
-      sources = [{'name'=>'SampleAdapter'}]
+      sources = [{'name' => 'SampleAdapter'}]
       set_state('test_db_storage' => @data)
       @s.pass_through = 'true'
       params = {:sources => sources, :search => {'name' => 'iPhone'}}
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
       token = @c.get_value(:search_token)
-      JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
-        {'source'=>sources[0]['name']},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
+      expect(JSON.parse(last_response.body)).to eq([[{'version' => Rhoconnect::SYNC_VERSION}, {'token' => token},
+                                                 {'source' => sources[0]['name']}, {'count' => 1}, {'insert' => {'1' => @product1}}]])
       verify_doc_result(@c, {:search => {},
                              :search_errors => {}})
     end
 
     it "should handle multiple source search with one source returning nothing" do
-      set_test_data('test_db_storage',@data)
-      sources = [{'name'=>'SimpleAdapter'},{'name'=>'SampleAdapter'}]
-      params = {:sources => sources,:search => {'name' => 'iPhone'}}
+      set_test_data('test_db_storage', @data)
+      sources = [{'name' => 'SimpleAdapter'}, {'name' => 'SampleAdapter'}]
+      params = {:sources => sources, :search => {'name' => 'iPhone'}}
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
       @c.source_name = 'SimpleAdapter'
       token1 = @c.get_value(:search_token)
-      token1.should be_nil
+      expect(token1).to be_nil
       @c.source_name = 'SampleAdapter'
       token = @c.get_value(:search_token)
-      JSON.parse(last_response.body).should == [[],[{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
-        {"source"=>"SampleAdapter"},{"count"=>1},{"insert"=>{'1'=>@product1}}]]
+      expect(JSON.parse(last_response.body)).to eq([[], [{'version' => Rhoconnect::SYNC_VERSION}, {'token' => token},
+                                                     {"source" => "SampleAdapter"}, {"count" => 1}, {"insert" => {'1' => @product1}}]])
     end
 
     it "should handle search and ack of search results" do
-      set_test_data('test_db_storage',@data)
-      sources = [{'name'=>'SimpleAdapter'},{'name'=>'SampleAdapter'}]
-      params = {:sources => sources,:search => {'search'=>'bar'}}
+      set_test_data('test_db_storage', @data)
+      sources = [{'name' => 'SimpleAdapter'}, {'name' => 'SampleAdapter'}]
+      params = {:sources => sources, :search => {'search' => 'bar'}}
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
       @c.source_name = 'SimpleAdapter'
       token = @c.get_value(:search_token)
-      token.should_not be_nil
+      expect(token).not_to be_nil
       sources[0]['token'] = token
-      @c.get_data(:search).should == {'obj'=>{'foo'=>'bar'}}
+      expect(@c.get_data(:search)).to eq({'obj' => {'foo' => 'bar'}})
       @c.source_name = 'SampleAdapter'
       token1 = @c.get_value(:search_token)
-      token1.should_not be_nil
+      expect(token1).not_to be_nil
       sources[1]['token'] = token1
-      @c.get_data(:search).should == {'1'=>@product1}
+      expect(@c.get_data(:search)).to eq('1' => @product1)
       # do ack on multiple sources
       do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
       @c.source_name = 'SimpleAdapter'
       token = @c.get_value(:search_token)
-      token.should be_nil
-      @c.get_data(:search).should == {}
+      expect(token).to be_nil
+      expect(@c.get_data(:search)).to eq({})
       @c.source_name = 'SampleAdapter'
       token1 = @c.get_value(:search_token)
-      token1.should be_nil
-      @c.get_data(:search).should == {}
+      expect(token1).to be_nil
+      expect(@c.get_data(:search)).to eq({})
     end
   end
 
@@ -596,117 +594,117 @@ describe "Server" do
     it "should make initial bulk data request (which creates Resque job) and receive wait (and no deprecation warning)" do
       set_state('test_db_storage' => @data)
       post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.body.should == {:result => :wait}.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq({:result => :wait}.to_json)
       warning_header = last_response.headers['Warning']
-      warning_header.should == nil or warning_header.index('deprecated').should == nil
-      Resque.peek(:bulk_data).should == {"args"=>
-        [{"data_name"=>File.join(@a_fields[:name],@u_fields[:login],@u_fields[:login])}],
-          "class"=>"Rhoconnect::BulkDataJob"}
+      expect(warning_header).to be_nil or expect(warning_header.index('deprecated')).to be_nil
+      expect(Resque.peek(:bulk_data)).to eq({"args" =>
+                                             [{"data_name" => File.join(@a_fields[:name], @u_fields[:login], @u_fields[:login])}],
+                                         "class" => "Rhoconnect::BulkDataJob"})
     end
 
     it "should make old-way initial bulk data request and receive wait along with deprecation warning" do
       set_state('test_db_storage' => @data)
       get "/application/bulk_data", :partition => :user, :client_id => @c.id
-      last_response.should be_ok
-      last_response.body.should == {:result => :wait}.to_json
-      last_response.headers['Warning'].index('deprecated').should_not == nil
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq({:result => :wait}.to_json)
+      expect(last_response.headers['Warning'].index('deprecated')).not_to be_nil
     end
 
     it "should make old-way initial bulk data request and receive wait along with deprecation warning (Sources sent as String)" do
       set_state('test_db_storage' => @data)
       get "/application/bulk_data?sources=FixedSchemaAdapter,SampleAdapter", :partition => :user, :client_id => @c.id
-      last_response.should be_ok
-      last_response.body.should == {:result => :wait}.to_json
-      last_response.headers['Warning'].index('deprecated').should_not == nil
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq({:result => :wait}.to_json)
+      expect(last_response.headers['Warning'].index('deprecated')).not_to be_nil
     end
 
     it "should receive url when bulk data is available" do
       set_state('test_db_storage' => @data)
       @a.sources.delete('JsSample')
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      data = BulkData.load(bulk_data_docname(@a.id,@u.id))
-      last_response.body.should == {:result => :url,
-        :url => data.url}.to_json
-      validate_db(data,{@s.name => @data, 'FixedSchemaAdapter' => @data})
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      do_bulk_data_job("data_name" => bulk_data_docname(@a.id, @u.id))
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(last_response).to be_ok
+      data = BulkData.load(bulk_data_docname(@a.id, @u.id))
+      expect(last_response.body).to eq({:result => :url,
+                                        :url => data.url}.to_json)
+      validate_db(data, {@s.name => @data, 'FixedSchemaAdapter' => @data})
     end
 
     it "should download bulk data file" do
       set_state('test_db_storage' => @data)
       @a.sources.delete('JsSample')
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).should == {'result' => 'url',
-                                                'url' => BulkData.load(bulk_data_docname(@a.id,@u.id)).url}
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      do_bulk_data_job("data_name" => bulk_data_docname(@a.id, @u.id))
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(JSON.parse(last_response.body)).to eq({'result' => 'url',
+                                                'url' => BulkData.load(bulk_data_docname(@a.id, @u.id)).url})
       get JSON.parse(last_response.body)["url"]
-      last_response.should be_ok
-      File.open('test.data','wb') {|f| f.puts last_response.body}
-      validate_db_file('test.data',[@s.name,'FixedSchemaAdapter'],{@s.name => @data, 'FixedSchemaAdapter' => @data})
+      expect(last_response).to be_ok
+      File.open('test.data', 'wb') {|f| f.puts last_response.body}
+      validate_db_file('test.data', [@s.name, 'FixedSchemaAdapter'], {@s.name => @data, 'FixedSchemaAdapter' => @data})
       File.delete('test.data')
       verify_doc_result(@c, :cd => @data)
       verify_doc_result(@s, {:md => @data,
-                            :md_copy => @data})
+                             :md_copy => @data})
     end
 
     it "should receive nop when no sources are available for partition" do
       set_state('test_db_storage' => @data)
-      Source.load('SimpleAdapter',@s_params).partition = :user
+      Source.load('SimpleAdapter', @s_params).partition = :user
       @a.sources.delete('OtherAdapter')
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.body.should == {:result => :nop}.to_json
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq({:result => :nop}.to_json)
     end
 
     it "should create bulk data job app partition with partition sources" do
       @s.partition = :app
       post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
-      last_response.body.should == {:result => :wait}.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq({:result => :wait}.to_json)
       warning_header = last_response.headers['Warning']
-      warning_header.should == nil or warning_header.index('deprecated').should == nil
-      Resque.peek(:bulk_data).should == {"args"=>
-        [{"data_name"=>File.join(@a_fields[:name],@a_fields[:name])}],
-          "class"=>"Rhoconnect::BulkDataJob"}
+      expect(warning_header).to be_nil or expect(warning_header.index('deprecated')).to be_nil
+      expect(Resque.peek(:bulk_data)).to eq({"args" =>
+                                             [{"data_name" => File.join(@a_fields[:name], @a_fields[:name])}],
+                                         "class" => "Rhoconnect::BulkDataJob"})
     end
 
     it "should return empty bulk data url if there are errors in query" do
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      do_bulk_data_job("data_name" => bulk_data_docname(@a.id, @u.id))
       operation = 'query'
       @s.lock(:errors) do
-        @s.put_data(:errors,{"#{operation}-error"=>{'message'=>"Some exception message"}}, true)
+        @s.put_data(:errors, {"#{operation}-error" => {'message' => "Some exception message"}}, true)
       end
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).should == {'result' => 'url', 'url' => ''}
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(JSON.parse(last_response.body)).to eq('result' => 'url', 'url' => '')
     end
 
     it "should return bulk data url for completed bulk data app partition" do
       set_state('test_db_storage' => @data)
       @s.partition = :app
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      do_bulk_data_job("data_name" => bulk_data_docname(@a.id,"*"))
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).should == {'result' => 'url',
-        'url' => BulkData.load(bulk_data_docname(@a.id,"*")).url}
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      do_bulk_data_job("data_name" => bulk_data_docname(@a.id, "*"))
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(JSON.parse(last_response.body)).to eq({'result' => 'url',
+                                                'url' => BulkData.load(bulk_data_docname(@a.id, "*")).url})
       @c.source_name = @s.name
       verify_doc_result(@c, :cd => @data)
       verify_doc_result(@s, {:md => @data,
-                            :md_copy => @data})
+                             :md_copy => @data})
     end
 
     it "should return bulk data url for completed bulk data with bulk_sync_only source" do
       set_state('test_db_storage' => @data)
       @a.sources.delete('JsSample')
       @s.sync_type = :bulk_sync_only
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).should == {'result' => 'url',
-        'url' => BulkData.load(bulk_data_docname(@a.id,@u.id)).url}
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      do_bulk_data_job("data_name" => bulk_data_docname(@a.id, @u.id))
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(JSON.parse(last_response.body)).to eq({'result' => 'url',
+                                                'url' => BulkData.load(bulk_data_docname(@a.id, @u.id)).url})
       @c.source_name = @s.name
       verify_doc_result(@c, :cd => {})
       verify_doc_result(@s, {:md => @data,
@@ -716,42 +714,42 @@ describe "Server" do
     it "should create bulk data job if no file exists" do
       set_state('test_db_storage' => @data)
       @a.sources.delete('JsSample')
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-      data = BulkData.load(bulk_data_docname(@a.id,@u.id))
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).should == {'result' => 'url', 'url' => data.url}
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      do_bulk_data_job("data_name" => bulk_data_docname(@a.id, @u.id))
+      data = BulkData.load(bulk_data_docname(@a.id, @u.id))
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(JSON.parse(last_response.body)).to eq({'result' => 'url', 'url' => data.url})
       File.delete(data.dbfile)
-      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      JSON.parse(last_response.body).should == {'result' => 'wait'}
-      Resque.peek(:bulk_data).should == {"args"=>
-        [{"data_name"=>bulk_data_docname(@a.id,@u.id)}], "class"=>"Rhoconnect::BulkDataJob"}
+      post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(JSON.parse(last_response.body)).to eq({'result' => 'wait'})
+      expect(Resque.peek(:bulk_data)).to eq({"args" =>
+                                             [{"data_name" => bulk_data_docname(@a.id, @u.id)}], "class" => "Rhoconnect::BulkDataJob"})
     end
   end
 
   describe "blob sync" do
     before(:each) do
-      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
+      do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
     end
     it "should upload blob in multipart post" do
-      file1,file2 = 'upload1.txt','upload2.txt'
+      file1, file2 = 'upload1.txt', 'upload2.txt'
       @product1['txtfile-rhoblob'] = file1
       @product1['_id'] = 'tempobj1'
       @product2['txtfile-rhoblob'] = file2
       @product2['_id'] = 'tempobj2'
-      cud = {'create'=>{'1'=>@product1,'2'=>@product2},
-        :blob_fields => ['txtfile-rhoblob']}.to_json
+      cud = {'create' => {'1' => @product1, '2' => @product2},
+             :blob_fields => ['txtfile-rhoblob']}.to_json
       post "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",
-        {:cud => cud,'txtfile-rhoblob-1' =>
-          Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__),'..','testdata',file1), "application/octet-stream"),
-          'txtfile-rhoblob-2' =>
-            Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__),'..','testdata',file2), "application/octet-stream")}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
-      last_response.should be_ok
+           {:cud => cud, 'txtfile-rhoblob-1' =>
+               Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__), '..', 'testdata', file1), "application/octet-stream"),
+            'txtfile-rhoblob-2' =>
+                Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__), '..', 'testdata', file2), "application/octet-stream")}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+      expect(last_response).to be_ok
       data = Store.get_data('test_create_storage')
-      data.size.should == 2
-      data.each do |id,obj|
-        File.exists?(obj['txtfile-rhoblob']).should == true
+      expect(data.size).to eq(2)
+      data.each do |id, obj|
+        expect(File.exists?(obj['txtfile-rhoblob'])).to be true
       end
     end
   end
-end
+end