redi2casa 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8864b86636142369894dab69c3571dfc3f6db506
-  data.tar.gz: 5ca0cde38d25a3bf655f14fc5d006ee9ff6dfaf1
+  metadata.gz: 02835343d420037160bf3308faa4fb3bcd6b5b2b
+  data.tar.gz: b3a5cbe64a8c618a6a73c63e29ceff6556f1f946
 SHA512:
-  metadata.gz: 98ea0ef507af4a811aa637e6a22d19a4c5bb100ffe297af047607ef3c82f9fcf012ad435370fa5eead72b38ccbe2d7d465b445432f4b2e2b8afbb1b63dd55a46
-  data.tar.gz: ae9644a1799261a15229ec5fd9c7851c6eeb779e9f7caacb77d4a88005d7d34f849d10a966e92e24e6a0ed6e93147c9cc82892b4b9b9859384ce7f54749a7fab
+  metadata.gz: 07fb0ee657a3775de3c25ab8c923b9d16fe5ea80e0686e45b1c960cfeead6e0bbdbf41c69b7b685059e1f962d6bfdb9321cbfe632bea9ccaa117113692763a79
+  data.tar.gz: f18b64faf51f072b439bf330796054f653a1da30b6491b74ffa36b47cb4199845bf110da3c165988b1a0cd275226bab39af03dbd6e0dcef343a3def01fa24661

data/Gemfile.lock

@@ -1,20 +1,29 @@
 PATH
   remote: .
   specs:
-    redi2casa (0.0.4)
+    redi2casa (0.1.1)
       cql-rb
 
 GEM
   remote: https://rubygems.org/
   specs:
-    cql-rb (1.1.1)
+    cql-rb (1.1.2)
+    diff-lcs (1.2.5)
     rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler
-  cql-rb
   rake
   redi2casa!
+  rspec

data/lib/redi2casa/del.rb

@@ -4,15 +4,15 @@ class Redi2casa
     if type == "counter"
       raise RuntimeError.new("deleting counters is not supported")
     elsif type == 'keyvalue'
-      @db_conn.execute("delete from keyvalue where key = '#{key}'")
+      execute "delete from keyvalue where key = '#{key}'"
     elsif type == 'hash'
-      @db_conn.execute("delete from hashes where key = '#{key}'")
+      execute "delete from hashes where key = '#{key}'"
     elsif type == 'list'
-      @db_conn.execute("delete from lists where key = '#{key}'")
+      execute "delete from lists where namespace = '#{key}'"
     elsif type == 'set'
-      @db_conn.execute("delete from sets where key = '#{key}'")
+      execute "delete from sets where key = '#{key}'"
     elsif type == 'sorted_set'
-      @db_conn.execute("delete from sorted_sets where key = '#{key}'")
+      execute "delete from sorted_sets where key = '#{key}'"
     end
   end
 end

data/lib/redi2casa/get.rb

@@ -1,11 +1,11 @@
 class Redi2casa
   def get key, type = 'keyvalue'
     if type == 'keyvalue'
-      resp = @db_conn.execute("select * from keyvalue where key = '#{key}'")
+      resp = execute "select * from keyvalue where key = '#{key}'"
       parse_response(resp, "value")
     elsif type == 'counter'
       # @ is a special column in counter used by incrby
-      resp = @db_conn.execute("select value from counters where KEY='#{key}' and column1 = '@'")
+      resp = execute "select value from counters where KEY='#{key}' and column1 = '@'"
       parse_response(resp, "value").to_i
     end
   end

data/lib/redi2casa/hdel.rb

@@ -1,9 +1,9 @@
 class Redi2casa
   def hdel key, column1, type = "counter"
     if type == "counter"
-      @db_conn.execute("delete from counters where key = '#{key}' and column1 = '#{column1}'")
+      raise RuntimeError.new("deleting counters is not supported")
     elsif type == "hash"
-      @db_conn.execute("delete from hashes where key = '#{key}' and column1 = '#{column1}'")
+      execute "delete from hashes where key = '#{key}' and column1 = '#{column1}'"
     end
   end
 end

data/lib/redi2casa/hget.rb

