rhoconnect 6.0.11 → 6.2.0

data/spec/server/stats_spec.rb

@@ -13,11 +13,11 @@ describe "Middleware" do
     @now = 10.0
     Store.flush_all
     app = double('app')
-    app.stub(:call)
+    allow(app).to receive(:call)
     Rhoconnect.stats = true
     Rhoconnect::Server.enable :stats
     @middleware_new_routes = Rhoconnect::Middleware::Stats.new(app)
-    Store.stub(:lock).and_yield
+    allow(Store).to receive(:lock).and_yield
   end
 
   after(:each) do
@@ -27,7 +27,7 @@ describe "Middleware" do
 
   it "should compute http average" do
     @incr = 0
-    Time.stub(:now).and_return do
+    allow(Time).to receive(:now) do
       if @incr > 0
         @now += 0.3
         @incr -= 1
@@ -43,15 +43,15 @@ describe "Middleware" do
     }
     10.times { @incr = 3; @middleware_new_routes.call(env) }
     metric = 'http:GET:/api/application/query:SampleAdapter'
-    Rhoconnect::Stats::Record.key(metric).should == "stat:#{metric}"
+    expect(Rhoconnect::Stats::Record.key(metric)).to eq("stat:#{metric}")
 
     # The conversion algorithm (float to string) currently checks two precisions.
     # it tries 16 digits and if that's not enough it then uses 17.
-    Rhoconnect::Stats::Record.range(metric, 0, -1).should == [
+    expect(Rhoconnect::Stats::Record.range(metric, 0, -1)).to eq([
       "2.0,0.6000000000000014:12",
       "2.0,0.6000000000000014:14",
       "2.0,0.6000000000000014:16",
       "2.0,0.6000000000000014:18"
-    ]
+    ])
   end
-end
+end

data/spec/server/x_domain_session_wrapper_spec.rb

@@ -50,11 +50,11 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => PROPER_QUERY_STRING
     }
     status, headers, body = @middleware_new_routes.call(env)
-    200.should == status
-    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
-    COOKIE_NV.should_not == env['HTTP_COOKIE']
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should == body[0]
+    expect(status).to eq(200)
+    expect(COOKIE_ANOTHER_NV). to eq(headers['Set-Cookie'])
+    expect(COOKIE_NV).not_to eq(env['HTTP_COOKIE'])
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect(body[0]).to eq('')
   end
 
   it "should skip if it isn't a sync protocol URI, for old REST routes" do
@@ -63,11 +63,11 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => PROPER_QUERY_STRING
     }
     status, headers, body = @middleware_old_routes.call(env)
-    200.should == status
-    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
-    COOKIE_NV.should_not == env['HTTP_COOKIE']
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should == body[0]
+    expect(status).to eq(200)
+    expect(COOKIE_ANOTHER_NV). to eq(headers['Set-Cookie'])
+    expect(COOKIE_NV).not_to eq(env['HTTP_COOKIE'])
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect(body[0]).to eq('')
   end
 
   it "should process cookie from QUERY_STRING if it is a sync protocol URI, for new REST routes" do
@@ -76,11 +76,11 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => PROPER_QUERY_STRING
     }
     status, headers, body = @middleware_new_routes.call(env)
-    200.should == status
-    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
-    env['HTTP_COOKIE'].should == COOKIE_VALUE
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should == body[0]
+    expect(status).to eq(200)
+    expect(COOKIE_ANOTHER_NV). to eq(headers['Set-Cookie'])
+    expect(env['HTTP_COOKIE']).to eq(COOKIE_VALUE)
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect(body[0]).to eq('')
   end
 
   it "should process cookie from QUERY_STRING if it is a sync protocol URI, for old REST routes" do
@@ -89,11 +89,11 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => PROPER_QUERY_STRING
     }
     status, headers, body = @middleware_old_routes.call(env)
