rhoconnect 5.5.18 → 7.4.1

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

data/spec/store_spec.rb

@@ -5,22 +5,22 @@ describe "Store" do
 
   describe "store methods" do
     it "should create proper connection class" do
-      Store.get_store(0).db.class.name.should match(/Redis/)
+      expect(Store.get_store(0).db.class.name).to match(/Redis/)
     end
 
     it "should create redis connection based on ENV" do
       ENV[REDIS_URL] = 'redis://localhost:6379'
-      Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(5).times.and_return { Redis.new }
+      expect(Redis).to receive(:new).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(1).times.and_call_original
       Store.nullify
-      Store.num_stores.should == 0
+      expect(Store.num_stores).to eq(0)
       Store.create
-      Store.get_store(0).db.should_not == nil
+      expect(Store.get_store(0).db).not_to be_nil
       ENV.delete(REDIS_URL)
     end
 
     it "should create redis connection based on REDISTOGO_URL ENV" do
       ENV[REDISTOGO_URL] = 'redis://localhost:6379'
-      Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(5).times.and_return { Redis.new }
+      expect(Redis).to receive(:new).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(1).and_call_original
       Store.nullify
       Store.create
       Store.get_store(0).db.should_not == nil
@@ -75,7 +75,7 @@ describe "Store" do
       Store.update_count('mydata', -5)
       Store.get_value('mydata').to_i.should == 16
       Store.delete_value('mydata')
-      Store.exists?('mydata').should be_false
+      Store.exists?('mydata').should be false
     end
 
     it "should delete_objects with simple data and verify that srem is called only on affected fields" do
@@ -288,7 +288,7 @@ describe "Store" do
       doc = "locked_data"
       lock = Time.now.to_i+3
       Store.get_store(0).db.set "lock:#{doc}", lock
-      Store.get_store(0).should_receive(:sleep).at_least(:once).with(1).and_return { sleep 1; Store.release_lock(doc,lock); }
+      expect(Store.get_store(0)).to receive(:sleep).at_least(:once).with(1) { sleep 1; Store.release_lock(doc,lock); }
       Store.get_lock(doc,4)
     end
 
@@ -318,7 +318,7 @@ describe "Store" do
       doc = "locked_data"
       Rhoconnect.lock_duration = 2
      	Store.get_lock(doc)
-     	Store.get_store(0).should_receive(:sleep).at_least(1).times.with(1).and_return { sleep 1 }
+     	expect(Store.get_store(0)).to receive(:sleep).at_least(1).times.with(1) { sleep 1 }
       Store.get_lock(doc)
      	Rhoconnect.lock_duration = nil
     end
@@ -345,8 +345,8 @@ describe "Store" do
 
     it "should not fail to rename if key doesn't exist" do
       Store.rename('key1','key2')
-      Store.exists?('key1').should be_false
-      Store.exists?('key2').should be_false
+      Store.exists?('key1').should be false
+      Store.exists?('key2').should be false
     end
 
     it "should raise ArgumentError on put_data with invalid data" do
@@ -366,9 +366,9 @@ describe "Store" do
       Store.put_object(:md, key1, data1)
       Store.put_object(:md, key2, data2)
       Store.keys(:md).should == []
-      Store.exists?("#{:md}:#{docindex1}").should be_true
-      Store.exists?("#{:md}:#{docindex2}").should be_true
-      Store.exists?("#{:md}:indices").should be_true
+      Store.exists?("#{:md}:#{docindex1}").should be  true
+      Store.exists?("#{:md}:#{docindex2}").should be  true
+      Store.exists?("#{:md}:indices").should be  true
       Store.get_store(0).db.hkeys("#{:md}:indices").should == ["#{docindex1}", "#{docindex2}"]
       Store.get_store(0).db.hvals("#{:md}:indices").should == ["#{:md}:#{docindex1}", "#{:md}:#{docindex2}"]
     end
@@ -396,20 +396,20 @@ describe "Store" do
       Store.put_tmp_data(:md, {key1 => data1})
       Store.put_tmp_data(:md, {key2 => data2}, true)
 
-      Store.exists?("#{:md}:#{docindex1}").should be_true
-      Store.exists?("#{:md}:#{docindex2}").should be_true
-      Store.exists?("#{:md}:indices").should be_true
+      Store.exists?("#{:md}:#{docindex1}").should be  true
+      Store.exists?("#{:md}:#{docindex2}").should be  true
+      Store.exists?("#{:md}:indices").should be  true
       Store.get_store(0).db.ttl("#{:md}:#{docindex1}").should == Rhoconnect.store_key_ttl
       Store.get_store(0).db.ttl("#{:md}:#{docindex2}").should == Rhoconnect.store_key_ttl
       Store.get_store(0).db.ttl("#{:md}:indices").should == Rhoconnect.store_key_ttl
 
       Store.rename_tmp_data(:md, :md_perm)
-      Store.exists?("#{:md}:#{docindex1}").should be_false
-      Store.exists?("#{:md}:#{docindex2}").should be_false
-      Store.exists?("#{:md}:indices").should be_false
-      Store.exists?("#{:md_perm}:#{docindex1}").should be_true
-      Store.exists?("#{:md_perm}:#{docindex2}").should be_true
-      Store.exists?("#{:md_perm}:indices").should be_true
+      Store.exists?("#{:md}:#{docindex1}").should be false
+      Store.exists?("#{:md}:#{docindex2}").should be false
+      Store.exists?("#{:md}:indices").should be false
+      Store.exists?("#{:md_perm}:#{docindex1}").should be  true
+      Store.exists?("#{:md_perm}:#{docindex2}").should be  true
+      Store.exists?("#{:md_perm}:indices").should be  true
       Store.get_store(0).db.ttl("#{:md_perm}:#{docindex1}").should == -1
       Store.get_store(0).db.ttl("#{:md_perm}:#{docindex2}").should == -1
       Store.get_store(0).db.ttl("#{:md_perm}:indices").should == -1
@@ -473,4 +473,4 @@ describe "Store" do
       end
     end
   end
-end
+end

data/spec/user_spec.rb

@@ -90,8 +90,8 @@ describe "User" do
 
   describe "User Stats" do
 
-    before(:all) do
-      Store.stub(:lock).and_yield
+    before(:each) do
+      allow(Store).to receive(:lock).and_yield
     end
 
     it "should increment user stats on create" do
@@ -114,4 +114,4 @@ describe "User" do
       Rhoconnect.stats = false
     end
   end
-end
+end