@@ -1,10 +1,10 @@
 class Redi2casa
   def hget key, column1, type = "counter"
     if type.to_s == "hash"
-      resp = @db_conn.execute("select value from hashes where key = '#{key}' and column1 = '#{column1}'")
+      resp = execute "select value from hashes where key = '#{key}' and column1 = '#{column1}'"
       parse_response(resp, "value")
     elsif type.to_s == "counter"
-      resp = @db_conn.execute("select value from counters where KEY='#{key}' and column1 = '#{column1}'")
+      resp = execute "select value from counters where KEY='#{key}' and column1 = '#{column1}'"
       parse_response(resp, "value").to_i
     end
   end

data/lib/redi2casa/hgetall.rb

@@ -1,10 +1,10 @@
 class Redi2casa
   def hgetall key, type = "counter"
     if type.to_s == "counter"
-      response = @db_conn.execute("select * from counters where KEY='#{key}'")
+      response = execute "select * from counters where KEY='#{key}'"
       response.inject({}) {|hsh, entry| hsh[entry["column1"]] = entry["value"]; hsh}
     elsif type.to_s == "hash"
-      response = @db_conn.execute("select * from hashes where key = '#{key}'")
+      response = execute "select * from hashes where key = '#{key}'"
       response.inject({}) {|hsh, entry| hsh[entry["column1"]] = entry["value"]; hsh}
     end
   end

data/lib/redi2casa/hincrby.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def hincrby key, column1, value = 1
-    @db_conn.execute("update counters set value = value + #{value} where key='#{key}' and column1 = '#{column1}'")
+    execute "update counters set value = value + #{value} where key='#{key}' and column1 = '#{column1}'"
   end
 end

data/lib/redi2casa/hkeys.rb

@@ -1,10 +1,10 @@
 class Redi2casa
   def hkeys key, type = "counter"
     if type.to_s == "counter"
-      response = @db_conn.execute("select column1 from counters where key = '#{key}'")
+      response = execute "select column1 from counters where key = '#{key}'"
       response.collect {|entry| entry["column1"]}
     elsif type.to_s == "hash"
-      response = @db_conn.execute("select column1 from hashes where key = '#{key}'")
+      response = execute "select column1 from hashes where key = '#{key}'"
       response.collect {|entry| entry["column1"]}
     end
   end

data/lib/redi2casa/hlen.rb

@@ -2,10 +2,10 @@ class Redi2casa
   # Supports only hashes now
   def hlen key, type = "hash"
     if type == "hash"
-      response = @db_conn.execute("select count(*) from hashes where key = '#{key}'")
+      response = execute "select count(*) from hashes where key = '#{key}'"
       parse_response(response, "count").to_i
     elsif type == "counter"
-      response = @db_conn.execute("select count(*) from counters where key = '#{key}'")
+      response = execute "select count(*) from counters where key = '#{key}'"
       parse_response(response, "count").to_i
     end
   end

data/lib/redi2casa/hmget.rb

@@ -8,7 +8,7 @@ class Redi2casa
       raise RuntimeError.new("invalid table")
     end
 
-    resp = @db_conn.execute("select column1, value from #{table} where key = '#{key}' and column1 IN ('#{column1s.join("','")}')")
+    resp = execute "select column1, value from #{table} where key = '#{key}' and column1 IN ('#{column1s.join("','")}')"
     hash = {}
     resp.each do |r|
       hash[r["column1"]] = r["value"]

data/lib/redi2casa/hset.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def hset key, column1, value
-    @db_conn.execute("UPDATE hashes SET value = '#{value}' WHERE column1 = '#{column1}' and key = '#{key}'")
+    execute "UPDATE hashes SET value = '#{value}' WHERE column1 = '#{column1}' and key = '#{key}'"
   end
 end

data/lib/redi2casa/keys.rb

@@ -0,0 +1,5 @@
+class Redi2casa
+  def keys pattern, type
+
+  end
+end

data/lib/redi2casa/lpop.rb

@@ -1,9 +1,9 @@
 class Redi2casa
   #has a read modify write problem
   def lpop namespace
-    resp = @db_conn.execute("select values from lists where namespace='#{namespace}'")
+    resp = execute "select values from lists where namespace='#{namespace}'"
     values = []
