fakeredis 0.7.0 → 0.9.0

data/spec/bitop_command_spec.rb

@@ -11,7 +11,7 @@ module FakeRedis
     end
 
     it 'raises an argument error when passed unsupported operation' do
-      lambda { @client.bitop("meh", "dest1", "key1") }.should raise_error(Redis::CommandError)
+      expect { @client.bitop("meh", "dest1", "key1") }.to raise_error(Redis::CommandError)
     end
 
     describe "or" do
@@ -28,22 +28,22 @@ module FakeRedis
         @client.setbit("key2", 2, 0)
         @client.setbit("key2", 3, 0)
 
-        @client.bitop("or", "dest1", "key1", "key2").should be == 1
-        @client.bitcount("dest1").should be == 3
-        @client.getbit("dest1", 0).should be == 1
-        @client.getbit("dest1", 1).should be == 1
-        @client.getbit("dest1", 2).should be == 1
-        @client.getbit("dest1", 3).should be == 0
+        expect(@client.bitop("or", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(3)
+        expect(@client.getbit("dest1", 0)).to eq(1)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
       end
 
       it "should apply bitwise or operation with empty values" do
         @client.setbit("key1", 1, 1)
 
-        @client.bitop("or", "dest1", "key1", "nothing_here1", "nothing_here2").should be == 1
-        @client.bitcount("dest1").should be == 1
-        @client.getbit("dest1", 0).should be == 0
-        @client.getbit("dest1", 1).should be == 1
-        @client.getbit("dest1", 2).should be == 0
+        expect(@client.bitop("or", "dest1", "key1", "nothing_here1", "nothing_here2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
       end
 
       it "should apply bitwise or operation with multiple keys" do
@@ -56,16 +56,16 @@ module FakeRedis
         @client.setbit("key3", 13, 1)
         @client.setbit("key3", 15, 1)
 
-        @client.bitop("or", "dest1", "key1", "key2", "key3").should be == 2
-        @client.bitcount("dest1").should be == 6
-        @client.getbit("dest1", 1).should be == 1
-        @client.getbit("dest1", 3).should be == 1
-        @client.getbit("dest1", 5).should be == 1
-        @client.getbit("dest1", 10).should be == 1
-        @client.getbit("dest1", 13).should be == 1
-        @client.getbit("dest1", 15).should be == 1
-        @client.getbit("dest1", 2).should be == 0
-        @client.getbit("dest1", 12).should be == 0
+        expect(@client.bitop("or", "dest1", "key1", "key2", "key3")).to eq(2)
+        expect(@client.bitcount("dest1")).to eq(6)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(1)
+        expect(@client.getbit("dest1", 10)).to eq(1)
+        expect(@client.getbit("dest1", 13)).to eq(1)
+        expect(@client.getbit("dest1", 15)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
+        expect(@client.getbit("dest1", 12)).to eq(0)
       end
     end
 
@@ -81,21 +81,21 @@ module FakeRedis
         @client.setbit("key2", 1, 1)
         @client.setbit("key2", 2, 1)
 
-        @client.bitop("and", "dest1", "key1", "key2").should be == 1
-        @client.bitcount("dest1").should be == 1
-        @client.getbit("dest1", 0).should be == 0
-        @client.getbit("dest1", 1).should be == 1
-        @client.getbit("dest1", 2).should be == 0
+        expect(@client.bitop("and", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
       end
 
       it "should apply bitwise and operation with empty values" do
         @client.setbit("key1", 1, 1)
 
-        @client.bitop("and", "dest1", "key1", "nothing_here").should be == 1
-        @client.bitcount("dest1").should be == 1
-        @client.getbit("dest1", 0).should be == 0
-        @client.getbit("dest1", 1).should be == 1
-        @client.getbit("dest1", 2).should be == 0
+        expect(@client.bitop("and", "dest1", "key1", "nothing_here")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
       end
 
       it "should apply bitwise and operation with multiple keys" do
@@ -114,14 +114,14 @@ module FakeRedis
         @client.setbit("key3", 5, 1)
         @client.setbit("key3", 6, 1)
 
-        @client.bitop("and", "dest1", "key1", "key2", "key3").should be == 1
-        @client.bitcount("dest1").should be == 2
-        @client.getbit("dest1", 1).should be == 0
-        @client.getbit("dest1", 2).should be == 1
-        @client.getbit("dest1", 3).should be == 0
-        @client.getbit("dest1", 4).should be == 1
-        @client.getbit("dest1", 5).should be == 0
-        @client.getbit("dest1", 6).should be == 0
+        expect(@client.bitop("and", "dest1", "key1", "key2", "key3")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(2)
+        expect(@client.getbit("dest1", 1)).to eq(0)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+        expect(@client.getbit("dest1", 4)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(0)
+        expect(@client.getbit("dest1", 6)).to eq(0)
       end
     end
 
@@ -139,22 +139,22 @@ module FakeRedis
         @client.setbit("key2", 2, 1)
         @client.setbit("key2", 3, 0)
 
-        @client.bitop("xor", "dest1", "key1", "key2").should be == 1
-        @client.bitcount("dest1").should be == 2
-        @client.getbit("dest1", 0).should be == 1
-        @client.getbit("dest1", 1).should be == 0
-        @client.getbit("dest1", 2).should be == 1
-        @client.getbit("dest1", 3).should be == 0
+        expect(@client.bitop("xor", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(2)
+        expect(@client.getbit("dest1", 0)).to eq(1)
+        expect(@client.getbit("dest1", 1)).to eq(0)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
       end
 
       it "should apply bitwise xor operation with empty values" do
         @client.setbit("key1", 1, 1)
 
-        @client.bitop("xor", "dest1", "key1", "nothing_here1", "nothing_here2").should be == 1
-        @client.bitcount("dest1").should be == 1
-        @client.getbit("dest1", 0).should be == 0
-        @client.getbit("dest1", 1).should be == 1
-        @client.getbit("dest1", 2).should be == 0
+        expect(@client.bitop("xor", "dest1", "key1", "nothing_here1", "nothing_here2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
       end
 
       it "should apply bitwise xor operation with multiple keys" do
@@ -168,24 +168,24 @@ module FakeRedis
         @client.setbit("key2", 4, 1)
         @client.setbit("key2", 6, 1)
 
-        @client.bitop("xor", "dest1", "key1", "key2").should be == 1
-        @client.bitcount("dest1").should be == 4
-        @client.getbit("dest1", 1).should be == 1
-        @client.getbit("dest1", 2).should be == 1
-        @client.getbit("dest1", 3).should be == 0
-        @client.getbit("dest1", 4).should be == 1
-        @client.getbit("dest1", 5).should be == 1
-        @client.getbit("dest1", 6).should be == 0
+        expect(@client.bitop("xor", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(4)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+        expect(@client.getbit("dest1", 4)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(1)
+        expect(@client.getbit("dest1", 6)).to eq(0)
       end
     end
 
     describe "not" do
       it 'raises an argument error when not passed any keys' do
-        lambda { @client.bitop("not", "destkey") }.should raise_error(Redis::CommandError)
+        expect { @client.bitop("not", "destkey") }.to raise_error(Redis::CommandError)
       end
 
       it 'raises an argument error when not passed too many keys' do
-        lambda { @client.bitop("not", "destkey", "key1", "key2") }.should raise_error(Redis::CommandError)
+        expect { @client.bitop("not", "destkey", "key1", "key2") }.to raise_error(Redis::CommandError)
       end
 
       it "should apply bitwise negation operation" do
@@ -193,16 +193,16 @@ module FakeRedis
         @client.setbit("key1", 3, 1)
         @client.setbit("key1", 5, 1)
 
-        @client.bitop("not", "dest1", "key1").should be == 1
-        @client.bitcount("dest1").should be == 5
-        @client.getbit("dest1", 0).should be == 1
-        @client.getbit("dest1", 1).should be == 0
-        @client.getbit("dest1", 2).should be == 1
-        @client.getbit("dest1", 3).should be == 0
-        @client.getbit("dest1", 4).should be == 1
-        @client.getbit("dest1", 5).should be == 0
-        @client.getbit("dest1", 6).should be == 1
-        @client.getbit("dest1", 7).should be == 1
+        expect(@client.bitop("not", "dest1", "key1")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(5)
+        expect(@client.getbit("dest1", 0)).to eq(1)
+        expect(@client.getbit("dest1", 1)).to eq(0)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+        expect(@client.getbit("dest1", 4)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(0)
+        expect(@client.getbit("dest1", 6)).to eq(1)
+        expect(@client.getbit("dest1", 7)).to eq(1)
       end
     end
   end

data/spec/fakeredis_spec.rb

@@ -18,4 +18,56 @@ describe FakeRedis do
       expect(described_class.enabled?).to be_falsy
     end
   end
+
+  describe '.disabling' do
+    context 'FakeRedis is enabled' do
+      before { described_class.enable }
+
+      it 'in memory connection' do
+        described_class.disabling do
+          expect(described_class.enabled?).to be_falsy
+        end
+
+        expect(described_class.enabled?).to be_truthy
+      end
+    end
+
+    context 'FakeRedis is disabled' do
+      before { described_class.disable }
+
+      it 'in memory connection' do
+        described_class.disabling do
+          expect(described_class.enabled?).to be_falsy
+        end
+
+        expect(described_class.enabled?).to be_falsy
+      end
+    end
+  end
+
+  describe '.enabling' do
+    context 'FakeRedis is enabled' do
+      before { described_class.enable }
+
+      it 'in memory connection' do
+        described_class.enabling do
+          expect(described_class.enabled?).to be_truthy
+        end
+
+        expect(described_class.enabled?).to be_truthy
+      end
+    end
+
+    context 'FakeRedis is disabled' do
+      before { described_class.disable }
+
+      it 'in memory connection' do
+        described_class.enabling do
+          expect(described_class.enabled?).to be_truthy
+        end
+
+        expect(described_class.enabled?).to be_falsy
+      end
+    end
+  end
 end

data/spec/geo_set_spec.rb

@@ -0,0 +1,164 @@
+require "spec_helper"
+
+module FakeRedis
+  describe "GeoMethods" do
+    before do
+      @client = Redis.new
+    end
+
+    describe "#geoadd" do
+      it "should raise when not enough arguments" do
+        expect { @client.geoadd("Sicily", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'geoadd' command")
+        expect { @client.geoadd("Sicily", [13.361389, 38.115556]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'geoadd' command")
+      end
+
+      it "should add items to the set" do
+        added_items_count = add_sicily
+        expect(added_items_count).to eq(2)
+      end
+
+      it "should update existing items" do
+        @client.geoadd("Sicily", 13.361389, 38.115556, "Palermo")
+        added_items_count = @client.geoadd("Sicily", 13, 39, "Palermo", 15.087269, 37.502669, "Catania")
+        expect(added_items_count).to eq(1)
+      end
+    end
+
+    describe "#geodist" do
+      before do
+        add_sicily
+      end
+
+      it "should return destination between two elements" do
+        distance_in_meters = @client.geodist("Sicily", "Palermo", "Catania")
+        expect(distance_in_meters).to eq("166412.6051")
+
+        distance_in_feet = @client.geodist("Sicily", "Palermo", "Catania", "ft")
+        expect(distance_in_feet).to eq("545973.1137")
+      end
+
+      it "should raise for unknown unit name" do
+        expect {
+          @client.geodist("Sicily", "Palermo", "Catania", "unknown")
+        }.to raise_error(Redis::CommandError, "ERR unsupported unit provided. please use m, km, ft, mi")
+      end
+
+      it "should return nil when element is missing" do
+        expect(@client.geodist("Sicily", "Palermo", "Rome")).to be_nil
+      end
+    end
+
+    describe "#geohash" do
+      before do
+        add_sicily
+      end
+
+      it "should raise when not enough arguments" do
+        expect { @client.geohash("Sicily", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'geohash' command")
+      end
+
+      it "should return geohashes" do
+        geohash = @client.geohash("Sicily", "Palermo")
+        expect(geohash).to eq(["sqc8b49rny"])
+
+        geohashes = @client.geohash("Sicily", ["Palermo", "Catania"])
+        expect(geohashes).to eq(["sqc8b49rny", "sqdtr74hyu"])
+      end
+
+      it "should return nils for nonexistent elements" do
+        geohashes = @client.geohash("Sicily", ["Palermo", "Rome"])
+        expect(geohashes).to eq(["sqc8b49rny", nil])
+      end
+    end
+
+    describe "#geopos" do
+      it "should return positions (longitude, latitude) for elements" do
+        add_sicily
+        position = @client.geopos("Sicily", "Catania")
+        expect(position).to eq([["15.087269", "37.502669"]])
+
+        positions = @client.geopos("Sicily", ["Palermo", "Catania"])
+        expect(positions).to eq([["13.361389", "38.115556"], ["15.087269", "37.502669"]])
+      end
+
+      it "should return nil for nonexistent elements" do
+        expect(@client.geopos("nonexistent", "nonexistent2")).to be_nil
+        add_sicily
+
+        position = @client.geopos("Sicily", "Rome")
+        expect(position).to eq([nil])
+
+        positions = @client.geopos("Sicily", ["Rome", "Catania"])
+        expect(positions).to eq([nil, ["15.087269", "37.502669"]])
+      end
+    end
+
+    describe "#georadius" do
+      before do
+        add_sicily
+      end
+
+      it "should return members within specified radius" do
+        nearest_cities = @client.georadius("Sicily", 15, 37, 100, "km")
+        expect(nearest_cities).to eq(["Catania"])
+      end
+
+      it "should sort returned members" do
+        nearest_cities = @client.georadius("Sicily", 15, 37, 200, "km", sort: "asc")
+        expect(nearest_cities).to eq(["Catania", "Palermo"])
+
+        farthest_cities = @client.georadius("Sicily", 15, 37, 200, "km", sort: "desc")
+        expect(farthest_cities).to eq(["Palermo", "Catania"])
+      end
+
+      it "should return specified count of members" do
+        city = @client.georadius("Sicily", 15, 37, 200, "km", sort: "asc", count: 1)
+        expect(city).to eq(["Catania"])
+      end
+
+      it "should include additional info for members" do
+        cities = @client.georadius("Sicily", 15, 37, 200, "km", "WITHDIST")
+        expect(cities).to eq([["Palermo", "190.6009"], ["Catania", "56.4883"]])
+
+        cities = @client.georadius("Sicily", 15, 37, 200, "km", "WITHCOORD")
+        expect(cities).to eq [["Palermo", ["13.361389", "38.115556"]], ["Catania", ["15.087269", "37.502669"]]]
+
+        cities = @client.georadius("Sicily", 15, 37, 200, "km", "WITHDIST", "WITHCOORD")
+        expect(cities).to eq(
+          [["Palermo", "190.6009", ["13.361389", "38.115556"]],
+           ["Catania", "56.4883", ["15.087269", "37.502669"]]]
+        )
+      end
+    end
+
+    describe "#georadiusbymember" do
+      before do
+        add_sicily
+      end
+
+      it "should sort returned members" do
+        nearest_cities = @client.georadiusbymember("Sicily", "Catania", 200, "km", sort: "asc")
+        expect(nearest_cities).to eq(["Catania", "Palermo"])
+
+        farthest_cities = @client.georadiusbymember("Sicily", "Catania", 200, "km", sort: "desc")
+        expect(farthest_cities).to eq(["Palermo", "Catania"])
+      end
+
+      it "should limit number of returned members" do
+        city = @client.georadiusbymember("Sicily", "Catania", 100, "km", count: 1)
+        expect(city).to eq(["Catania"])
+      end
+
+      it "should include extra info if requested" do
+        city = @client.georadiusbymember("Sicily", "Catania", 200, "km", sort: :desc, options: :WITHDIST, count: 1)
+        expect(city).to eq([["Palermo", "166.4126"]])
+      end
+    end
+
+    private
+
+    def add_sicily
+      @client.geoadd("Sicily", 13.361389, 38.115556, "Palermo", 15.087269, 37.502669, "Catania")
+    end
+  end
+end

data/spec/hashes_spec.rb

@@ -32,7 +32,7 @@ module FakeRedis
       expect(@client.hdel("key1", "k1")).to be(1)
       expect(@client.hdel("key1", "k2")).to be(1)
 
-      expect(@client.exists("key1")).to eq(false)
+      expect(@client.exists("key1")).to eq(0)
     end
 
     it "should convert key to a string for hset" do
@@ -108,6 +108,13 @@ module FakeRedis
       expect(@client.hlen("key1")).to eq(2)
     end
 
+    it "should get the string length of the value associated with field in a hash" do
+      @client.hset("key1", "i1", "val1")
+      expect(@client.hstrlen("key1", "i1")).to eq(4)
+      expect(@client.hstrlen("key1", "nonexistent")).to eq(0)
+      expect(@client.hstrlen("nonexistent", "field")).to eq(0)
+    end
+
     it "should get the values of all the given hash fields" do
       @client.hset("key1", "i1", "val1")
       @client.hset("key1", "i2", "val2")
@@ -122,15 +129,19 @@ module FakeRedis
       expect { @client.hmget("key1") }.to raise_error(Redis::CommandError)
     end
 
+    it "should throw an argument error when the list of keys you ask for is empty" do
+      expect { @client.hmget("key1", []) }.to raise_error(Redis::CommandError)
+    end
+
     it "should reject an empty list of values" do
       expect { @client.hmset("key") }.to raise_error(Redis::CommandError)
-      expect(@client.exists("key")).to be false
+      expect(@client.exists?("key")).to be false
     end
 
     it "rejects an insert with a key but no value" do
       expect { @client.hmset("key", 'foo') }.to raise_error(Redis::CommandError)
       expect { @client.hmset("key", 'foo', 3, 'bar') }.to raise_error(Redis::CommandError)
-      expect(@client.exists("key")).to be false
+      expect(@client.exists?("key")).to be false
     end
 
     it "should reject the wrong number of arguments" do
@@ -156,12 +167,42 @@ module FakeRedis
     end
 
     it "should set the string value of a hash field" do
-      expect(@client.hset("key1", "k1", "val1")).to eq(true)
-      expect(@client.hset("key1", "k1", "val1")).to eq(false)
+      expect(@client.hset("key1", "k1", "val1")).to eq(1)
+      expect(@client.hset("key1", "k1", "val1")).to eq(0)
 
       expect(@client.hget("key1", "k1")).to eq("val1")
     end
 
+    it "should accept a list of key-value pair" do
+      @client.hset("key1", "k1", "val1", "k2", "val2")
+
+      expect(@client.hget("key1", "k1")).to eq("val1")
+      expect(@client.hget("key1", "k2")).to eq("val2")
+    end
+
+    it "should accept a hash of attributes to insert" do
+      @client.hset("key1", {"k1" => "val1", "k2" => "val2"})
+
+      expect(@client.hget("key1", "k1")).to eq("val1")
+      expect(@client.hget("key1", "k2")).to eq("val2")
+    end
+
+    it "should return correct value when inserting a list of key-value pair" do
+      @client.hset("key1", "k1", "val1", "k2", "val2")
+
+      expect(@client.hset("key1", "k1", "val1", "k2", "val2")).to eq(0)
+      expect(@client.hset("key1", "k2", "val2", "k3", "val3")).to eq(1)
+      expect(@client.hset("key1", "k4", "val4", "k5", "val5")).to eq(2)
+    end
+
+    it "should return correct value when inserting a hash of attributes" do
+      @client.hset("key1", { "k1" => "val1", "k2" => "val2" })
+
+      expect(@client.hset("key1", { "k1" => "val1", "k2" => "val2" })).to eq(0)
+      expect(@client.hset("key1", { "k2" => "val2", "k3" => "val3" })).to eq(1)
+      expect(@client.hset("key1", { "k4" => "val4", "k5" => "val5" })).to eq(2)
+    end
+
     it "should set the value of a hash field, only if the field does not exist" do
       @client.hset("key1", "k1", "val1")
       expect(@client.hsetnx("key1", "k1", "value")).to eq(false)

data/spec/hyper_log_logs_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+module FakeRedis
+  describe "HyperLogLogsMethods" do
+    let(:redis) { Redis.new }
+
+    it "should add item to hyperloglog" do
+      expect(redis.pfadd("hll", "val")).to eq(true)
+      expect(redis.pfcount("hll")).to eq(1)
+    end
+
+    it "should not add duplicated item to hyperloglog" do
+      redis.pfadd("hll", "val")
+      expect(redis.pfadd("hll", "val")).to eq(false)
+      expect(redis.pfcount("hll")).to eq(1)
+    end
+
+    it "should not add multiple items to hyperloglog" do
+      expect(redis.pfadd("hll", ["val1", "val2"])).to eq(true)
+      expect(redis.pfcount("hll")).to eq(2)
+    end
+
+    it "should return zero as cardinality for nonexistent key" do
+      expect(redis.pfcount("nonexistent")).to eq(0)
+    end
+
+    it "should return cardinality of union of hyperloglogs" do
+      redis.pfadd("hll1", ["val1", "val2"])
+      redis.pfadd("hll2", ["val2", "val3"])
+      expect(redis.pfcount("hll1", "hll2")).to eq(3)
+    end
+
+    it "should error if an empty list of keys is given" do
+      expect { redis.pfcount([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'pfcount' command")
+    end
+
+    it "should merge hyperloglogs" do
+      redis.pfadd("hll1", ["val1", "val2"])
+      redis.pfadd("hll2", ["val2", "val3"])
+      expect(redis.pfmerge("hll3", "hll1", "hll2")).to eq(true)
+      expect(redis.pfcount("hll3")).to eq(3)
+    end
+
+    it "should merge nonexistent hyperloglogs with others" do
+      redis.pfadd("hll1", "val")
+      expect(redis.pfmerge("hll3", "hll1", "nonexistent")).to eq(true)
+      expect(redis.pfcount("hll3")).to eq(1)
+    end
+  end
+end