redislike 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b32d60e77c8f6e9fc89a7df48aa4f8229564c66e
-  data.tar.gz: ce5b4dcdafb32682ac78350970cbbedd6ccca032
+  metadata.gz: be9073ce31c76bc2fe4b3395ea7118953d792c7b
+  data.tar.gz: 83f2fb7b888471aac831d9bed7ec2ac0a040c00e
 SHA512:
-  metadata.gz: ae5c0c559385cf9e46394631629f942b2bd4c5da4b9b9208d3d5ab13ad030b55fc65325b847cadb24cdf74d3bbc48bfbda23555dcb933e9addfbd468174b3b9a
-  data.tar.gz: 9e0bade973bb81c47130e8ba41975b4798d9ece654d338dda1c627ef23c071aa5e946842e59776797fabc5242c51ca3b266b8ee385f54609f3ba2b18902d385e
+  metadata.gz: 5f208e78072393e3f78831956a921fec73994e6f1761b1043c7ae6d47d272e9d8265e568ecffb368370fa36deb6b3ca161eb7eeb990a54df4daa23a94c3cf89f
+  data.tar.gz: 63531c739bd0928a9e8e201147817b80014822b88a8c39e7c91bca6a5f9cc9e46247bc6de15dc10ecc1f2feb4aee4086c1f5c2bf99bcd32013c28e7260dd0f3d

data/Rakefile

@@ -13,6 +13,11 @@ task :kintama do
   sh 'ruby tests/redislike.rb'
 end
 
+desc 'Verify Compatibility with Redis'
+task :compatibility do
+  sh 'ruby tests/compatibility/redislike.rb'
+end
+
 task audit: [:style, :complexity, :duplication, :design, :documentation]
 
 task style: [:rubocop]

data/lib/redislike/lists.rb

@@ -73,6 +73,8 @@ module RedisLike
     end
 
     def lset(list, index, item)
+      fail KeyError, 'ERR no such key' unless exists(list)
+      fail IndexError, 'ERR index out of range' unless lindex(list, index)
       items = fetch list, []
       items[index] = item
       'OK' if store list, items

data/redislike.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name        = 'redislike'
-  gem.version     = '0.1.0'
+  gem.version     = '0.2.0'
   gem.licenses    = 'MIT'
   gem.authors     = ['Chris Olstrom']
   gem.email       = 'chris@olstrom.com'

data/tests/compatibility/helpers/compatibility.rb

@@ -0,0 +1,11 @@
+module CompatibilityTesting
+  def mirror(method, *arguments)
+    original = @original.method(method).call(*arguments)
+    compatible = @compatible.method(method).call(*arguments)
+    [original, compatible]
+  end
+
+  def assert_compatible(method, *arguments)
+    assert_equal(*mirror(method, *arguments))
+  end
+end

data/tests/compatibility/redislike/lists/lindex.rb

@@ -0,0 +1,29 @@
+context 'LINDEX' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:lindex', 'foo'
+    mirror :lpush, 'test:lindex', 'bar'
+    mirror :lpush, 'test:lindex', 'baz'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :lindex, 'test:nx', 1
+  end
+
+  test 'in range' do
+    assert_compatible :lindex, 'test:lindex', 1
+  end
+
+  test 'out of range' do
+    assert_compatible :lindex, 'test:lindex', 999
+  end
+
+  teardown do
+    @original.del 'test:lindex'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/linsert.rb

@@ -0,0 +1,30 @@
+context 'LINSERT' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:linsert', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :linsert, 'test:nx', :before, 'foo', 'bar'
+    assert_compatible :linsert, 'test:nx', :after, 'foo', 'bar'
+  end
+
+  test 'when list contains pivot value' do
+    assert_compatible :linsert, 'test:linsert', :before, 'foo', 'bar'
+    assert_compatible :linsert, 'test:linsert', :after, 'foo', 'bar'
+  end
+
+  test 'when list does not contain pivot value' do
+    assert_compatible :linsert, 'test:linsert', :before, 'baz', 'bar'
+    assert_compatible :linsert, 'test:linsert', :after, 'baz', 'bar'
+  end
+
+  teardown do
+    @original.del 'test:linsert', 'test:nx'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/llen.rb