-    200.should == status
-    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
-    env['HTTP_COOKIE'].should == COOKIE_VALUE
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should == body[0]
+    expect(status).to eq(200)
+    expect(COOKIE_ANOTHER_NV). to eq(headers['Set-Cookie'])
+    expect(env['HTTP_COOKIE']).to eq(COOKIE_VALUE)
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect(body[0]).to eq('')
   end
 
   it "shouldn't process cookie from QUERY_STRING if there is no appropriate parameter name or value, for new REST routes" do
@@ -102,11 +102,11 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => WRONG_QUERY_STRING
     }
     status, headers, body = @middleware_new_routes.call(env)
-    200.should == status
-    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
-    env['HTTP_COOKIE'].should_not == COOKIE_VALUE
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should == body[0]
+    expect(status).to eq(200)
+    expect(COOKIE_ANOTHER_NV). to eq(headers['Set-Cookie'])
+    expect(env['HTTP_COOKIE']).not_to eq(COOKIE_VALUE)
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect(body[0]).to eq('')
   end
 
   it "shouldn't process cookie from QUERY_STRING if there is no appropriate parameter name or value, for old REST routes" do
@@ -115,11 +115,11 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => WRONG_QUERY_STRING
     }
     status, headers, body = @middleware_old_routes.call(env)
-    200.should == status
-    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
-    env['HTTP_COOKIE'].should_not == COOKIE_VALUE
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should == body[0]
+    expect(status).to eq(200)
+    expect(COOKIE_ANOTHER_NV). to eq(headers['Set-Cookie'])
+    expect(env['HTTP_COOKIE']).not_to eq(COOKIE_VALUE)
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect(body[0]).to eq('')
   end
 
   it "should respond with cookie in a body if it is a login URI, for new REST routes" do
@@ -128,11 +128,11 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => PROPER_QUERY_STRING
     }
     status, headers, body = @middleware_new_routes.call(env)
-    200.should == status
-    headers['Set-Cookie'].should == COOKIE_ANOTHER_NV
-    env['HTTP_COOKIE'].should == COOKIE_VALUE
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should_not == body[0]
+    expect(status).to eq(200)
+    expect(headers['Set-Cookie']).to eq(COOKIE_ANOTHER_NV)
+    expect(env['HTTP_COOKIE']).to eq(COOKIE_VALUE)
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect('').not_to eq(body[0])
   end
 
   it "should respond with cookie in a body if it is a login URI, for old REST routes" do
@@ -141,10 +141,10 @@ describe "XDomainSessionWrapper middleware" do
         'QUERY_STRING' => PROPER_QUERY_STRING
     }
     status, headers, body = @middleware_old_routes.call(env)
-    200.should == status
-    headers['Set-Cookie'].should == COOKIE_ANOTHER_NV
-    env['HTTP_COOKIE'].should == COOKIE_VALUE
-    headers['Content-Length'].should == body[0].length.to_s
-    ''.should_not == body[0]
+    expect(status).to eq(200)
+    expect(headers['Set-Cookie']).to eq(COOKIE_ANOTHER_NV)
+    expect(env['HTTP_COOKIE']).to eq(COOKIE_VALUE)
+    expect(headers['Content-Length']).to eq(body[0].length.to_s)
+    expect('').not_to eq(body[0])
   end
 end

data/spec/source_adapter_spec.rb

@@ -61,7 +61,7 @@ describe "Model" do
 
   it "should create model with trailing spaces" do
     s = setup_adapter('SimpleAdapter ')
-    Rhoconnect::Model::Base.create(s).is_a?(SimpleAdapter).should be_true
+    Rhoconnect::Model::Base.create(s).is_a?(SimpleAdapter).should be  true
   end
 
   describe "model methods" do
@@ -152,4 +152,4 @@ describe "Model" do
       end
     end
   end
-end
+end

data/spec/source_sync_spec.rb

@@ -578,7 +578,7 @@ describe "SourceSync" do
       set_source_queue_state(@s, {@create_queue_name => [[@s.name, [['5', { 'name' => 'Android', 'link' => '1', 'force_duplicate_error' => '1' }]]]]},@c.id,true)
       @sscud.do_cud
       verify_source_queue_data(@s, @create_queue_name => [])
