rocksdb-ruby 0.2.3 → 1.0.0

data/spec/db_readonly_spec.rb

@@ -4,26 +4,54 @@ require "rocksdb"
 
 describe RocksDB do
   before do
-    @rocksdb = RocksDB::DB.new "/tmp/file2"
-    @rocksdb.put("test:multi_db", "1")
+    @rocksdb = RocksDB.open temp_db_path
+    @rocksdb.put("test", "value")
     @rocksdb.close
-    
-    @rocksdb2 = RocksDB::DB.new("/tmp/file2", {:readonly => true})
   end
 
-  it 'should get data' do
-    expect{@rocksdb2.put("test:multi_db", "10")}.to raise_error(RuntimeError)
-    expect{@rocksdb2.delete("test:multi_db")}.to raise_error(RuntimeError)
-    expect(@rocksdb2.get("test:multi_db")).to eq "1"
-    expect(@rocksdb2.is_readonly?).to eq true
-    
-    batch = RocksDB::Batch.new
-    batch.delete("test:batch1")
-    batch.put("test:batch2", "b")
-    expect{@rocksdb2.write(batch)}.to raise_error(RuntimeError)
+  context "when writable" do
+    before do
+      @rocksdb = RocksDB.open temp_db_path
+    end
+
+    it 'writable? is true' do
+      expect(@rocksdb.writable?).to eq true
+    end
+
+    it 'can write' do
+      expect{@rocksdb.put("newtest", "value")}
+        .not_to raise_error
+    end
+
+    it 'can read' do
+      expect(@rocksdb.get("test")).to eq "value"
+    end
+
+    after do
+      @rocksdb.close
+    end
   end
 
-  after do
-    @rocksdb2.close
+  context "when not writable" do
+    before do
+      @rocksdb = RocksDB.open_readonly temp_db_path
+    end
+
+    it 'writable? is false' do
+      expect(@rocksdb.writable?).to eq false
+    end
+
+    it "can't write" do
+      expect{@rocksdb.put("newtest", "value")}
+        .to raise_error(RocksDB::ReadOnly)
+    end
+
+    it 'can read' do
+      expect(@rocksdb.get("test")).to eq "value"
+    end
+
+    after do
+      @rocksdb.close
+    end
   end
 end

data/spec/db_spec.rb

@@ -4,183 +4,250 @@ require "rocksdb"
 require 'fileutils'
 
 describe RocksDB do
-  before :all do
-    FileUtils.rm(Dir.glob('/tmp/file/*'))
-  end
+  warn "RocksDB library version: #{RocksDB::library_version}" rescue nil
 
   before do
-    @rocksdb = RocksDB::DB.new("/tmp/file")
+    @rocksdb = RocksDB.open(temp_db_path)
   end
 
-  it "should get property" do
-    @rocksdb.put("test:read", "1")
-    expect(@rocksdb.property("rocksdb.estimate-num-keys")).to eq("1")
-  end
+  context "close" do
+    it 'closes database' do
+      @rocksdb.close
+      expect(@rocksdb.open?).to eq false
+    end
 
-  it 'should get data' do
-    @rocksdb.put("test:read", "1")
-    expect(@rocksdb.is_readonly?).to eq false
-    expect(@rocksdb.get("test:read")).to eq "1"
-  end
+    it 'not fails to close database that is already closes' do
+      @rocksdb.close
+      @rocksdb.close
+      expect(@rocksdb.open?).to eq false
+    end
 
-  it 'should put data' do 
-    expect(@rocksdb.put("test:put", "2")).to be true
-    expect(@rocksdb.get("test:put")).to eq "2"
+    it 'raises exception on closed database' do
+      @rocksdb.close
+
+      expect{ @rocksdb.get "test" }
+        .to raise_error(RocksDB::DatabaseClosed)
+      expect{ @rocksdb.put "test", "value" }
+        .to raise_error(RocksDB::DatabaseClosed)
+    end
   end
 
-  it 'should delete data' do 
-    @rocksdb.put("test:delete", "3")
-    expect(@rocksdb.get("test:delete")).to eq "3"
+  context "get_one" do
+    it 'should get data' do
+      @rocksdb.put("test:read", "1")
+      expect(@rocksdb.get_one("test:read")).to eq "1"
+    end
 