@@ -0,0 +1,24 @@
+context 'LLEN' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:llen', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :llen, 'test:nx'
+  end
+
+  test 'when list exists' do
+    mirror :lpush, 'test:llen', 'foo'
+    assert_compatible :llen, 'test:llen'
+  end
+
+  teardown do
+    @original.del 'test:llen'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/lpop.rb

@@ -0,0 +1,24 @@
+context 'LPOP' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:lpop', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :lpop, 'test:nx'
+  end
+
+  test 'when list exists' do
+    mirror :lpush, 'test:lpop', 'foo'
+    assert_compatible :lpop, 'test:nx'
+  end
+
+  teardown do
+    @original.del 'test:lpop'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/lpush.rb

@@ -0,0 +1,23 @@
+context 'LPUSH' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:lpush', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :lpush, 'test:nx', 'foo'
+  end
+
+  test 'when list has items already' do
+    assert_compatible :lpush, 'test:lpush', 'foo'
+  end
+
+  teardown do
+    @original.del 'test:lpush', 'test:nx'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/lpushx.rb

@@ -0,0 +1,23 @@
+context 'LPUSHX' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:lpushx', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :lpushx, 'test:nx', 'foo'
+  end
+
+  test 'when list has items already' do
+    assert_compatible :lpushx, 'test:lpushx', 'foo'
+  end
+
+  teardown do
+    @original.del 'test:lpushx', 'test:nx'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/lrange.rb

@@ -0,0 +1,31 @@
+context 'LRANGE' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:lrange', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :lrange, 'test:nx', 0, -1
+  end
+
+  test 'when list exists' do
+    assert_compatible :lrange, 'test:lrange', 0, -1
+  end
+
+  test 'stop beyond range' do
+    assert_compatible :lrange, 'test:lrange', 0, 9
+  end
+
+  test 'stop before start' do
+    assert_compatible :lrange, 'test:lrange', -1, 1
+  end
+
+  teardown do
+    @original.del 'test:lrange'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/lrem.rb

@@ -0,0 +1,59 @@
+context 'LREM' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    3.times { mirror :lpush, 'test:lrem', 'foo' }
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :lrem, 'test:nx', 0, 'foo'
+  end
+
+  test 'all items (present)' do
+    assert_compatible :lrem, 'test:lrem', 0, 'foo'
+  end
+
+  test 'all items (when not present)' do
+    assert_compatible :lrem, 'test:lrem', 0, 'bar'
+  end
+
+  test 'one from head (present)' do
+    assert_compatible :lrem, 'test:lrem', 1, 'foo'
+  end
+
+  test 'one from head (when not present)' do
+    assert_compatible :lrem, 'test:lrem', 1, 'bar'
+  end
+
+  test 'more than exists from head (present)' do
+    assert_compatible :lrem, 'test:lrem', 9, 'foo'
+  end
+
+  test 'more than exists from head (when not present)' do
+    assert_compatible :lrem, 'test:lrem', 9, 'bar'
+  end
+
+  test 'one from tail (present)' do
+    assert_compatible :lrem, 'test:lrem', -1, 'foo'
+  end
+
+  test 'one from tail (when not present)' do
+    assert_compatible :lrem, 'test:lrem', -1, 'bar'
+  end
+
+  test 'more than exists from tail (present)' do
+    assert_compatible :lrem, 'test:lrem', -9, 'foo'
+  end
+
+  test 'more than exists from tail (when not present)' do
+    assert_compatible :lrem, 'test:lrem', -9, 'bar'
+  end
+
+  teardown do
+    @original.del 'test:lrem'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/lset.rb