-      verify_doc_result(@c, :create_errors => {"5-error"=>{"message"=>"Error during create: object confict detected"}, "5"=>{"name"=>"Android", "link"=>"1", 'force_duplicate_error' => '1'}} )
+      verify_doc_result(@c, :create_errors => {"5-error"=>{"message"=>"Error during create: object conflict detected"}, "5"=>{"name"=>"Android", "link"=>"1", 'force_duplicate_error' => '1'}} )
     end
 
     it "should detect create conflict in the intermediate state create and skip the duplicate record create" do
@@ -609,7 +609,7 @@ describe "SourceSync" do
       @sscud.do_cud
 
       verify_source_queue_data(@s, @update_queue_name => [])
-      verify_doc_result(@c, :update_errors => {"4-error"=>{"message"=>"Error during update: object confict detected"}, "4"=>{"name"=>"ErrorName", 'force_duplicate_error' => '1'}})
+      verify_doc_result(@c, :update_errors => {"4-error"=>{"message"=>"Error during update: object conflict detected"}, "4"=>{"name"=>"ErrorName", 'force_duplicate_error' => '1'}})
       verify_doc_result(@c, :update_rollback => {'4'=> {'name' => 'Apple'}})
     end
 
@@ -644,7 +644,7 @@ describe "SourceSync" do
       @sscud.do_cud
 
       verify_source_queue_data(@s, @update_queue_name => [])
-      verify_doc_result(@c, :update_errors => {"4-error"=>{"message"=>"Error during update: object confict detected"}, "4"=>{"name"=>"ErrorName", 'force_duplicate_error' => '1'}})
+      verify_doc_result(@c, :update_errors => {"4-error"=>{"message"=>"Error during update: object conflict detected"}, "4"=>{"name"=>"ErrorName", 'force_duplicate_error' => '1'}})
       verify_doc_result(@c, :update_rollback => {'4'=> {'name' => 'Apple'}})
     end
 
@@ -704,7 +704,7 @@ describe "SourceSync" do
       @sscud.do_cud
 
       verify_source_queue_data(@s, @delete_queue_name => [])
-      verify_doc_result(@c, :delete_errors => {"4-error"=>{"message"=>"Error during delete: object confict detected"}, "4"=>{"name"=>"Apple", 'force_duplicate_error' => '1'}})
+      verify_doc_result(@c, :delete_errors => {"4-error"=>{"message"=>"Error during delete: object conflict detected"}, "4"=>{"name"=>"Apple", 'force_duplicate_error' => '1'}})
     end
   end
 

data/spec/spec_helper.rb

@@ -143,7 +143,7 @@ module TestHelpers
   end
 
   def setup_post_yield(response)
-    RestClient.stub(:post).and_yield(response, nil, nil)
+    allow(RestClient).to receive(:post).and_yield(response, nil, nil)
   end
 
   def set_state(state,append=false)
@@ -186,11 +186,11 @@ module TestHelpers
       expected = result[dockey]
       begin
         if expected.is_a?(Hash)
-          Store.get_data(dockey).should == expected
+          expect(Store.get_data(dockey)).to eq(expected)
         elsif expected.is_a?(Array)
-          Store.get_data(dockey,Array).should == expected
+          expect(Store.get_data(dockey, Array)).to eq(expected)
         else
-          Store.get_value(dockey).should == expected
+          expect(Store.get_value(dockey)).to eq(expected)
         end
       rescue RSpec::Expectations::ExpectationNotMetError => e
         message = "\nVerifying `#{dockey}`\n\n" + e.to_s
@@ -204,11 +204,11 @@ module TestHelpers
       expected = result[dockey]
       begin
         if expected.is_a?(Hash)
-          docobj.get_data(dockey).should == expected
+          expect(docobj.get_data(dockey)).to eq(expected)
         elsif expected.is_a?(Array)
-          docobj.get_data(dockey,Array).should == expected
+          expect(docobj.get_data(dockey,Array)).to eq(expected)
         else