-    resp.fetch {|entry| values = entry.to_hash["values"]}
+    resp.each {|entry| values = entry.to_hash["values"]}
     resp = values.shift
     lrepush(namespace, values)
     resp

data/lib/redi2casa/lpush.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def lpush namespace, data
-    @db_conn.execute("UPDATE lists SET values = ['#{data}'] + values WHERE namespace = '#{namespace}'")
+    execute "UPDATE lists SET values = ['#{data}'] + values WHERE namespace = '#{namespace}'"
   end
 end

data/lib/redi2casa/lrange.rb

@@ -1,6 +1,9 @@
 class Redi2casa
   def lrange namespace, first, last
-    resp = @db_conn.execute("select values from lists where namespace='#{namespace}'")
-    resp.fetch {|entry| return entry.to_hash["values"][first..last]}
+    resp = execute "select values from lists where namespace='#{namespace}'"
+    resp.each {|entry| 
+      values = entry.to_hash["values"] || []
+      return values[first..last]
+    }
   end
 end

data/lib/redi2casa/ltrim.rb

@@ -1,8 +1,8 @@
 class Redi2casa
   def ltrim namespace, first, last
-    resp = @db_conn.execute("select values from lists where namespace='#{namespace}'")
+    resp = execute "select values from lists where namespace='#{namespace}'"
     values = {}
-    resp.fetch {|entry| values = entry.to_hash["values"]}
+    resp.each {|entry| values = entry.to_hash["values"]}
     values_count = values.count
     #if first is greater than list length, redis returns empty list
     #if negative value of last is equal or greater than list length a similar behaviour is shown
@@ -17,10 +17,11 @@ class Redi2casa
   end
 
   def lflush namespace
-    @db_conn.execute("UPDATE lists SET values = []  WHERE namespace = '#{namespace}'")
+    execute "UPDATE lists SET values = []  WHERE namespace = '#{namespace}'"
   end
 
+  private
   def lrepush namespace, list
-    @db_conn.execute("UPDATE lists SET values = [?]  WHERE namespace = '#{namespace}'", list)
+    execute "UPDATE lists SET values = ['#{list.join("','")}']  WHERE namespace = '#{namespace}'"
   end
 end

data/lib/redi2casa/rpop.rb

@@ -1,6 +1,6 @@
 class Redi2casa
   def rpop namespace
-    resp = @db_conn.execute("select values from lists where namespace='#{namespace}'")
+    resp = execute "select values from lists where namespace='#{namespace}'"
     values = []
     resp.fetch {|entry| values = entry.to_hash["values"]}
     resp = values.pop

data/lib/redi2casa/rpush.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def rpush namespace, data
-    @db_conn.execute("UPDATE lists SET values = values + ['#{data}'] WHERE namespace = '#{namespace}'")
+    execute "UPDATE lists SET values = values + ['#{data}'] WHERE namespace = '#{namespace}'"
   end
 end

data/lib/redi2casa/sadd.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def sadd key, *members
-    @db_conn.execute("update sets set members = members + {'#{members.join("','")}'} where key = '#{key}'")
+    execute "update sets set members = members + {'#{members.join("','")}'} where key = '#{key}'"
   end
 end

data/lib/redi2casa/sadd_with_expire.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def sadd_with_expire( key, ttl, *members)
-    @db_conn.execute("update sets using ttl #{ttl} set members = members + {'#{members.join("','")}'} where key = '#{key}'")
+    execute "update sets using ttl #{ttl} set members = members + {'#{members.join("','")}'} where key = '#{key}'"
   end
 end

data/lib/redi2casa/set.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def set key, value
-    @db_conn.execute("UPDATE keyvalue set value = '#{value}' where key = '#{key}'")
+    execute "UPDATE keyvalue set value = '#{value}' where key = '#{key}'"
   end
 end

data/lib/redi2casa/setex.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def setex key, ttl, value
-    @db_conn.execute("UPDATE keyvalue using TTL #{ttl} set value = '#{value}' where key = '#{key}'")
+    execute "UPDATE keyvalue using TTL #{ttl} set value = '#{value}' where key = '#{key}'"
   end
 end