-    expect(@rocksdb.delete("test:delete")).to be true
-    expect(@rocksdb.get("test:delete")).to be_nil
+    it 'should get with []' do
+      @rocksdb.delete("test:hash")
+      expect(@rocksdb["test:hash"]).to be_nil
+      @rocksdb.put("test:hash", "42")
+      expect(@rocksdb["test:hash"]).to eq "42"
+    end
+
+    it 'should return nil if not found' do
+      expect(@rocksdb.get_one("must_not_be_found")).to be_nil
+    end
   end
 
-  it 'should get multi data' do
-    @rocksdb.put("test:multi1", "a")
-    @rocksdb.put("test:multi2", "b")
-    @rocksdb.put("test:multi3", "c")
+  context "get_many" do
+    before do
+      @rocksdb.put("test:multi1", "a")
+      @rocksdb.put("test:multi2", "b")
+      @rocksdb.put("test:multi3", "c")
+    end
+
+    it 'should get all values' do
+      expect(@rocksdb.get_many(["test:multi1", "test:multi2", "test:multi3"]))
+            .to eq ["a", "b", "c"]
+    end
+
+    it 'should return nil if key not found' do
+      @rocksdb.delete("test:multi2")
 
-    expect(@rocksdb.multi_get(["test:multi1", "test:multi2", "test:multi3"])).to eq ["a", "b", "c"]
+      expect(@rocksdb.get_many(["test:multi1", "test:multi2", "test:multi3"]))
+            .to eq ["a", nil, "c"]
+    end
   end
 
-  it 'should put data atomic update' do
-    @rocksdb.put("test:batch1", "a")
-    @rocksdb.delete("test:batch2")
+  context "get" do
+    before do
+      @rocksdb.put("test:multi1", "a")
+      @rocksdb.put("test:multi2", "b")
+      @rocksdb.put("test:multi3", "c")
+    end
 
-    expect(@rocksdb.get("test:batch1")).to eq "a"
-    expect(@rocksdb.get("test:batch")).to be_nil
+    it 'should get one, when one argument' do
+      expect(@rocksdb.get("test:multi2"))
+            .to eq "b"
+    end
 
-    batch = RocksDB::Batch.new
-    batch.delete("test:batch1")
-    batch.put("test:batch2", "b")
-    @rocksdb.write(batch)
+    it 'should get many, when two or more arguments' do
+      expect(@rocksdb.get("test:multi1", "test:multi2", "test:multi3"))
+            .to eq ["a", "b", "c"]
+    end
 
-    expect(@rocksdb.get("test:batch1")).to be_nil
-    expect(@rocksdb.get("test:batch2")).to eq "b"
+    it 'should get many, when array given' do
+      expect(@rocksdb.get(["test:multi1", "test:multi2", "test:multi3"]))
+            .to eq ["a", "b", "c"]
+    end
   end
 
-  it 'should use multiple db' do
-    @rocksdb2 = RocksDB::DB.new("/tmp/file2")
-    @rocksdb.put("test:multi_db", "1")
-    @rocksdb2.put("test:multi_db", "2")
-    
-    expect(@rocksdb.get("test:multi_db")).to eq "1"
-    expect(@rocksdb2.get("test:multi_db")).to eq "2"
-    @rocksdb2.close
-  end
+  context "put" do
+    it 'should put data' do
+      expect(@rocksdb.put("test:put", "2")).to be true
+      expect(@rocksdb.get("test:put")).to eq "2"
+    end
 
-  it 'should use japanese charactor' do
-    @rocksdb.put("test:japanese", "あいうえお")
+    it 'should overwrite data with put' do
+      expect(@rocksdb.put("test:put", "2")).to be true
+      expect(@rocksdb.get("test:put")).to eq "2"
 
-    expect(@rocksdb.get("test:japanese")).to eq "あいうえお"
-    expect(@rocksdb.multi_get(["test:japanese"])).to eq ["あいうえお"]
-  end
+      expect(@rocksdb.put("test:put", "3")).to be true
+      expect(@rocksdb.get("test:put")).to eq "3"
+    end
 
-  it 'should use each' do
-    iter = @rocksdb.each 
+    it 'should put any data that can behave like string' do
+      class CastableTest
+        def initialize(value)
+          @value = value
+        end
 