-          docobj.get_value(dockey).should == expected
+          expect(docobj.get_value(dockey)).to eq(expected)
         end
       rescue RSpec::Expectations::ExpectationNotMetError => e
         message = "\nVerifying `#{dockey}`\n\n" + e.to_s
@@ -222,7 +222,7 @@ module TestHelpers
       expected = result[dockey]
       begin
         data,assoc_keys = source.get_queue(dockey)
-        data.should == expected
+        expect(data).to eq(expected)
       rescue RSpec::Expectations::ExpectationNotMetError => e
         message = "\nVerifying `#{dockey}`\n\n" + e.to_s
         Kernel::raise(RSpec::Expectations::ExpectationNotMetError.new(message))

data/spec/stats/record_spec.rb

@@ -16,13 +16,13 @@ describe "Record" do
   end
 
   it "should add metric to the record and trim record size" do
-    Time.stub(:now).and_return { @now }
+    allow(Time).to receive(:now) { @now }
     10.times { @now += 1; Rhoconnect::Stats::Record.add('foo') }
     Store.zrange('stat:foo', 0, -1).should == ["2:12", "2:14", "2:16", "2:18"]
   end
 
   it "should add single record" do
-    Time.stub(:now).and_return { @now += 1; @now }
+    allow(Time).to receive(:now) { @now += 1; @now }
     Rhoconnect::Stats::Record.add('foo')
     Store.zrange('stat:foo', 0, -1).should == ["1:10"]
   end
@@ -49,7 +49,7 @@ describe "Record" do
   end
 
   it "should add absolute metric value" do
-    Time.stub(:now).and_return { @now }
+    allow(Time).to receive(:now) { @now }
     time = 0
     4.times do
       @now += 1
@@ -62,7 +62,7 @@ describe "Record" do
   it "should update metric" do
     Rhoconnect.stats = true
     @incr = 0
-    Time.stub(:now).and_return do
+    allow(Time).to receive(:now) do
       if @incr > 0
         @now += 1
         @incr -= 1
@@ -80,13 +80,13 @@ describe "Record" do
   end
 
   it "should get range of metric values" do
-    Time.stub(:now).and_return { @now }
+    allow(Time).to receive(:now) { @now }
     10.times { @now += 1; Rhoconnect::Stats::Record.add('foo') }
     Rhoconnect::Stats::Record.range('foo', 0, 1).should == ["2:12", "2:14"]
   end
 
   it "should reset metric" do
-    Time.stub(:now).and_return { @now }
+    allow(Time).to receive(:now) { @now }
     10.times { @now += 1; Rhoconnect::Stats::Record.add('foo') }
     Store.zrange('stat:foo', 0, -1).should == ["2:12", "2:14", "2:16", "2:18"]
     Rhoconnect::Stats::Record.reset('foo')
@@ -99,4 +99,4 @@ describe "Record" do
     Rhoconnect::Stats::Record.reset_all
     Store.keys('stat:*').should == []
   end
-end
+end

data/spec/store_orm_spec.rb

@@ -1,13 +1,13 @@
 # Taken from http://github.com/voloko/redis-model
-require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe Rhoconnect::StoreOrm do
 
   context "DSL" do
     class TestDSL < Rhoconnect::StoreOrm
       field :foo
-      list  :bar
-      set   :sloppy
+      list :bar
+      set :sloppy
     end
 
     before(:each) do
@@ -15,37 +15,37 @@ describe Rhoconnect::StoreOrm do
     end
 
     it "should define rw accessors for field" do
-      @x.should respond_to(:foo)
-      @x.should respond_to(:foo=)
+      expect(@x).to respond_to(:foo)
+      expect(@x).to respond_to(:foo=)
     end
 
     it "should define r accessor for list" do
-      @x.should respond_to(:bar)
+      expect(@x).to respond_to(:bar)
     end
 
     it "should define r accessor for set" do
-      @x.should respond_to(:sloppy)
+      expect(@x).to respond_to(:sloppy)
     end
 
     it "should raise error on invalid type" do