@@ -0,0 +1,20 @@
+context 'LSET' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    3.times { mirror :lpush, 'test:lset', 'foo' }
+  end
+
+  test 'in range' do
+    assert_compatible :lset, 'test:lset', 1, 'bar'
+    assert_equal mirror(:lindex, 'test:lset', 1).uniq, ['bar']
+  end
+
+  teardown do
+    @original.del 'test:lset'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/ltrim.rb

@@ -0,0 +1,24 @@
+context 'LTRIM' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    100.times { mirror :lpush, 'test:ltrim', 'foo' }
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :ltrim, 'test:nx', 0, 10
+  end
+
+  test 'when range is larger than list length' do
+    assert_compatible :ltrim, 'test:ltrim', 0, 200
+    assert_equal mirror(:lrange, 'test:ltrim', 0, -1).uniq.flatten.size, 100
+  end
+
+  teardown do
+    @original.del 'test:ltrim'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/rpop.rb

@@ -0,0 +1,25 @@
+context 'RPOP' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:rpop', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :rpop, 'test:nx'
+  end
+
+  test 'when list exists' do
+    mirror :rpush, 'test', 'foo'
+    assert_compatible :rpop, 'test:rpop'
+  end
+
+
+  teardown do
+    @original.del 'test:rpop'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/rpoplpush.rb

@@ -0,0 +1,24 @@
+context 'RPOPLPUSH' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:rpoplpush', 'foo'
+  end
+
+  test 'when source list does not exist' do
+    assert_compatible :rpoplpush, 'test:nx', 'test:rpoplpush:a'
+  end
+
+  test 'when list exists' do
+    3.times { mirror :lpush, 'test:rpoplpush:a', 'foo' }
+    assert_compatible :rpoplpush, 'test:rpoplpush:a', 'test:rpoplpush:b'
+  end
+
+  teardown do
+    @original.del 'test:rpoplpush:a', 'test:rpoplpush:b'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/rpush.rb

@@ -0,0 +1,24 @@
+context 'RPUSH' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:rpush', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :rpush, 'test:nx', 'foo'
+  end
+
+  test 'when list has items already' do
+    mirror :lpush, 'test:rpush', 'foo'
+    assert_compatible :rpush, 'test:rpush', 'foo'
+  end
+
+  teardown do
+    @original.del 'test:rpush', 'test:nx'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists/rpushx.rb

@@ -0,0 +1,25 @@
+context 'RPUSHX' do
+  include CompatibilityTesting
+
+  setup do
+    @original = Redis.new
+    @compatible = Moneta.new :Memory
+    mirror :lpush, 'test:rpushx', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_compatible :rpushx, 'test:nx', 'foo'
+  end
+
+  test 'when list has items already' do
+    mirror :lpush, 'test:rpushx', 'foo'
+    assert_compatible :rpushx, 'test:rpushx', 'foo'
+  end
+
+
+  teardown do
+    @original.del 'test:rpushx', 'test:nx'
+    @original.disconnect!
+    @compatible.close
+  end
+end

data/tests/compatibility/redislike/lists.rb

@@ -0,0 +1,14 @@
+require_relative 'lists/lindex'
+require_relative 'lists/linsert'
+require_relative 'lists/llen'
+require_relative 'lists/lpop'
+require_relative 'lists/lpush'
+require_relative 'lists/lpushx'
+require_relative 'lists/lrange'
+require_relative 'lists/lrem'
+require_relative 'lists/lset'
+require_relative 'lists/ltrim'
+require_relative 'lists/rpop'
+require_relative 'lists/rpoplpush'
+require_relative 'lists/rpush'
+require_relative 'lists/rpushx'

data/tests/compatibility/redislike.rb

@@ -0,0 +1,12 @@
+
+require 'bundler/setup'
+require 'simplecov'
+SimpleCov.command_name 'Kintama'
+SimpleCov.start { add_filter '/vendor/' }
+require 'redis'
+require 'kintama'
+require 'moneta'
+require 'redislike'
+
+require_relative 'helpers/compatibility'
+require_relative 'redislike/lists'

data/tests/redislike/lists/lindex.rb