-    array = []
-    @rocksdb.each do |value|
-      expect(value).not_to be_empty
-      array << value
+        def to_str
+          @value.to_s
+        end
+      end
+
+      castable_key = CastableTest.new(42)
+      castable_value = CastableTest.new([1984])
+
+      expect(@rocksdb.put(castable_key, castable_value)).to be true
+      expect(@rocksdb.get("42")).to eq "[1984]"
     end
 
-    rev_array = []
-    @rocksdb.reverse_each do |value|
-      expect(value).not_to be_empty
-      rev_array << value
+    it "should gracefully fail on non-string objects" do
+      expect{ @rocksdb.put(42, true) }.to raise_error(TypeError)
     end
- 
 
-    expect(array).to eq rev_array.reverse
+    it 'should put data atomic update' do
+      @rocksdb.put("test:batch1", "a")
+      @rocksdb.delete("test:batch2")
+
+      expect(@rocksdb.get("test:batch1")).to eq "a"
+      expect(@rocksdb.get("test:batch")).to be_nil
 
-    @rocksdb.each_index do |key|
-      expect(key).not_to be_empty
+      batch = RocksDB::Batch.new
+      batch.delete("test:batch1")
+      batch.put("test:batch2", "b")
+      @rocksdb.write(batch)
+
+      expect(@rocksdb.get("test:batch1")).to be_nil
+      expect(@rocksdb.get("test:batch2")).to eq "b"
     end
 
-    @rocksdb.each_with_index do |key, value|
-      expect(key).not_to be_empty
-      expect(value).not_to be_empty
+    it 'should put and read multibyte data' do
+      @rocksdb.put("test:japanese", "あいうえお")
+      @rocksdb.put("test:russian", "Перепёлка")
+
+      expect(@rocksdb.get("test:japanese")).to eq "あいうえお"
+      expect(@rocksdb.get("test:japanese", "test:russian"))
+        .to eq ["あいうえお", "Перепёлка"]
     end
 
-    iter.close
+    it 'should put with []=' do
+      @rocksdb.delete("test:hash")
+      expect(@rocksdb["test:hash"]).to be_nil
+      @rocksdb["test:hash"] = "a"
+      expect(@rocksdb.get("test:hash")).to eq "a"
+    end
   end
 
-  it 'should exists?' do
-    @rocksdb.put("test:exists?", "a")
-    @rocksdb.delete("test:noexists?")
-    expect(@rocksdb.exists?("test:exists?")).to be true
-    expect(@rocksdb.exists?("test:noexists?")).to be false
+  context "exists?" do
+    it 'returns true when exists' do
+      @rocksdb.put "test:exists?", "a"
+
+      expect(@rocksdb.exists?("test:exists?")).to be true
+      expect(@rocksdb.includes?("test:exists?")).to be true
+    end
+
+    it 'returns false when no exists' do
+      expect(@rocksdb.exists?("test:noexists?")).to be false
+      expect(@rocksdb.includes?("test:noexists?")).to be false
+    end
 
-    expect(@rocksdb.includes?("test:exists?")).to be true
-    expect(@rocksdb.includes?("test:noexists?")).to be false
+    it 'returns false when key deleted' do
+      @rocksdb.put "test:deleted_key", "deleted_value"
+      @rocksdb.delete "test:deleted_key"
 
+      expect(@rocksdb.exists?("test:deleted_key")).to be false
+      expect(@rocksdb.includes?("test:deleted_key")).to be false
+    end
   end
 
-  it 'hash' do
-    @rocksdb.delete("test:hash")
-    expect(@rocksdb["test:hash"]).to be_nil
-    @rocksdb["test:hash"] = "a"
-    expect(@rocksdb["test:hash"]).to eq "a"
+  context "delete" do
+    it 'should delete data' do
+      @rocksdb.put("test:delete", "3")
+      expect(@rocksdb.get("test:delete")).to eq "3"
 