-      lambda do
+      expect(lambda do
         class TestInvalidType < Rhoconnect::StoreOrm
           field :invalid, :invalid_type
         end
-      end.should raise_error(ArgumentError, 'Unknown type invalid_type for field invalid')
+      end).to raise_error(ArgumentError, 'Unknown type invalid_type for field invalid')
     end
   end
 
   context "field type cast" do
     class TestType < Rhoconnect::StoreOrm
       field :foo_string, :string
-      field :foo_json,   :json
-      field :foo_date,   :datetime
-      field :foo_int,    :int
-      field :foo_float,  :float
+      field :foo_json, :json
+      field :foo_date, :datetime
+      field :foo_int, :int
+      field :foo_float, :float
 
-      list  :list_date,  :datetime
-      set   :set_date,   :datetime
+      list :list_date, :datetime
+      set :set_date, :datetime
     end
 
     class TestValidateType < Rhoconnect::StoreOrm
@@ -61,135 +61,135 @@ describe Rhoconnect::StoreOrm do
     before(:each) do
       Store.create
       Store.flush_all
+=begin
       @xRedisMock = RSpec::Mocks::Mock.new
       @yRedisMock = RSpec::Mocks::Mock.new
       @xRedisDbMock = RSpec::Mocks::Mock.new
       @yRedisDbMock = RSpec::Mocks::Mock.new
+=end
       @x = TestType.with_key(1)
       @y = TestType.with_key(1)
-      @x.stub(:store).and_return(@xRedisMock)
-      @y.stub(:store).and_return(@yRedisMock)
-      @xRedisMock.stub(:db).and_return(@xRedisDbMock)
-      @yRedisMock.stub(:db).and_return(@yRedisDbMock)
+      allow(@x).to receive(:store).and_return(@xRedisMock)
+      allow(@y).to receive(:store).and_return(@yRedisMock)
+      allow(@xRedisMock).to receive(:db).and_return(@xRedisDbMock)
+      allow(@yRedisMock).to receive(:db).and_return(@yRedisDbMock)
     end
 
     it "should create with string id" do
       @x = TestType.create(:id => 'test')
-      @x.id.should == 'test'
+      expect(@x.id).to eq('test')
     end
 
     it "should create with auto-increment id" do
       @x = TestType.create
       @x1 = TestType.create
-      @x1.id.should == @x.id + 1
+      expect(@x1.id).to eq(@x.id + 1)
     end
 
     it "should raise ArgumentError on create with duplicate id" do
       @x = TestType.create(:id => 'test1')
-      lambda { TestType.create(:id => 'test1') }.should
-        raise_error(ArgumentError, "Record already exists for 'test1'")
+      expect(lambda {TestType.create(:id => 'test1') }).to raise_error(ArgumentError, "Record already exists for 'test1'")
     end
 
     it "should validate_presence_of v_field" do
-      lambda { TestValidateType.create(:id => 'test2') }.should
-        raise_error(ArgumentError, "Missing required field 'v_field'")
+      expect(lambda {TestValidateType.create(:id => 'test2')}).to raise_error(ArgumentError, "Missing required field 'v_field'")
     end
 
     it "should load with attributes set" do
       TestLoadType.create(:id => 'test2')
-      @x = TestLoadType.load('test2',{:foo => 'bar'})
-      @x.foo.should == 'bar'
+      @x = TestLoadType.load('test2', {:foo => 'bar'})
+      expect(@x.foo).to eq('bar')
     end
 
     it "should save string as is" do
-      @xRedisMock.should_receive(:put_value).with('test_type:1:foo_string', 'xxx')
-      @yRedisMock.should_receive(:get_value).with('test_type:1:foo_string').and_return('xxx')
+      expect(@xRedisMock).to receive(:put_value).with('test_type:1:foo_string', 'xxx')
+      expect(@yRedisMock).to receive(:get_value).with('test_type:1:foo_string').and_return('xxx')
       @x.foo_string = 'xxx'
-      @y.foo_string.should be_instance_of(String)
+      expect(@y.foo_string).to be_instance_of(String)
     end
 
     it "should marshal integer fields" do