data/lib/redi2casa/smembers.rb

@@ -1,6 +1,6 @@
 class Redi2casa
   def smembers key
-    resp = @db_conn.execute("select * from sets where key = '#{key}'")
+    resp = execute "select * from sets where key = '#{key}'"
     if resp.first
       resp.first["members"].to_a
     else

data/lib/redi2casa/srem.rb

@@ -1,5 +1,5 @@
 class Redi2casa
   def srem key, member
-    @db_conn.execute("update sets set members = members - {'#{member}'} where key = '#{key}'")
+    execute "update sets set members = members - {'#{member}'} where key = '#{key}'"
   end
 end

data/lib/redi2casa/version.rb

@@ -1,3 +1,3 @@
 class Redi2casa
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/redi2casa/zadd.rb

@@ -1,6 +1,6 @@
 class Redi2casa
   # Random text is an extra column added to make sure we have multiple entries with same key, score and value
   def zadd key, score, value
-    @db_conn.execute("insert into sorted_sets (key, score,value, random_text) values ('#{key}',#{score}, '#{value}', '#{Time.now.to_i}')")
+    execute "insert into sorted_sets (key, score,value, random_text) values ('#{key}',#{score}, '#{value}', '#{Time.now.to_i}')"
   end
 end

data/lib/redi2casa/zrangebyscore.rb

@@ -1,9 +1,10 @@
 class Redi2casa
+  # Ranges are exclusive
   def zrangebyscore key, lower_limit, higher_limit = -1
     if higher_limit == -1
-      resp = @db_conn.execute("select value from sorted_sets where key = '#{key}' and score > #{lower_limit}")
+      resp = execute "select value from sorted_sets where key = '#{key}' and score > #{lower_limit}"
     else
-      resp = @db_conn.execute("select value from sorted_sets where key = '#{key}' and score > #{lower_limit} and score < #{higher_limit}")
+      resp = execute "select value from sorted_sets where key = '#{key}' and score > #{lower_limit} and score < #{higher_limit}"
     end
     resp.collect do |entry|
       entry['value']

data/lib/redi2casa/zrem.rb

@@ -1,8 +1,8 @@
 class Redi2casa
   def zrem key, member
-    resp = @db_conn.execute("select * from sorted_sets where key = '#{key}'")
+    resp = execute "select * from sorted_sets where key = '#{key}'"
     resp.each do |entry|
-      @db_conn.execute("delete from sorted_sets where key = '#{key}' and score = #{entry['score']} and value = '#{entry['value']}'") if entry['value'] == member.to_s
+      execute "delete from sorted_sets where key = '#{key}' and score = #{entry['score']} and value = '#{entry['value']}'" if entry['value'] == member.to_s
     end
   end
 end

data/lib/redi2casa/zscore.rb

@@ -1,6 +1,6 @@
 class Redi2casa
   def zscore key, value
-    resp = @db_conn.execute("select * from sorted_sets where key = '#{key}'")
+    resp = execute "select * from sorted_sets where key = '#{key}'"
     resp.each do |entry|
       return entry['score'] if entry['value'] == value.to_s
     end

data/lib/redi2casa.rb

@@ -5,11 +5,31 @@ Gem.find_files("redi2casa/*.rb").each { |path| require path }
 
 class Redi2casa
   def initialize(hosts, keyspace)
-    @db_conn =  Cql::Client.connect(:hosts => hosts)
-    @db_conn.use(keyspace)
+    @hosts = hosts
+    @keyspace = keyspace
+    connect
   end
 
+  def connect
+    @db_conn =  Cql::Client.connect(:hosts => @hosts)
+    @db_conn.use(@keyspace)
+  end
+
+  alias :reconnect :connect
+
   def parse_response(resp, key)
     resp.map {|entry| entry[key].to_s }.first
   end
+
+  def execute query
+    @failed ||= 0
+    @db_conn.execute query
+  rescue Cql::NotConnectedError
+    reconnect
+    @failed += 1
+    retry if @failed < 3
+    raise
+  ensure
+    @failed = 0
+  end
 end

data/redi2casa.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "cql-rb"
 
-  spec.add_development_dependency "cql-rb"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
 end