+      expect(@rocksdb.delete("test:delete")).to be true
+      expect(@rocksdb.get("test:delete")).to be_nil
+    end
+
+    it 'should return true even if key does not exists' do
+      @rocksdb.delete("must_not_be_found_to_delete")
+      expect(@rocksdb.delete("must_not_be_found_to_delete")).to be true
+    end
+  end
+
+  it "should get property" do
+    @rocksdb.put("test:read", "1")
+    expect(@rocksdb.property("rocksdb.estimate-num-keys")).to eq("1")
+  end
+
+  it "should get library_version" do
+    expect(RocksDB.library_version).to match(/\d+\.\d+\.\d+/)
+  end
+
+  it 'should use multiple db' do
+    @rocksdb2 = RocksDB::DB.new("/tmp/file2")
+    @rocksdb.put("test:multi_db", "1")
+    @rocksdb2.put("test:multi_db", "2")
+
+    expect(@rocksdb.get("test:multi_db")).to eq "1"
+    expect(@rocksdb2.get("test:multi_db")).to eq "2"
+    @rocksdb2.close
   end
 
   it 'race condition test' do
     key = "test"
     value = "1"
 
-    expect{RocksDB::DB.new("/tmp/file")}.to raise_error(RocksDB::DBError)
+    expect{RocksDB.open(temp_db_path)}.to raise_error(RocksDB::Error)
 
     expect(@rocksdb.put("test:put", "1")).to be true
 
-    @rocksdb2 = RocksDB::DB.new("/tmp/file", {:readonly => true})
-    expect(@rocksdb2.is_readonly?).to eq true
+    @rocksdb2 = RocksDB.open_readonly(temp_db_path)
+    expect(@rocksdb2.writable?).to eq false
     expect(@rocksdb2.get("test:put")).to eq "1"
 
     @rocksdb.close
 
-    expect(@rocksdb.is_open?).to eq false
+    expect(@rocksdb.open?).to eq false
 
-    @rocksdb = RocksDB::DB.new("/tmp/file")
-    expect(@rocksdb.is_readonly?).to eq false
-    expect(@rocksdb.is_open?).to eq true
+    @rocksdb = RocksDB.open(temp_db_path)
+    expect(@rocksdb.writable?).to eq true
+    expect(@rocksdb.open?).to eq true
     expect(@rocksdb.put("test:put", "2")).to be true
-    
-    @rocksdb3 = RocksDB::DB.new("/tmp/file", {:readonly => true})
-    expect(@rocksdb3.is_readonly?).to eq true
-    expect(@rocksdb3.is_open?).to eq true
+
+    @rocksdb3 = RocksDB.open_readonly(temp_db_path)
+    expect(@rocksdb3.writable?).to eq false
+    expect(@rocksdb3.open?).to eq true
     expect(@rocksdb3.get("test:put")).to eq "2"
 
     @rocksdb2.close
     @rocksdb3.close
-    
   end
-  
-  it 'singleton' do
-    @rocksdb2 = RocksDB::DB.get_instance("/tmp/file")
-    expect(@rocksdb2.is_readonly?).to eq false
-    expect(@rocksdb2.is_open?).to eq true
-
-    @rocksdb3 = RocksDB::DB.get_instance("/tmp/file")
-    expect(@rocksdb3.is_readonly?).to eq false
-    expect(@rocksdb).to eq (@rocksdb3)
-    expect(@rocksdb2).to eq (@rocksdb3)
-    
-    @rocksdb4 = RocksDB::DB.get_instance("/tmp/file", {:readonly => true})
-    expect(@rocksdb2).not_to eq (@rocksdb4)
-    expect(@rocksdb4.is_readonly?).to eq true
-    expect(@rocksdb4.is_open?).to eq true
-    
-    @rocksdb2.close
-    expect{@rocksdb2.get("test:put")}.to raise_error(RuntimeError)
-    expect(@rocksdb2.is_open?).to eq false
-    expect{@rocksdb3.get("test:put")}.to raise_error(RuntimeError)
-    expect(@rocksdb3.is_open?).to eq false
 
-    @rocksdb4.close
-  end
-  
   context 'compact' do
     it 'works with no parameters' do
       expect(@rocksdb.compact).to eq(true)
@@ -203,4 +270,3 @@ describe RocksDB do
     @rocksdb.close
   end
 end
-

data/spec/iterator_spec.rb

@@ -2,38 +2,325 @@
 require 'spec_helper'
 require "RocksDB"
 
-describe RocksDB do
+describe RocksDB::Iterator do
   before do