-      @xRedisMock.should_receive(:put_value).with('test_type:1:foo_int', '12')
-      @yRedisMock.should_receive(:get_value).with('test_type:1:foo_int').and_return('12')
+      expect(@xRedisMock).to receive(:put_value).with('test_type:1:foo_int', '12')
+      expect(@yRedisMock).to receive(:get_value).with('test_type:1:foo_int').and_return('12')
       @x.foo_int = 12
-      @y.foo_int.should be_kind_of(Integer)
-      @y.foo_int.should == 12
+      expect(@y.foo_int).to be_kind_of(Integer)
+      expect(@y.foo_int).to eq(12)
     end
 
     it "should marshal float fields" do
-      @xRedisMock.should_receive(:put_value).with('test_type:1:foo_float', '12.1')
-      @yRedisMock.should_receive(:get_value).with('test_type:1:foo_float').and_return('12.1')
+      expect(@xRedisMock).to receive(:put_value).with('test_type:1:foo_float', '12.1')
+      expect(@yRedisMock).to receive(:get_value).with('test_type:1:foo_float').and_return('12.1')
       @x.foo_float = 12.1
-      @y.foo_float.should be_kind_of(Float)
-      @y.foo_float.should == 12.1
+      expect(@y.foo_float).to be_kind_of(Float)
+      expect(@y.foo_float).to eq(12.1)
     end
 
     it "should marshal datetime fields" do
       time = DateTime.now
-      str  = time.strftime('%FT%T%z')
-      @xRedisMock.should_receive(:put_value).with('test_type:1:foo_date', str)
-      @yRedisMock.should_receive(:get_value).with('test_type:1:foo_date').and_return(str)
+      str = time.strftime('%FT%T%z')
+      expect(@xRedisMock).to receive(:put_value).with('test_type:1:foo_date', str)
+      expect(@yRedisMock).to receive(:get_value).with('test_type:1:foo_date').and_return(str)
       @x.foo_date = time
-      @y.foo_date.should be_kind_of(DateTime)
-      @y.foo_date.should.to_s == time.to_s
+      expect(@y.foo_date).to be_kind_of(DateTime)
+      expect(@y.foo_date.to_s).to eq(time.to_s)
     end
 
     it "should marshal json structs" do
       data = {'foo' => 'bar', 'x' => 2}
-      str  = JSON.dump(data)
-      @xRedisMock.should_receive(:put_value).with('test_type:1:foo_json', str)
-      @yRedisMock.should_receive(:get_value).with('test_type:1:foo_json').and_return(str)
+      str = JSON.dump(data)
+      expect(@xRedisMock).to receive(:put_value).with('test_type:1:foo_json', str)
+      expect(@yRedisMock).to receive(:get_value).with('test_type:1:foo_json').and_return(str)
       @x.foo_json = data
-      @y.foo_json.should be_kind_of(Hash)
-      @y.foo_json.should.inspect == data.inspect
+      expect(@y.foo_json).to be_kind_of(Hash)
+      expect(@y.foo_json.inspect).to eq(data.inspect)
     end
 
     it "should return nil for empty fields" do
-      @xRedisMock.should_receive(:get_value).with('test_type:1:foo_date').and_return(nil)
-      @x.foo_date.should be_nil
+      expect(@xRedisMock).to receive(:get_value).with('test_type:1:foo_date').and_return(nil)
+      expect(@x.foo_date).to be_nil
     end
 
     it "should marshal list values" do
       data = DateTime.now