@@ -0,0 +1,33 @@
+context 'LINDEX' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'return nothing' do
+      assert_equal nil, @db.lindex('test:nx', 1)
+    end
+  end
+
+  given 'a list with 3 items' do
+    setup do
+      @db.lpush 'test:lindex', 'foo'
+      @db.lpush 'test:lindex', 'bar'
+      @db.lpush 'test:lindex', 'baz'
+    end
+
+    context 'a request for an index within range' do
+      should 'return the item at that index' do
+        assert_equal 'bar', @db.lindex('test:lindex', 1)
+      end
+    end
+
+    context 'a request for an index out of range' do
+      should 'return nothing' do
+        assert_equal nil, @db.lindex('test:lindex', 999)
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/linsert.rb

@@ -0,0 +1,38 @@
+context 'LINSERT' do
+  setup do
+    @db = Moneta.new :Memory
+    @db.lpush 'test:linsert', 'foo'
+  end
+
+  context 'inserting before a pivot value' do
+    test 'when list does not exist' do
+      assert_equal 0, @db.linsert('test:nx', :before, 'foo', 'bar')
+    end
+
+    test 'when pivot is present' do
+      assert_equal 2, @db.linsert('test:linsert', :before, 'foo', 'bar')
+      assert @db.lrange('test:linsert', 0, -1).include? 'bar'
+    end
+
+    test 'when pivot is not present' do
+      assert_equal -1, @db.linsert('test:linsert', :before, 'baz', 'bar')
+    end
+  end
+
+  context 'inserting after a pivot' do
+    test 'when list does not exist' do
+      assert_equal 0, @db.linsert('test:nx', :after, 'foo', 'bar')
+    end
+
+    test 'when pivot is present' do
+      assert_equal 2, @db.linsert('test:linsert', :after, 'foo', 'bar')
+      assert @db.lrange('test:linsert', 0, -1).include? 'bar'
+    end
+
+    test 'when pivot is not present' do
+      assert_equal -1, @db.linsert('test:linsert', :after, 'baz', 'bar')
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/llen.rb

@@ -0,0 +1,18 @@
+context 'LLEN' do
+  setup do
+    @db = Moneta.new :Memory
+    @db.lpush 'test:llen', 'foo'
+  end
+
+  test 'when list does not exist' do
+    assert_equal 0, @db.llen('test:nx')
+  end
+
+  test 'when list exists' do
+    assert_equal 1, @db.llen('test:llen')
+    @db.lpush 'test:llen', 'bar'
+    assert_equal 2, @db.llen('test:llen')
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/lpop.rb

@@ -0,0 +1,25 @@
+context 'LPOP' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'should return nothing' do
+      assert_nil @db.lpop 'test:nx'
+    end
+  end
+
+  given 'a list with two items in it' do
+    setup do
+      @db.lpush 'test:lpop', 'foo'
+      @db.lpush 'test:lpop', 'bar'
+    end
+
+    should 'return items from the head of the list' do
+      values = 3.times.map { @db.lpop 'test:lpop' }
+      assert_equal ['bar', 'foo', nil], values
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/lpush.rb

@@ -0,0 +1,28 @@
+context 'LPUSH' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'have one item when one is pushed into it' do
+      assert_equal 1, @db.lpush('test:nx', 'foo')
+    end
+  end
+
+  given 'a list with 2 items' do
+    setup { 2.times { @db.lpush 'test:lpush', 'foo' } }
+
+    context 'pushing an item into it' do
+      should 'have 3 items' do
+        assert_equal 3, @db.lpush('test:lpush', 'foo')
+      end
+
+      should 'have that item at the head of the list' do
+        @db.lpush 'test:lpush', 'bar'
+        assert_equal 'bar', @db.lpop('test:lpush')
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/lpushx.rb