data/spec/bitwise_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Redi2casa do
+  context "bitwise" do
+    KEY = "test_bitwise"
+    before(:each) do
+      $r ||= Redi2casa.new(["localhost"], "redi2casa")
+      $r.del(KEY, "sorted_set")
+    end
+
+    def r
+      $r
+    end
+    it "set two bits to 1 and getbits" do
+      r.set_bit KEY, 5, 1
+      r.set_bit KEY, 10, 1
+      r.get_bit(KEY, 5).should == 1
+      r.get_bit(KEY, 10).should == 1
+      r.get_bit(KEY, 8).should == 0
+    end
+    
+    it "set two bits to 1 and set it back to 0 and then getbits" do
+      r.set_bit KEY, 5, 1
+      r.set_bit KEY, 5, 0
+      r.get_bit(KEY, 5).should == 0
+    end
+    
+    it "clear bits should clear all the set bits" do
+      r.set_bit KEY, 5, 1
+      r.set_bit KEY, 10, 1
+      r.clear_bits KEY
+      r.get_bit(KEY, 5).should == 0
+      r.get_bit(KEY, 10).should == 0
+    end
+    
+    it "unset bits are by default 0" do
+      r.get_bit(KEY, 25).should == 0
+    end
+  end
+end

data/spec/counters_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Redi2casa do
+  context "counters" do
+    KEY = "test_counters"
+    before(:each) do
+      $r ||= Redi2casa.new(["localhost"], "redi2casa")
+    end
+    
+    def r
+      $r
+    end
+    
+    it "hincryby" do
+      a = r.hget(KEY, "c1", "counter")
+      r.hincrby(KEY, "c1", 1)
+      r.hget(KEY, "c1", "counter").should == a + 1
+      r.hincrby(KEY, "c1", 5)
+      r.hget(KEY, "c1", "counter").should == a + 6
+    end
+    
+    it "hkeys" do
+      r.hincrby(KEY, "c1")
+      r.hincrby(KEY, "c2")
+      r.hkeys(KEY, "counter").include?("c1").should == true
+      r.hkeys(KEY, "counter").include?("c2").should == true
+    end
+    
+    it "hlen" do
+      r.hincrby(KEY, "c1")
+      r.hincrby(KEY, "c2")
+      r.hlen(KEY, "counter").should >= 2
+    end
+    
+    it "hget" do
+      a = r.hget(KEY, "c1", "counter")
+      r.hincrby(KEY, "c1", 5)
+      r.hget(KEY, "c1", "counter").should == a + 5
+    end
+    
+    it "hmget" do
+      a = r.hget(KEY, "c1", "counter")
+      b = r.hget(KEY, "c2", "counter")
+      r.hmget(KEY, "counter", "c1", "c2").should == [ a, b]
+    end
+    
+    it "hgetall" do
+      a = r.hget(KEY, "c1")
+      b = r.hget(KEY, "c2")
+      resp = r.hgetall(KEY, "counter")
+      resp["c1"].should == a
+      resp["c2"].should == b
+    end
+  end
+end