-      str  = data.strftime('%FT%T%z')
-
-      @xRedisDbMock.should_receive('rpush').with('test_type:1:list_date', str)
-      @xRedisDbMock.should_receive('lset').with('test_type:1:list_date', 1, str)
-      @xRedisDbMock.should_receive('exists').with('test_type:1:list_date', str)
-      @xRedisDbMock.should_receive('lrem').with('test_type:1:list_date', 0, str)
-      @xRedisDbMock.should_receive('lpush').with('test_type:1:list_date', str)
-      @xRedisDbMock.should_receive('lrange').with('test_type:1:list_date', 0, 1).and_return([str])
-      @xRedisDbMock.should_receive('rpop').with('test_type:1:list_date').and_return(str)
-      @xRedisDbMock.should_receive('lpop').with('test_type:1:list_date').and_return(str)
-      @xRedisDbMock.should_receive('lindex').with('test_type:1:list_date', 0).and_return(str)
+      str = data.strftime('%FT%T%z')
+
+      expect(@xRedisDbMock).to receive('rpush').with('test_type:1:list_date', str)
+      expect(@xRedisDbMock).to receive('lset').with('test_type:1:list_date', 1, str)
+      expect(@xRedisDbMock).to receive('exists').with('test_type:1:list_date', str)
+      expect(@xRedisDbMock).to receive('lrem').with('test_type:1:list_date', 0, str)
+      expect(@xRedisDbMock).to receive('lpush').with('test_type:1:list_date', str)
+      expect(@xRedisDbMock).to receive('lrange').with('test_type:1:list_date', 0, 1).and_return([str])
+      expect(@xRedisDbMock).to receive('rpop').with('test_type:1:list_date').and_return(str)
+      expect(@xRedisDbMock).to receive('lpop').with('test_type:1:list_date').and_return(str)
+      expect(@xRedisDbMock).to receive('lindex').with('test_type:1:list_date', 0).and_return(str)
       @x.list_date << data
       @x.list_date[1] = data
       @x.list_date.include?(data)
       @x.list_date.remove(0, data)
       @x.list_date.push_head(data)
-      @x.list_date[0].should be_kind_of(DateTime)
-      @x.list_date[0, 1][0].should be_kind_of(DateTime)
-      @x.list_date.pop_tail.should be_kind_of(DateTime)
-      @x.list_date.pop_head.should be_kind_of(DateTime)
+      expect(@x.list_date[0]).to be_kind_of(DateTime)
+      expect(@x.list_date[0, 1][0]).to be_kind_of(DateTime)
+      expect(@x.list_date.pop_tail).to be_kind_of(DateTime)
+      expect(@x.list_date.pop_head).to be_kind_of(DateTime)
     end
 
     it "should marshal set values" do
       data = DateTime.now
-      str  = data.strftime('%FT%T%z')
+      str = data.strftime('%FT%T%z')
 
-      @xRedisDbMock.should_receive('sadd').with('test_type:1:set_date', str)
-      @xRedisDbMock.should_receive('srem').with('test_type:1:set_date', str)
-      @xRedisDbMock.should_receive('sismember').with('test_type:1:set_date', str)
-      @xRedisDbMock.should_receive('smembers').with('test_type:1:set_date').and_return([str])
+      expect(@xRedisDbMock).to receive('sadd').with('test_type:1:set_date', str)
+      expect(@xRedisDbMock).to receive('srem').with('test_type:1:set_date', str)
+      expect(@xRedisDbMock).to receive('sismember').with('test_type:1:set_date', str)
+      expect(@xRedisDbMock).to receive('smembers').with('test_type:1:set_date').and_return([str])
       @x.set_date << data
       @x.set_date.delete(data)
       @x.set_date.include?(data)
-      @x.set_date.members[0].should be_kind_of(DateTime)
+      expect(@x.set_date.members[0]).to be_kind_of(DateTime)
     end
 
     it "should handle empty members" do
-      @xRedisDbMock.stub(:smembers).and_return(nil)
-      @x.set_date.members.should == []
+      allow(@xRedisDbMock).to receive(:smembers).and_return(nil)
+      expect(@x.set_date.members).to eq([])
     end
   end
 
@@ -201,25 +201,26 @@ describe Rhoconnect::StoreOrm do
     end
 
     before do
-      @redisMock = RSpec::Mocks::Mock.new
+      #@redisMock = RSpec::Mocks::Mock.new
+      @redisMock
       @x = TestIncrements.with_key(1)