@@ -0,0 +1,28 @@
+context 'LPUSHX' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'have one item when one is pushed into it' do
+      assert_equal 0, @db.lpushx('test:nx', 'foo')
+    end
+  end
+
+  given 'a list with 2 items' do
+    setup { 2.times { @db.lpush 'test:lpushx', 'foo' } }
+
+    context 'pushing an item into it' do
+      should 'have 3 items' do
+        assert_equal 3, @db.lpushx('test:lpushx', 'foo')
+      end
+
+      should 'have that item at the head of the list' do
+        @db.lpushx 'test:lpushx', 'bar'
+        assert_equal 'bar', @db.lpop('test:lpushx')
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/lrange.rb

@@ -0,0 +1,45 @@
+context 'LRANGE' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'return an empty list' do
+      assert_equal [], @db.lrange('test:nx', 0, -1)
+    end
+  end
+
+  given 'a list with three items in it' do
+    setup do
+      @db.lpush 'test:lrange', 'foo'
+      @db.lpush 'test:lrange', 'bar'
+      @db.lpush 'test:lrange', 'baz'
+    end
+
+    context 'a range within the list' do
+      should 'return the items in that range' do
+        assert_equal %w(baz bar), @db.lrange('test:lrange', 0, 1)
+      end
+    end
+
+    context 'a range containing the whole list' do
+      should 'return the whole list' do
+        assert_equal %w(baz bar foo), @db.lrange('test:lrange', 0, -1)
+      end
+    end
+
+    context 'an out of range stop' do
+      should 'return the whole list' do
+        assert_equal %w(baz bar foo), @db.lrange('test:lrange', 0, 9)
+      end
+    end
+
+    context 'stop before stop' do
+      should 'return an empty list' do
+        assert_equal [], @db.lrange('test:lrange', -1, 1)
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/lset.rb

@@ -0,0 +1,34 @@
+context 'LSET' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'raise an error' do
+      assert_raises(KeyError) { @db.lset('test:nx', 1, 'foo') }
+    end
+  end
+
+  given 'a list with three items' do
+    setup { 3.times { @db.lpush 'test:lset', 'foo' } }
+
+    context 'setting an item within range' do
+      should 'return OK' do
+        assert_equal 'OK', @db.lset('test:lset', 1, 'bar')
+      end
+
+      should 'overwrite the previous item' do
+        @db.lset('test:lset', 1, 'bar')
+        assert_equal 'bar', @db.lindex('test:lset', 1)
+      end
+    end
+
+    context 'setting an item out of range' do
+      should 'raise an error' do
+        assert_raises(IndexError) { @db.lset('test:lset', 999, 'bar') }
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/rpop.rb

@@ -0,0 +1,25 @@
+context 'RPOP' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'should return nothing' do
+      assert_nil @db.rpop 'test:nx'
+    end
+  end
+
+  given 'a list with two items in it' do
+    setup do
+      @db.lpush 'test:rpop', 'foo'
+      @db.lpush 'test:rpop', 'bar'
+    end
+
+    should 'return items from the tail of the list' do
+      values = 3.times.map { @db.rpop 'test:rpop' }
+      assert_equal ['foo', 'bar', nil], values
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/rpoplpush.rb

@@ -0,0 +1,38 @@
+context 'RPOPLPUSH' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'return nothing' do
+      assert_nil @db.rpoplpush 'test:nx', 'test:rpoplpush:b'
+    end
+  end
+
+  given 'a list with two items' do
+    setup do
+      @db.lpush 'test:rpoplpush:a', 'foo'
+      @db.lpush 'test:rpoplpush:a', 'bar'
+    end
+
+    should 'return the item at the tail of the list' do
+      assert_equal 'foo', @db.rpoplpush('test:rpoplpush:a', 'test:rpoplpush:b')
+    end
+
+    context 'an item has been moved' do
+      setup do
+        @db.rpoplpush 'test:rpoplpush:a', 'test:rpoplpush:b'
+      end
+
+      should 'be removed from the source list' do
+        assert !@db.lrange('test:rpoplpush:a', 0, -1).include?('foo')
+      end
+
+      should 'end up in the destination list' do
+        assert @db.lrange('test:rpoplpush:b', 0, -1).include?('foo')
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/rpush.rb