data/spec/hashs_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Redi2casa do
+  context "hashes" do
+    KEY = "test_hash"
+    before(:each) do
+      $r ||= Redi2casa.new(["localhost"], "redi2casa")
+      $r.del KEY, "hash"
+    end
+    def r
+      $r
+    end
+
+    context "hdel & hget" do
+      it "should delete a entry already present" do
+        r.hset KEY, "a", "5"
+        r.hget(KEY, "a", "hash").should == "5"
+        r.hdel(KEY, "a", "hash")
+        r.hget(KEY, "a", "hash").should == nil
+      end
+
+      it "should ignore if the entry is not already present" do
+        r.hset(KEY, "b", "25")
+        r.hdel(KEY, "a", "hash")
+        r.hget(KEY, "b", "hash").should == "25"
+        r.hget(KEY, "a", "hash").should == nil
+      end
+    end
+
+    context "hget" do
+      it "should get item which is already set" do
+        r.hset KEY, "a", "5"
+        r.hget(KEY, "a", "hash").should == "5"
+      end
+
+      it "should return nil if the element dows not exist" do
+        r.hget(KEY, "a", "hash").should == nil
+      end
+    end
+
+    context "hgetall" do
+      it "get all elements as a hash" do
+        r.hset KEY, "a", "5"
+        r.hset KEY, "b", "10"
+        r.hset KEY, "c", "15"
+        r.hgetall(KEY, "hash").should == {"a" => "5", "b" => "10", "c" => "15"}
+      end
+
+      it "should return empty hash if it does not exist" do
+        r.hgetall(KEY, "hash").should == {}
+      end
+    end
+
+    context "hlen" do
+      it "returns number of elements in the hash" do
+        r.hset KEY, "a", "5"
+        r.hset KEY, "b", "10"
+        r.hset KEY, "c", "15"
+        r.hset KEY, "d", "15"
+        r.hlen(KEY).should == 4
+      end
+
+      it "returns 0 if hash does not exists" do
+        r.hlen(KEY).should == 0
+      end
+    end
+
+    context "hmget" do
+      it "returns multiple elements in a hash" do
+        r.hset KEY, "a", "5"
+        r.hset KEY, "b", "10"
+        r.hset KEY, "c", "15"
+        r.hset KEY, "d", "15"
+        r.hmget(KEY, "hash", "a", "b", "f").should == ["5", "10", nil]
+      end
+    end
+
+    context "hset" do
+      it "sets a value to hash" do
+        r.hset KEY, "z", "2000"
+        r.hget(KEY, "z", "hash").should == "2000"
+      end
+    end
+  end
+end

data/spec/keyvalue_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Redi2casa do
+  context "keyvalue" do
+    KEY = "test_keyvalye"
+    before(:each) do
+      $r ||= Redi2casa.new(["localhost"], "redi2casa")
+      $r.del(KEY, "keyvalue")
+    end
+
+    def r
+      $r
+    end
+    
+    it "get and set -- before setting element should be nil then the set value after set" do
+      r.get(KEY).should == nil
+      r.set(KEY, "z")
+      r.get(KEY).should == "z"
+    end
+    
+    it "get and setex the set key should remain for ttl only" do
+      r.setex(KEY, 5, "z")
+      r.get(KEY).should == "z"
+      sleep 7
+      r.get(KEY).should == nil
+    end
+  end
+end

data/spec/lists_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Redi2casa do
+  context "lists" do
+    KEY = "test_list"
+    before(:each) do
+      $r ||= Redi2casa.new(["localhost"], "redi2casa")
+      $r.del(KEY, "list")
+    end
+
+    def r
+      $r
+    end
+
+    context "lpop" do
+      it "pop the first element out" do
+        r.lpush KEY, "a"
+        r.lpush KEY, "b"
+        r.lpush KEY, "f"
+        r.lpush KEY, "g"
+        r.lpop(KEY).should == "g"
+      end
+      
+      it "return nil if the list is empty" do
+        r.lpop(KEY).should == nil
+      end
+    end
+    
+    context "lpush & lrange" do
+      it "pushes to the start of the list" do
+        r.lpush KEY, "a"
+        r.lpush KEY, "b"
+        r.lpush KEY, "f"
+        r.lpush KEY, "g"
+        r.lrange(KEY, 0, -1).should == ["g", "f", "b", "a"]
+        r.lrange(KEY, 2, 3).should == ["b", "a"]
+      end
+    end
+    
+    context "lrange" do
+      it "return empty list in case the list is empty" do
+        r.lrange(KEY, 0, -1).should == []
+      end
+    end
+    
+    context "ltrim" do
+      it "trims the list to specified ranges" do
+        r.lpush KEY, "a"
+        r.lpush KEY, "b"
+        r.lpush KEY, "f"
+        r.lpush KEY, "g"
+        r.ltrim(KEY, 0, 2)
+        r.lrange(KEY, 0, -1) == ["g", "f", "b"]
+        r.ltrim(KEY, 1, 2) 
+        r.lrange(KEY, 0, -1) == ["f", "b"]
+      end
+    end
+    
+    context "lflush" do
+      it "empties the list" do
+        r.lpush KEY, "a"
+        r.lpush KEY, "b"
+        r.lpush KEY, "f"
+        r.lpush KEY, "g"
+        r.lflush KEY
+        r.lrange(KEY, 0, -1) == []
+      end
+    end
+  end
+end