-      @x.stub(:store).and_return(@redisMock)
+      allow(@x).to receive(:store).and_return(@redisMock)
     end
 
     it "should send INCR when #increment! is called on an integer" do
-      @redisMock.should_receive(:update_count).with("test_increments:1:foo", 1)
+      expect(@redisMock).to receive(:update_count).with("test_increments:1:foo", 1)
       @x.increment!(:foo)
     end
 
     it "should send DECR when #decrement! is called on an integer" do
-      @redisMock.should_receive(:update_count).with("test_increments:1:foo", -1)
+      expect(@redisMock).to receive(:update_count).with("test_increments:1:foo", -1)
       @x.decrement!(:foo)
     end
 
     it "should raise an ArgumentError when called on non-integers" do
       [:bar, :baz].each do |f|
-        lambda{@x.increment!(f)}.should raise_error(ArgumentError)
-        lambda{@x.decrement!(f)}.should raise_error(ArgumentError)
+        expect(lambda {@x.increment!(f)}).to raise_error(ArgumentError)
+        expect(lambda {@x.decrement!(f)}).to raise_error(ArgumentError)
       end
     end
   end
@@ -227,48 +228,50 @@ describe Rhoconnect::StoreOrm do
   context "redis commands" do
     class TestCommands < Rhoconnect::StoreOrm
       field :foo
-      list  :bar
-      set   :sloppy
+      list :bar
+      set :sloppy
     end
 
     before(:each) do
-      @redisMock = RSpec::Mocks::Mock.new
-      @redisDbMock = RSpec::Mocks::Mock.new
+      # @redisMock = RSpec::Mocks::Mock.new
+      # @redisDbMock = RSpec::Mocks::Mock.new
+      @redisMock
+      @redisDbMock
       @x = TestCommands.with_key(1)
-      @x.stub(:store).and_return(@redisMock)
-      @redisMock.stub(:db).and_return(@redisDbMock)
+      allow(@x).to receive(:store).and_return(@redisMock)
+      allow(@redisMock).to receive(:db).and_return(@redisDbMock)
     end
 
     it "should send GET on field read" do
-      @redisMock.should_receive(:get_value).with('test_commands:1:foo')
+      expect(@redisMock).to receive(:get_value).with('test_commands:1:foo')
       @x.foo
     end
 
     it "should send SET on field write" do
-      @redisMock.should_receive(:put_value).with('test_commands:1:foo', 'bar')
+      expect(@redisMock).to receive(:put_value).with('test_commands:1:foo', 'bar')
       @x.foo = 'bar'
     end
 
     it "should send RPUSH on list <<" do
-      @redisDbMock.should_receive(:rpush).with('test_commands:1:bar', 'bar')
+      expect(@redisDbMock).to receive(:rpush).with('test_commands:1:bar', 'bar')
       @x.bar << 'bar'
     end
 
     it "should send SADD on set <<" do
-      @redisDbMock.should_receive(:sadd).with('test_commands:1:sloppy', 'bar')
+      expect(@redisDbMock).to receive(:sadd).with('test_commands:1:sloppy', 'bar')
       @x.sloppy << 'bar'
     end
 
     it "should delete separate fields" do
-      @redisMock.should_receive(:delete_value).with('test_commands:1:foo')
+      expect(@redisMock).to receive(:delete_value).with('test_commands:1:foo')
       @x.delete :foo
     end
 
     it "should delete all field" do
-      @redisMock.should_receive(:delete_value).with('test_commands:1:foo')
-      @redisMock.should_receive(:delete_value).with('test_commands:1:rho__id')
-      @redisMock.should_receive(:delete_value).with('test_commands:1:bar')
-      @redisMock.should_receive(:delete_value).with('test_commands:1:sloppy')
+      expect(@redisMock).to receive(:delete_value).with('test_commands:1:foo')
+      expect(@redisMock).to receive(:delete_value).with('test_commands:1:rho__id')
+      expect(@redisMock).to receive(:delete_value).with('test_commands:1:bar')
+      expect(@redisMock).to receive(:delete_value).with('test_commands:1:sloppy')
       @x.delete
     end
   end