@@ -0,0 +1,28 @@
+context 'RPUSH' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'have one item when one is pushed into it' do
+      assert_equal 1, @db.rpush('test:nx', 'foo')
+    end
+  end
+
+  given 'a list with 2 items' do
+    setup { 2.times { @db.lpush 'test:rpush', 'foo' } }
+
+    context 'pushing an item into it' do
+      should 'have 3 items' do
+        assert_equal 3, @db.rpush('test:rpush', 'foo')
+      end
+
+      should 'have that item at the tail of the list' do
+        @db.rpush 'test:rpush', 'bar'
+        assert_equal 'bar', @db.rpop('test:rpush')
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists/rpushx.rb

@@ -0,0 +1,28 @@
+context 'RPUSHX' do
+  setup do
+    @db = Moneta.new :Memory
+  end
+
+  given 'an empty list' do
+    should 'have one item when one is pushed into it' do
+      assert_equal 0, @db.rpushx('test:nx', 'foo')
+    end
+  end
+
+  given 'a list with 2 items' do
+    setup { 2.times { @db.lpush 'test:rpushx', 'foo' } }
+
+    context 'pushing an item into it' do
+      should 'have 3 items' do
+        assert_equal 3, @db.rpushx('test:rpushx', 'foo')
+      end
+
+      should 'have that item at the tail of the list' do
+        @db.rpushx 'test:rpushx', 'bar'
+        assert_equal 'bar', @db.rpop('test:rpushx')
+      end
+    end
+  end
+
+  teardown { @db.close }
+end

data/tests/redislike/lists.rb