-    @rocksdb = RocksDB::DB.new "/tmp/file"
+    @rocksdb = RocksDB.open temp_db_path
+
+    @rocksdb.put("test1:0001", "a")
+    @rocksdb.put("test1:0002", "b")
+    @rocksdb.put("test1:0003", "c")
+    @rocksdb.put("test1:0004", "d")
+    @rocksdb.put("test1:0005", "e")
+
+    @iterator = @rocksdb.to_iterator
+  end
+
+  context "valid" do
+    it 'should be valid at start' do
+      @iterator.seek_to_first
+
+      expect(@iterator).to be_valid
+    end
+
+    it 'should not be valid at end' do
+      @iterator.seek_to_last
+      @iterator.next
+
+      expect(@iterator).to_not be_valid
+    end
+
+    it 'should not be valid when closed' do
+      @iterator.close
+
+      expect(@iterator).to_not be_valid
+    end
+
+    it 'should not be valid when database closed' do
+      @rocksdb.close
+
+      expect(@iterator).to_not be_valid
+    end
+  end
+
+  context 'close' do
+    it 'closes iterator' do
+      @iterator.close
+      expect(@iterator).to_not be_valid
+    end
+
+    it 'raises exception on closed iterator' do
+      @iterator.close
+      expect{@iterator.seek_to_first}.to raise_error(RocksDB::IteratorClosed)
+    end
+
+    it 'raises exception on closed database' do
+      @rocksdb.close
+      expect{@iterator.seek_to_first}.to raise_error(RocksDB::DatabaseClosed)
+    end
+  end
+
+  context "enumerable" do
+    context "each" do
+      it 'iterates over all values' do
+        values = []
+
+        @rocksdb.each do |value|
+          values << value
+        end
+
+        expect(values).to eq ["a", "b", "c", "d", "e"]
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.each)
+          .to be_a(Enumerable)
+      end
+    end
+
+    context "reverse_each" do
+      it 'iterates over all values in reverse order' do
+        values = []
+
+        @rocksdb.reverse_each do |value|
+          values << value
+        end
+
+        expect(values).to eq ["e", "d", "c", "b", "a"]
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.reverse_each)
+          .to be_a(Enumerable)
+      end
+    end
+
+    context "each_key" do
+      it 'iterates over all keys' do
+        keys = []
+
+        @rocksdb.each_key do |key|
+          keys << key
+        end
+
+        expect(keys).to eq [
+          "test1:0001",
+          "test1:0002",
+          "test1:0003",
+          "test1:0004",
+          "test1:0005"
+        ]
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.each_key)
+          .to be_a(Enumerable)
+      end
+    end
+
+    context "reverse_each_key" do
+      it 'iterates over all keys in reverse order' do
+        keys = []
+
+        @rocksdb.reverse_each_key do |key|
+          keys << key
+        end
+
+        expect(keys).to eq [
+          "test1:0005",
+          "test1:0004",
+          "test1:0003",
+          "test1:0002",
+          "test1:0001"
+        ]
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.reverse_each_key)
+          .to be_a(Enumerable)
+      end
+    end
+
+    context "each_pair" do
+      it 'iterates over all values and keys' do
+        pairs = {}
+
+        @rocksdb.each_pair do |key, value|
+          pairs[key] = value
+        end
+
+        expect(pairs).to eq ({
+          "test1:0001"=>"a",
+          "test1:0002"=>"b",
+          "test1:0003"=>"c",
+          "test1:0004"=>"d",
+          "test1:0005"=>"e"
+        })
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.each_pair)
+          .to be_a(Enumerable)
+      end
+    end
+
+    context "reverse_each_pair" do
+      it 'iterates over all values and keys in reverse order' do
+        pairs = {}
+
+        @rocksdb.reverse_each_pair do |key, value|
+          pairs[key] = value
+        end
+
+        expect(pairs).to eq ({
+          "test1:0005"=>"e",
+          "test1:0004"=>"d",
+          "test1:0003"=>"c",
+          "test1:0002"=>"b",
+          "test1:0001"=>"a"
+        })
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.reverse_each_pair)
+          .to be_a(Enumerable)
+      end
+    end
+
+    context "each_prefix" do
+      it 'iterates over keys and values of given prefix' do
+        @rocksdb.put("test0:0000", "z")
+        @rocksdb.put("test2:0000", "u")
+        result = {}
+
+        @rocksdb.each_prefix("test1") do |key, value|
+          result[key] = value
+        end
+
+        expect(result).to eq({
+          "test1:0001" => "a",
+          "test1:0002" => "b",
+          "test1:0003" => "c",
+          "test1:0004" => "d",
+          "test1:0005" => "e",
+        })
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.each_prefix("test1"))
+          .to be_a(Enumerable)
+      end
+    end
+
+    context "each_range" do
+      it 'iterates over keys and values of given range' do
+        @rocksdb.put("test0:0001", "-1")
+        @rocksdb.put("test2:multi3", "f")
+
+        result = {}
+
+        @rocksdb.each_range("test1:0002", "test1:0004") do |key, value|
+          result[key] = value
+        end
+
+        expect(result).to eq({
+          "test1:0002" => "b",
+          "test1:0003" => "c",
+          "test1:0004" => "d"
+        })
+      end
+
+      it 'returns enumerable' do
+        expect(@rocksdb.each_range("test1:0002", "test1:0004"))
+          .to be_a(Enumerable)
+      end
+    end
+  end
+
+  it 'should seek to first' do
+    @iterator.seek_to_first
+
+    expect(@iterator.key).to eq "test1:0001"
+    expect(@iterator.value).to eq "a"
+  end
+
+  it 'should seek to last' do
+    @iterator.seek_to_last
+
+    expect(@iterator.key).to eq "test1:0005"
+    expect(@iterator.value).to eq "e"
+  end
+
+  context "seek" do
+    it 'should seek to record when record exists' do
+      @iterator.seek "test1:0003"
+
+      expect(@iterator.key).to eq "test1:0003"
+      expect(@iterator.value).to eq "c"
+    end
+
+    it 'should seek to first' do
+      @iterator.seek "alpha"
+
+      expect(@iterator).to be_valid
+      expect(@iterator.key).to eq "test1:0001"
+      expect(@iterator.value).to eq "a"
+    end
   end
 
