rhoconnect 5.5.18 → 7.4.1

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