data/spec/redis2casa_spec.rb

@@ -0,0 +1,9 @@
+require 'redi2casa'
+
+require './spec/sets_spec.rb'
+require './spec/hashs_spec.rb'
+require './spec/lists_spec.rb'
+require './spec/sorted-sets_spec.rb'
+require './spec/keyvalue_spec.rb'
+require './spec/bitwise_spec.rb'
+require './spec/counters_spec.rb'

data/spec/sets_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Redi2casa do
+  context "sets" do
+    KEY = "test_set"
+    before(:each) do
+      $r ||= Redi2casa.new(["localhost"], "redi2casa")
+      $r.del(KEY, "set")
+    end
+
+    def r
+      $r
+    end
+
+    context "sadd" do
+      it "should add first element" do
+        r.sadd KEY, "a"
+        r.smembers(KEY).include?("a").should == true
+      end
+
+      it "should add second element" do
+        r.sadd KEY, "a"
+        r.sadd KEY, "b"
+        r.smembers(KEY).include?("a").should == true
+        r.smembers(KEY).include?("b").should == true
+      end
+
+      it "already added element should not be added again" do
+        r.sadd KEY, "a"
+        r.sadd KEY, "a"
+        r.smembers(KEY).size.should == 1
+      end
+    end
+
+    context "sadd_with_expire" do
+      it "add a new element it should disapper after ttl" do
+        r.sadd_with_expire KEY, 5, "a"
+        r.smembers(KEY).size.should == 1
+        sleep 7
+        r.smembers(KEY).size.should == 0
+      end
+    end
+
+    context "scard" do
+      it "default size should be 0" do
+        r.scard(KEY).should == 0
+      end
+
+      it "add 5 unique elements and size should be five" do
+        r.sadd KEY, "a", "b", "c", "d", "e"
+        r.scard(KEY).should == 5
+      end
+    end
+
+    context "sismember" do
+      it "add a element and it should be there in the set" do
+        r.sadd KEY, "a", "b", "c", "d", "e"
+        r.sismember(KEY, "a").should == true
+        r.sismember(KEY, "d").should == true
+      end
+
+      it "random element should not be present in the set" do
+        r.sadd KEY, "a"
+        r.sismember(KEY, "b").should == false
+      end
+    end
+
+    context "smembers" do
+      it "add 5 members and this should be listed in smembers" do
+        r.sadd KEY, "a", "b", "c", "d", "e"
+        r.smembers(KEY).should == ["a", "b", "c", "d", "e"]
+      end
+
+      it "default should be empty set" do
+        r.smembers(KEY).should == []
+      end
+    end
+
+    context "spop" do
+      it "removes random element from set" do
+        r.sadd KEY, "a", "b", "c", "d", "e"
+        k = r.spop(KEY)
+        r.smembers(KEY).should == ["a", "b", "c", "d", "e"] - [ k ]
+      end
+
+      it "return nil incase set is empty" do
+        r.spop(KEY).should == nil
+      end
+    end
+
+    context "srem" do
+      it "deletes the element if present" do
+        r.sadd KEY, "a", "b", "c", "d", "e"
+        r.srem KEY, "b"
+        r.smembers(KEY).should == ["a", "c", "d", "e"]
+      end
+
+      it "ignores if element is not present" do
+        r.sadd KEY, "a", "b", "c", "d", "e"
+        r.srem KEY, "f"
+        r.smembers(KEY).should == ["a", "b", "c", "d", "e"]
+      end
+    end
+  end
+end