@@ -1,255 +1,12 @@
-context 'List Operations' do
-  def mirror(method, *arguments)
-    original = @original.method(method).call(*arguments)
-    compatible = @compatible.method(method).call(*arguments)
-    [original, compatible]
-  end
-
-  def assert_compatible(method, *arguments)
-    assert_equal(*mirror(method, *arguments))
-  end
-
-  setup do
-    @original = Redis.new
-    # @compatible = Moneta.new :Daybreak, file: '.test.db', expires: true
-    @compatible = Moneta.new :Memory
-
-    @original.del 'test', 'test:a', 'test:b', 'test:nx'
-  end
-
-  teardown do
-    @original.disconnect!
-    @compatible.close
-  end
-
-  context 'lindex' do
-    setup do
-      mirror :lpush, 'test', 'foo'
-      mirror :lpush, 'test', 'bar'
-    end
-
-    test 'when list does not exist' do
-      assert_compatible :lindex, 'test:nx', 1
-    end
-
-    test 'in range' do
-      assert_compatible :lindex, 'test', 1
-    end
-
-    test 'out of range' do
-      assert_compatible :lindex, 'test', 999
-    end
-  end
-
-  context 'linsert' do
-    setup do
-      mirror :lpush, 'test', 'foo'
-    end
-
-    test 'when list does not exist' do
-      assert_compatible :linsert, 'test:nx', :before, 'foo', 'bar'
-      assert_compatible :linsert, 'test:nx', :after, 'foo', 'bar'
-    end
-
-    test 'when list contains pivot value' do
-      assert_compatible :linsert, 'test', :before, 'foo', 'bar'
-      assert_compatible :linsert, 'test', :after, 'foo', 'bar'
-    end
-
-    test 'when list does not contain pivot value' do
-      assert_compatible :linsert, 'test', :before, 'baz', 'bar'
-      assert_compatible :linsert, 'test', :after, 'baz', 'bar'
-    end
-  end
-
-  context 'llen' do
-    test 'when list does not exist' do
-      assert_compatible :llen, 'test:nx'
-    end
-
-    test 'when list exists' do
-      mirror :lpush, 'test', 'foo'
-      assert_compatible :llen, 'test'
-    end
-  end
-
-  context 'lpop' do
-    test 'when list does not exist' do
-      assert_compatible :lpop, 'test:nx'
-    end
-
-    test 'when list exists' do
-      mirror :lpush, 'test', 'foo'
-      assert_compatible :lpop, 'test:nx'
-    end
-  end
-
-  context 'lpush' do
-    test 'when list does not exist' do
-      assert_compatible :lpush, 'test:nx', 'foo'
-    end
-
-    test 'when list has items already' do
-      mirror :lpush, 'test', 'foo'
-      assert_compatible :lpush, 'test', 'foo'
-    end
-  end
-
-  context 'lpushx' do
-    test 'when list does not exist' do
-      assert_compatible :lpushx, 'test:nx', 'foo'
-    end
-
-    test 'when list has items already' do
-      mirror :lpush, 'test', 'foo'
-      assert_compatible :lpushx, 'test', 'foo'
-    end
-  end
-
-  context 'lrange' do
-    test 'when list does not exist' do
-      assert_compatible :lrange, 'test:nx', 0, -1
-    end
-
-    test 'when list exists' do
-      mirror :lpush, 'test', 'foo'
-      assert_compatible :lrange, 'test', 0, -1
-    end
-
-    test 'stop beyond range' do
-      mirror :lpush, 'test', 'foo'
-      assert_compatible :lrange, 'test', 0, 9
-    end
-
-    test 'stop before start' do
-      mirror :lpush, 'test', 'foo'
-      assert_compatible :lrange, 'test', -1, 1
-    end
-  end
-
-  context 'lrem' do
-    setup do
-      mirror :lpush, 'test', 'foo'
-      mirror :lpush, 'test', 'foo'
-      mirror :lpush, 'test', 'foo'
-    end
-
-    test 'when list does not exist' do
-      assert_compatible :lrem, 'test:nx', 0, 'foo'
-    end
-
-    test 'all items (present)' do
-      assert_compatible :lrem, 'test', 0, 'foo'
-    end
-
-    test 'all items (when not present)' do
-      assert_compatible :lrem, 'test', 0, 'bar'
-    end
-
-    test 'one from head (present)' do
-      assert_compatible :lrem, 'test', 1, 'foo'
-    end
-
-    test 'one from head (when not present)' do
-      assert_compatible :lrem, 'test', 1, 'bar'
-    end
-
-    test 'more than exists from head (present)' do
-      assert_compatible :lrem, 'test', 9, 'foo'
-    end
-
-    test 'more than exists from head (when not present)' do
-      assert_compatible :lrem, 'test', 9, 'bar'
-    end
-
-    test 'one from tail (present)' do
-      assert_compatible :lrem, 'test', -1, 'foo'
-    end
-
-    test 'one from tail (when not present)' do
-      assert_compatible :lrem, 'test', -1, 'bar'
-    end
-
-    test 'more than exists from tail (present)' do
-      assert_compatible :lrem, 'test', -9, 'foo'
-    end
-
-    test 'more than exists from tail (when not present)' do
-      assert_compatible :lrem, 'test', -9, 'bar'
-    end
-  end
-
-  context 'lset' do
-    setup do
-      mirror :lpush, 'test', 'foo'
-      mirror :lpush, 'test', 'foo'
-      mirror :lpush, 'test', 'foo'
-    end
-
-    test 'in range' do
-      assert_compatible :lset, 'test', 1, 'bar'
-      assert_equal mirror(:lindex, 'test', 1).uniq, ['bar']
-    end
-  end
-
-  context 'ltrim' do
-    setup do
-      100.times do
-        mirror :lpush, 'test', 'foo'
-      end
-    end
-
-    test 'when list does not exist' do
-      assert_compatible :ltrim, 'test:nx', 0, 10
-    end
-
-    test 'when range is larger than list length' do
-      assert_compatible :ltrim, 'test', 0, 200
-      assert_equal mirror(:lrange, 'test', 0, -1).uniq.flatten.size, 100
-    end
-  end
-
-  context 'rpop' do
-    test 'when list does not exist' do
-      assert_compatible :rpop, 'test:nx'
-    end
-
-    test 'when list exists' do
-      mirror :rpush, 'test', 'foo'
-      assert_compatible :rpop, 'test:nx'
-    end
-  end
-
-  context 'rpoplpush' do
-    test 'when source list does not exist' do
-      assert_compatible :rpoplpush, 'test:nx', 'test:b'
-    end
-
-    test 'when list exists' do
-      3.times { mirror :lpush, 'test:a', 'foo' }
-      assert_compatible :rpoplpush, 'test:a', 'test:b'
-    end
-  end
-
-  context 'rpush' do
-    test 'when list does not exist' do
-      assert_compatible :rpush, 'test:nx', 'foo'
-    end
-
-    test 'when list has items already' do
-      mirror :rpush, 'test', 'foo'
-      assert_compatible :rpush, 'test', 'foo'
-    end
-  end
-
-  context 'rpushx' do
-    test 'when list does not exist' do
-      assert_compatible :rpushx, 'test:nx', 'foo'
-    end
-
-    test 'when list has items already' do
-      mirror :rpush, 'test', 'foo'
-      assert_compatible :rpushx, 'test', 'foo'
-    end
-  end
-end
+require_relative 'lists/lindex'
+require_relative 'lists/linsert'
+require_relative 'lists/llen'
+require_relative 'lists/lpop'
+require_relative 'lists/lpush'
+require_relative 'lists/lpushx'
+require_relative 'lists/lrange'
+require_relative 'lists/lset'
+require_relative 'lists/rpop'
+require_relative 'lists/rpoplpush'
+require_relative 'lists/rpush'
+require_relative 'lists/rpushx'