-  it 'should use iterator' do
-    iterator = @rocksdb.new_iterator
+  context "seek_for_previous",
+    skip: !RocksDB::Iterator.instance_methods.include?(:seek_for_previous) do
 
-    iterator.seek_to_first
-    
-    expect(iterator.valid).to be true
-    while(iterator.valid)
-      expect(iterator.value).not_to be_empty
-      expect(iterator.key).not_to be_empty
-      iterator.next
+    it 'should seek to record when target record exists' do
+      @iterator.seek_for_previous "test1:0004"
+
+      expect(@iterator.key).to eq "test1:0004"
+      expect(@iterator.value).to eq "d"
+    end
+
+    it 'should seek to closest record when target is not exists' do
+      @iterator.seek_for_previous "test2"
+
+      expect(@iterator.key).to eq "test1:0005"
+      expect(@iterator.value).to eq "e"
     end
-    iterator.close
   end
 
-  it 'should seek iterator' do
-    iterator = @rocksdb.new_iterator
+  it 'should go forward' do
+    @iterator.seek_to_first
+    @iterator.next
+
+    expect(@iterator.key).to eq "test1:0002"
+    expect(@iterator.value).to eq "b"
+  end
 
-    iterator.seek("test:put")
-    
-    iterator.valid
-    expect(iterator.value).to eq "2"
-    expect(iterator.key).to eq "test:put"
+  it 'should go back' do
+    @iterator.seek_to_last
+    @iterator.previous
+
+    expect(@iterator.key).to eq "test1:0004"
+    expect(@iterator.value).to eq "d"
+  end
+
+  it 'should iterate all the way to the end' do
+    result = {}
+    @iterator.seek_to_first
+
+    while @iterator.valid?
+      result[@iterator.key] = @iterator.value
+      @iterator.next
+    end
 
-    iterator.close
+    expect(result).to eq ({
+      "test1:0001" => "a",
+      "test1:0002" => "b",
+      "test1:0003" => "c",
+      "test1:0004" => "d",
+      "test1:0005" => "e"
+    })
   end
 
   after do
+    @iterator.close
     @rocksdb.close
   end
 end