data/spec/sorted-sets_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Redi2casa do
+  context "sorted-sets" do
+    KEY = "test_sorted-set"
+    before(:each) do
+      $r ||= Redi2casa.new(["localhost"], "redi2casa")
+      $r.del(KEY, "sorted_set")
+    end
+
+    def r
+      $r
+    end
+    
+    context "zadd" do
+      it "add one element with a score" do
+        r.zadd KEY, 5, "a"
+        r.zrangebyscore(KEY, 0).should == ["a"]
+      end
+      
+      it "add already existing element with the same score" do
+        r.zadd KEY, 5, "a"
+        r.zadd KEY, 5, "a"
+        r.zrangebyscore(KEY, 0).should == ["a"]
+      end
+      
+      it "add two elements with same score" do
+        r.zadd KEY, 5, "a"
+        r.zadd KEY, 5, "b"
+        r.zrangebyscore(KEY, 0).should == ["a", "b"]
+      end
+      
+      it "add two elements with different score" do
+        r.zadd KEY, 5, "a"
+        r.zadd KEY, 6, "b"
+        r.zrangebyscore(KEY, 0).should == ["a", "b"]
+      end
+    end
+    
+    context "zrangebyscore" do
+      it "list elements from 0 to -1 should give all elements with positive score" do
+        r.zadd KEY, 5, "a"
+        r.zadd KEY, 6, "b"
+        r.zadd KEY, 7, "c"
+        r.zadd KEY, 8, "d"
+        r.zrangebyscore(KEY, 0).should == ["a", "b", "c", "d"]
+      end
+      
+      it "list elements with subset with specified range of scores" do
+        # Ranges are exclusive
+        r.zadd KEY, 5, "a"
+        r.zadd KEY, 6, "b"
+        r.zadd KEY, 7, "c"
+        r.zadd KEY, 8, "d"
+        r.zrangebyscore(KEY, 5, 8).should == ["b", "c"]
+      end
+    end
+    
+    context "zrem" do
+      it "removed certain element from the zset and removing non existant member should be ignored" do
+        r.zadd KEY, 5, "a"
+        r.zadd KEY, 6, "b"
+        r.zadd KEY, 7, "c"
+        r.zadd KEY, 8, "d"
+        r.zrem KEY, "c"
+        r.zrem KEY, "z"
+        r.zrangebyscore(KEY, 0).should == ["a", "b", "d"]
+      end
+    end
+    
+    context "zscore" do
+      it "returns score of certain element in the zset and for non existant member score should be nil" do
+        r.zadd KEY, 5, "a"
+        r.zadd KEY, 6, "b"
+        r.zadd KEY, 7, "c"
+        r.zadd KEY, 8, "d"
+        r.zscore(KEY, "c").should == 7
+        r.zscore(KEY, "z").should == nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require './lib/redi2casa.rb'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redi2casa
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - vireshas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-17 00:00:00.000000000 Z
+date: 2013-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cql-rb
@@ -26,7 +26,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: cql-rb
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -40,7 +40,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -54,7 +54,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -84,6 +84,7 @@ files:
 - Rakefile
 - cassandra_cli_cmds
 - cqlsh_cmds
+- lib/.DS_Store
 - lib/redi2casa.rb
 - lib/redi2casa/clear_bits.rb
 - lib/redi2casa/del.rb
@@ -98,6 +99,7 @@ files:
 - lib/redi2casa/hmget.rb
 - lib/redi2casa/hset.rb
 - lib/redi2casa/incrby.rb
+- lib/redi2casa/keys.rb
 - lib/redi2casa/lpop.rb
 - lib/redi2casa/lpush.rb
 - lib/redi2casa/lrange.rb
@@ -120,6 +122,15 @@ files:
 - lib/redi2casa/zrem.rb
 - lib/redi2casa/zscore.rb
 - redi2casa.gemspec
+- spec/bitwise_spec.rb
+- spec/counters_spec.rb
+- spec/hashs_spec.rb
+- spec/keyvalue_spec.rb
+- spec/lists_spec.rb
+- spec/redis2casa_spec.rb
+- spec/sets_spec.rb
+- spec/sorted-sets_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/vireshas/redi2casa
 licenses:
 - MIT
@@ -145,4 +156,13 @@ signing_key:
 specification_version: 4
 summary: Moving redis calls to equivalent cassandra calls can be a pain unless you
   use this gem
-test_files: []
+test_files:
+- spec/bitwise_spec.rb
+- spec/counters_spec.rb
+- spec/hashs_spec.rb
+- spec/keyvalue_spec.rb
+- spec/lists_spec.rb
+- spec/redis2casa_spec.rb
+- spec/sets_spec.rb
+- spec/sorted-sets_spec.rb
+- spec/spec_helper.rb