data/tests/redislike.rb

@@ -3,9 +3,8 @@ require 'bundler/setup'
 require 'simplecov'
 SimpleCov.command_name 'Kintama'
 SimpleCov.start { add_filter '/vendor/' }
-require 'redis'
 require 'kintama'
 require 'moneta'
+require 'redislike'
 
-require_relative '../lib/redislike'
 require_relative 'redislike/lists'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redislike
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Olstrom
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-05 00:00:00.000000000 Z
+date: 2015-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: moneta
@@ -83,8 +83,37 @@ files:
 - lib/redislike/keys.rb
 - lib/redislike/lists.rb
 - redislike.gemspec
+- tests/compatibility/helpers/compatibility.rb
+- tests/compatibility/redislike.rb
+- tests/compatibility/redislike/lists.rb
+- tests/compatibility/redislike/lists/lindex.rb
+- tests/compatibility/redislike/lists/linsert.rb
+- tests/compatibility/redislike/lists/llen.rb
+- tests/compatibility/redislike/lists/lpop.rb
+- tests/compatibility/redislike/lists/lpush.rb
+- tests/compatibility/redislike/lists/lpushx.rb
+- tests/compatibility/redislike/lists/lrange.rb
+- tests/compatibility/redislike/lists/lrem.rb
+- tests/compatibility/redislike/lists/lset.rb
+- tests/compatibility/redislike/lists/ltrim.rb
+- tests/compatibility/redislike/lists/rpop.rb
+- tests/compatibility/redislike/lists/rpoplpush.rb
+- tests/compatibility/redislike/lists/rpush.rb
+- tests/compatibility/redislike/lists/rpushx.rb
 - tests/redislike.rb
 - tests/redislike/lists.rb
+- tests/redislike/lists/lindex.rb
+- tests/redislike/lists/linsert.rb
+- tests/redislike/lists/llen.rb
+- tests/redislike/lists/lpop.rb
+- tests/redislike/lists/lpush.rb
+- tests/redislike/lists/lpushx.rb
+- tests/redislike/lists/lrange.rb
+- tests/redislike/lists/lset.rb
+- tests/redislike/lists/rpop.rb
+- tests/redislike/lists/rpoplpush.rb
+- tests/redislike/lists/rpush.rb
+- tests/redislike/lists/rpushx.rb
 homepage: http://colstrom.github.io/redislike/
 licenses:
 - MIT