juno 0.2.3 → 0.2.4

data/spec/generate.rb

@@ -1,6 +1,7 @@
 ADAPTER_SPECS = [:null_stringkey_stringvalue, :store_stringkey_stringvalue, :returndifferent_stringkey_stringvalue]
 SIMPLE_SPECS = [:null, :store, :returndifferent, :marshallable_key]
 EXPIRES_SPECS = SIMPLE_SPECS + [:expires_stringkey_stringvalue]
+header = "# Generated by #{__FILE__} at #{Time.now.to_s}, #{`git describe --all --long`}"
 
 TESTS = {
   'simple_memory' => {
@@ -120,17 +121,17 @@ TESTS = {
   'simple_memcached' => {
     :store => :Memcached,
     :specs => EXPIRES_SPECS,
-    :options => ':server => "localhost:22122", :namespace => "simple_memcached"'
+    :options => ':namespace => "simple_memcached"'
   },
   'simple_memcached_dalli' => {
     :store => :MemcachedDalli,
     :specs => EXPIRES_SPECS,
-    :options => ':server => "localhost:22122", :namespace => "simple_memcached_dalli"'
+    :options => ':namespace => "simple_memcached_dalli"'
   },
   'simple_memcached_native' => {
     :store => :MemcachedNative,
     :specs => EXPIRES_SPECS,
-    :options => ':server => "localhost:22122", :namespace => "simple_memcached_native"'
+    :options => ':namespace => "simple_memcached_native"'
   },
   'simple_riak' => {
     :store => :Riak,
@@ -229,16 +230,14 @@ TESTS = {
     :specs => EXPIRES_SPECS
   },
   'expires_memory' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Expires
   adapter :Memory
 end},
     :specs => [:null, :store, :expires]
   },
   'expires_file' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Expires
   use :Transformer, :key => [:marshal, :escape], :value => :marshal
   adapter :File, :dir => File.join(make_tempdir, "expires-file")
@@ -246,20 +245,19 @@ end},
     :specs => [:null, :store, :expires, :returndifferent, :marshallable_key],
     :tests => %{
 it 'should delete expired value in underlying file storage' do
-  @store.store('foo', 'bar', :expires => 2)
-  @store['foo'].should == 'bar'
+  store.store('foo', 'bar', :expires => 2)
+  store['foo'].should == 'bar'
   sleep 1
-  @store['foo'].should == 'bar'
+  store['foo'].should == 'bar'
   sleep 2
-  @store['foo'].should == nil
-  @store.adapter['foo'].should == nil
-  @store.adapter.adapter['foo'].should == nil
+  store['foo'].should == nil
+  store.adapter['foo'].should == nil
+  store.adapter.adapter['foo'].should == nil
 end
 }
   },
   'proxy_redis' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Proxy
   use :Proxy
   adapter :Redis
@@ -267,8 +265,7 @@ end},
     :specs => ADAPTER_SPECS + [:expires_stringkey_stringvalue]
   },
   'proxy_expires_memory' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Proxy
   use :Expires
   use :Proxy
@@ -277,8 +274,7 @@ end},
     :specs => [:null, :store, :expires]
   },
   'cache_file_memory' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use(:Cache) do
     backend { adapter :File, :dir => File.join(make_tempdir, "cache_file_memory") }
     cache { adapter :Memory }
@@ -287,20 +283,19 @@ end},
     :specs => ADAPTER_SPECS,
     :tests => %{
 it 'should store loaded values in cache' do
-  @store.backend['foo'] = 'bar'
-  @store.cache['foo'].should == nil
-  @store['foo'].should == 'bar'
-  @store.cache['foo'].should == 'bar'
-  @store.backend.delete('foo')
-  @store['foo'].should == 'bar'
-  @store.delete('foo')
-  @store['foo'].should == nil
+  store.backend['foo'] = 'bar'
+  store.cache['foo'].should == nil
+  store['foo'].should == 'bar'
+  store.cache['foo'].should == 'bar'
+  store.backend.delete('foo')
+  store['foo'].should == 'bar'
+  store.delete('foo')
+  store['foo'].should == nil
 end
 }
   },
   'cache_memory_null' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use(:Cache) do
     backend(Juno::Adapters::Memory.new)
     cache(Juno::Adapters::Null.new)
@@ -309,8 +304,7 @@ end},
     :specs => ADAPTER_SPECS
   },
   'stack_file_memory' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use(:Stack) do
     add(Juno.new(:Null))
     add(Juno::Adapters::Null.new)
@@ -321,8 +315,7 @@ end},
     :specs => ADAPTER_SPECS
   },
   'stack_memory_file' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use(:Stack) do
     add(Juno.new(:Null))
     add(Juno::Adapters::Null.new)
@@ -332,9 +325,15 @@ Juno.build do
 end},
     :specs => [:null_stringkey_stringvalue, :store_stringkey_stringvalue]
   },
+  'lock' => {
+    :build => %{Juno.build do
+  use :Lock
+  adapter :Memory
+end},
+    :specs => [:null, :store]
+  },
   'transformer_compress' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :value => :compress
   adapter :Memory
 end},
@@ -342,8 +341,7 @@ end},
     :specs => [:null, :store, :returndifferent]
   },
   'transformer_json' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => :json, :value => :json
   adapter :Memory
 end},
@@ -352,8 +350,7 @@ end},
     :specs => [:null, :store, :returndifferent]
   },
   'transformer_bson' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => :bson, :value => :bson
   adapter :Memory
 end},
@@ -361,9 +358,15 @@ end},
     :value => %w(Hash String),
     :specs => [:null, :store, :returndifferent]
   },
+  'transformer_ox' => {
+    :build => %{Juno.build do
+  use :Transformer, :key => :ox, :value => :ox
+  adapter :Memory
+end},
+    :specs => [:null, :store, :returndifferent]
+  },
 #  'transformer_tnet' => {
-#    :build => %{
-#Juno.build do
+#    :build => %{Juno.build do
 #  use :Transformer, :key => :tnet, :value => :tnet
 #  adapter :Memory
 #end},
@@ -372,8 +375,7 @@ end},
 #    :specs => [:null, :store, :returndifferent]
 #  },
   'transformer_msgpack' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => :msgpack, :value => :msgpack
   adapter :Memory
 end},
@@ -382,40 +384,35 @@ end},
     :specs => [:null, :store, :returndifferent]
   },
   'transformer_yaml' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => :yaml, :value => :yaml
   adapter :Memory
 end},
     :specs => [:null, :store, :returndifferent]
   },
   'transformer_marshal_base64' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :base64], :value => [:marshal, :base64]
   adapter :Memory
 end},
     :specs => [:null, :store, :returndifferent, :marshallable_key]
   },
   'transformer_marshal_escape' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :escape], :value => :marshal
   adapter :Memory
 end},
     :specs => [:null, :store, :returndifferent, :marshallable_key]
   },
   'transformer_marshal_md5' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :md5], :value => :marshal
   adapter :Memory
 end},
     :specs => [:null, :store, :returndifferent, :marshallable_key]
   },
   'transformer_marshal_md5_spread' => {
-    :build => %{
-Juno.build do
+    :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :md5, :spread], :value => :marshal
   adapter :Memory
 end},
@@ -426,9 +423,9 @@ end},
     :specs => ADAPTER_SPECS,
     :tests => %{
 it 'updates an existing key/value' do
-  @store['foo/bar'] = '1'
-  @store['foo/bar'] = '2'
-  records = @store.table.find :all, :conditions => { :k => 'foo/bar' }
+  store['foo/bar'] = '1'
+  store['foo/bar'] = '2'
+  records = store.table.find :all, :conditions => { :k => 'foo/bar' }
   records.count.should == 1
 end
 
@@ -512,15 +509,15 @@ end
     :specs => ADAPTER_SPECS
   },
   'adapter_memcached_dalli' => {
-    :build => 'Juno::Adapters::MemcachedDalli.new(:server => "localhost:22122", :namespace => "adapter_memcached_dalli")',
+    :build => 'Juno::Adapters::MemcachedDalli.new(:namespace => "adapter_memcached_dalli")',
     :specs => ADAPTER_SPECS + [:expires_stringkey_stringvalue]
   },
   'adapter_memcached_native' => {
-    :build => 'Juno::Adapters::MemcachedNative.new(:server => "localhost:22122", :namespace => "adapter_memcached_native")',
+    :build => 'Juno::Adapters::MemcachedNative.new(:namespace => "adapter_memcached_native")',
     :specs => ADAPTER_SPECS + [:expires_stringkey_stringvalue]
   },
   'adapter_memcached' => {
-    :build => 'Juno::Adapters::Memcached.new(:server => "localhost:22122", :namespace => "adapter_memcached")',
+    :build => 'Juno::Adapters::Memcached.new(:namespace => "adapter_memcached")',
     :specs => ADAPTER_SPECS + [:expires_stringkey_stringvalue]
   },
   'adapter_memory' => {
@@ -564,8 +561,12 @@ end
     :build => 'Juno::Adapters::Sqlite.new(:file => File.join(make_tempdir, "adapter_sqlite"))',
     :specs => ADAPTER_SPECS
   },
-  'adapter_tokyocabinet' => {
-    :build => 'Juno::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet"))',
+  'adapter_tokyocabinet_bdb' => {
+    :build => 'Juno::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet_bdb"), :type => :bdb)',
+    :specs => ADAPTER_SPECS
+  },
+  'adapter_tokyocabinet_hdb' => {
+    :build => 'Juno::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet_hdb"), :type => :hdb)',
     :specs => ADAPTER_SPECS
   },
   'adapter_yaml' => {
@@ -594,163 +595,163 @@ KEYS.each do |key_type, (key1,key2)|
   VALUES.each do |val_type, (val1,val2)|
 
     code = %{it "reads from keys that are #{key_type}s like a Hash" do
-  @store[#{key1}].should == nil
-  @store.load(#{key1}).should == nil
+  store[#{key1}].should == nil
+  store.load(#{key1}).should == nil
 end
 
 it "guarantees that the same #{val_type} value is returned when setting a #{key_type} key" do
   value = #{val1}
-  (@store[#{key1}] = value).should equal(value)
+  (store[#{key1}] = value).should equal(value)
 end
 
 it "returns false from key? if a #{key_type} key is not available" do
-  @store.key?(#{key1}).should == false
+  store.key?(#{key1}).should == false
 end
 
 it "returns nil from delete if an element for a #{key_type} key does not exist" do
-  @store.delete(#{key1}).should == nil
+  store.delete(#{key1}).should == nil
 end
 
 it "removes all #{key_type} keys from the store with clear" do
-  @store[#{key1}] = #{val1}
-  @store[#{key2}] = #{val2}
-  @store.clear.should equal(@store)
-  @store.key?(#{key1}).should_not ==  true
-  @store.key?(#{key2}).should_not == true
+  store[#{key1}] = #{val1}
+  store[#{key2}] = #{val2}
+  store.clear.should equal(store)
+  store.key?(#{key1}).should_not ==  true
+  store.key?(#{key2}).should_not == true
 end
 
 it "fetches a #{key_type} key with a default value with fetch, if the key is not available" do
-  @store.fetch(#{key1}, #{val1}).should == #{val1}
+  store.fetch(#{key1}, #{val1}).should == #{val1}
 end
 
 it "fetches a #{key_type} key with a block with fetch, if the key is not available" do
   key = #{key1}
   value = #{val1}
-  @store.fetch(key) do |k|
+  store.fetch(key) do |k|
     k.should equal(key)
     value
   end.should equal(value)
 end
 
 it 'should accept options' do
-  @store.key?(#{key1}, :option1 => 1).should == false
-  @store.load(#{key1}, :option2 => 2).should == nil
-  @store.fetch(#{key1}, nil, :option3 => 3).should == nil
-  @store.delete(#{key1}, :option4 => 4).should == nil
-  @store.clear(:option5 => 5).should equal(@store)
-  @store.store(#{key1}, #{val1}, :option6 => 6).should == #{val1}
+  store.key?(#{key1}, :option1 => 1).should == false
+  store.load(#{key1}, :option2 => 2).should == nil
+  store.fetch(#{key1}, nil, :option3 => 3).should == nil
+  store.delete(#{key1}, :option4 => 4).should == nil
+  store.clear(:option5 => 5).should equal(store)
+  store.store(#{key1}, #{val1}, :option6 => 6).should == #{val1}
 end}
     SPECS["null_#{key_type.downcase}key_#{val_type.downcase}value"] = code
 
     code = %{it "writes #{val_type} values to keys that are #{key_type}s like a Hash" do
-  @store[#{key1}] = #{val1}
-  @store[#{key1}].should == #{val1}
-  @store.load(#{key1}).should == #{val1}
+  store[#{key1}] = #{val1}
+  store[#{key1}].should == #{val1}
+  store.load(#{key1}).should == #{val1}
 end
 
 it "returns true from key? if a #{key_type} key is available" do
-  @store[#{key1}] = #{val1}
-  @store.key?(#{key1}).should == true
+  store[#{key1}] = #{val1}
+  store.key?(#{key1}).should == true
 end
 
 it "stores #{val_type} values with #{key_type} keys with #store" do
   value = #{val1}
-  @store.store(#{key1}, value).should equal(value)
-  @store[#{key1}].should == #{val1}
-  @store.load(#{key1}).should == #{val1}
+  store.store(#{key1}, value).should equal(value)
+  store[#{key1}].should == #{val1}
+  store.load(#{key1}).should == #{val1}
 end
 
 it "removes and returns a #{val_type} element with a #{key_type} key from the backing store via delete if it exists" do
-  @store[#{key1}] = #{val1}
-  @store.delete(#{key1}).should == #{val1}
-  @store.key?(#{key1}).should == false
+  store[#{key1}] = #{val1}
+  store.delete(#{key1}).should == #{val1}
+  store.key?(#{key1}).should == false
 end
 
 it "overwrites existing #{val_type} values with #{key_type}" do
-  @store[#{key1}] = #{val1}
-  @store[#{key1}].should == #{val1}
-  @store[#{key1}] = #{val2}
-  @store[#{key1}].should == #{val2}
+  store[#{key1}] = #{val1}
+  store[#{key1}].should == #{val1}
+  store[#{key1}] = #{val2}
+  store[#{key1}].should == #{val2}
 end
 
 it "does not run the block if the #{key_type} key is available" do
-  @store[#{key1}] = #{val1}
+  store[#{key1}] = #{val1}
   unaltered = "unaltered"
-  @store.fetch(#{key1}) { unaltered = "altered" }
+  store.fetch(#{key1}) { unaltered = "altered" }
   unaltered.should == "unaltered"
 end
 
 it "fetches a #{key_type} key with a default value with fetch, if the key is available" do
-  @store[#{key1}] = #{val1}
-  @store.fetch(#{key1}, #{val2}).should == #{val1}
+  store[#{key1}] = #{val1}
+  store.fetch(#{key1}, #{val2}).should == #{val1}
 end}
     SPECS["store_#{key_type.downcase}key_#{val_type.downcase}value"] = code
 
     code = %{it "guarantees that a different #{val_type} value is retrieved from the #{key_type} key" do
   value = #{val1}
-  @store[#{key1}] = #{val1}
-  @store[#{key1}].should_not be_equal(#{val1})
+  store[#{key1}] = #{val1}
+  store[#{key1}].should_not be_equal(#{val1})
 end}
     SPECS["returndifferent_#{key_type.downcase}key_#{val_type.downcase}value"] = code
 
     code = %{it 'should support expires on store and #[]' do
-  @store.store(#{key1}, #{val1}, :expires => 2)
-  @store[#{key1}].should == #{val1}
+  store.store(#{key1}, #{val1}, :expires => 2)
+  store[#{key1}].should == #{val1}
   sleep 1
-  @store[#{key1}].should == #{val1}
+  store[#{key1}].should == #{val1}
   sleep 2
-  @store[#{key1}].should == nil
+  store[#{key1}].should == nil
 end
 
 it 'should support expires on store and load' do
-  @store.store(#{key1}, #{val1}, :expires => 2)
-  @store.load(#{key1}).should == #{val1}
+  store.store(#{key1}, #{val1}, :expires => 2)
+  store.load(#{key1}).should == #{val1}
   sleep 1
-  @store.load(#{key1}).should == #{val1}
+  store.load(#{key1}).should == #{val1}
   sleep 2
-  @store.load(#{key1}).should == nil
+  store.load(#{key1}).should == nil
 end
 
 it 'should support expires on store and key?' do
-  @store.store(#{key1}, #{val1}, :expires => 2)
-  @store.key?(#{key1}).should == true
+  store.store(#{key1}, #{val1}, :expires => 2)
+  store.key?(#{key1}).should == true
   sleep 1
-  @store.key?(#{key1}).should == true
+  store.key?(#{key1}).should == true
   sleep 2
-  @store.key?(#{key1}).should == false
+  store.key?(#{key1}).should == false
 end
 
 it 'should support updating the expiration time in load' do
-  @store.store(#{key2}, #{val2}, :expires => 2)
-  @store[#{key2}].should == #{val2}
+  store.store(#{key2}, #{val2}, :expires => 2)
+  store[#{key2}].should == #{val2}
   sleep 1
-  @store.load(#{key2}, :expires => 3).should == #{val2}
-  @store[#{key2}].should == #{val2}
+  store.load(#{key2}, :expires => 3).should == #{val2}
+  store[#{key2}].should == #{val2}
   sleep 1
-  @store[#{key2}].should == #{val2}
+  store[#{key2}].should == #{val2}
   sleep 3
-  @store[#{key2}].should == nil
+  store[#{key2}].should == nil
 end
 
 it 'should support updating the expiration time in fetch' do
-  @store.store(#{key1}, #{val1}, :expires => 2)
-  @store[#{key1}].should == #{val1}
+  store.store(#{key1}, #{val1}, :expires => 2)
+  store[#{key1}].should == #{val1}
   sleep 1
-  @store.fetch(#{key1}, nil, :expires => 3).should == #{val1}
-  @store[#{key1}].should == #{val1}
+  store.fetch(#{key1}, nil, :expires => 3).should == #{val1}
+  store[#{key1}].should == #{val1}
   sleep 1
-  @store[#{key1}].should == #{val1}
+  store[#{key1}].should == #{val1}
   sleep 3
-  @store[#{key1}].should == nil
+  store[#{key1}].should == nil
 end
 
 it 'should respect expires in delete' do
-  @store.store(#{key2}, #{val2}, :expires => 2)
-  @store[#{key2}].should == #{val2}
+  store.store(#{key2}, #{val2}, :expires => 2)
+  store[#{key2}].should == #{val2}
   sleep 1
-  @store[#{key2}].should == #{val2}
+  store[#{key2}].should == #{val2}
   sleep 2
-  @store.delete(#{key2}).should == nil
+  store.delete(#{key2}).should == nil
 end}
     SPECS["expires_#{key_type.downcase}key_#{val_type.downcase}value"] = code
 
@@ -759,47 +760,47 @@ end
 
 SPECS["marshallable_key"]  = %{it "refuses to #[] from keys that cannot be marshalled" do
   expect do
-    @store[Struct.new(:foo).new(:bar)]
+    store[Struct.new(:foo).new(:bar)]
   end.to raise_error(marshal_error)
 end
 
 it "refuses to load from keys that cannot be marshalled" do
   expect do
-    @store.load(Struct.new(:foo).new(:bar))
+    store.load(Struct.new(:foo).new(:bar))
   end.to raise_error(marshal_error)
 end
 
 it "refuses to fetch from keys that cannot be marshalled" do
   expect do
-    @store.fetch(Struct.new(:foo).new(:bar), true)
+    store.fetch(Struct.new(:foo).new(:bar), true)
   end.to raise_error(marshal_error)
 end
 
 it "refuses to #[]= to keys that cannot be marshalled" do
   expect do
-    @store[Struct.new(:foo).new(:bar)] = 'value'
+    store[Struct.new(:foo).new(:bar)] = 'value'
   end.to raise_error(marshal_error)
 end
 
 it "refuses to store to keys that cannot be marshalled" do
   expect do
-    @store.store Struct.new(:foo).new(:bar), 'value'
+    store.store Struct.new(:foo).new(:bar), 'value'
   end.to raise_error(marshal_error)
 end
 
 it "refuses to check for key? if the key cannot be marshalled" do
   expect do
-    @store.key? Struct.new(:foo).new(:bar)
+    store.key? Struct.new(:foo).new(:bar)
   end.to raise_error(marshal_error)
 end
 
 it "refuses to delete a key if the key cannot be marshalled" do
   expect do
-    @store.delete Struct.new(:foo).new(:bar)
+    store.delete Struct.new(:foo).new(:bar)
   end.to raise_error(marshal_error)
 end}
 
-specs_code = ''
+specs_code = "#{header}\n"
 SPECS.each do |key, code|
   specs_code << "#################### #{key} ####################\n\n" <<
     "shared_examples_for '#{key}' do\n  " << code.gsub("\n", "\n  ") << "\nend\n\n"
@@ -814,13 +815,13 @@ TESTS.each do |name, options|
   value = [options.delete(:value) || %w(Object String Hash)].flatten
 
   specs = [options.delete(:specs) || SIMPLE_SPECS].flatten
-  specs_code = ''
+  specs_code = []
   specs.each do |s|
-    specs_code << "    it_should_behave_like '#{s}'\n" if SPECS[s.to_s]
+    specs_code << "  it_should_behave_like '#{s}'" if SPECS[s.to_s]
     key.each do |k|
       value.each do |v|
         x = "#{s}_#{k.downcase}key_#{v.downcase}value"
-        specs_code << "    it_should_behave_like '#{x}'\n" if SPECS[x]
+        specs_code << "  it_should_behave_like '#{x}'" if SPECS[x]
       end
     end
   end
@@ -831,29 +832,15 @@ TESTS.each do |name, options|
 
   build ||= "Juno.new(#{store.inspect}#{opts})"
 
-  code = %{# Generated file
-require 'helper'
-
-begin
-  #{preamble}#{build}.close
-
-  describe #{name.inspect} do
-    before do
-      @store = #{build}
-      @store.clear
-    end
-
-    after do
-      @store.close.should == nil if @store
-    end
+  code = %{#{header}require 'helper'
 
-#{specs_code}#{options[:tests].to_s.gsub("\n", "\n    ")}
+describe_juno #{name.inspect} do
+  #{preamble}def new_store
+    #{build.gsub("\n", "\n    ")}
   end
-rescue LoadError => ex
-  puts "Test #{name} not executed: \#{ex.message}"
-rescue Exception => ex
-  puts "Test #{name} not executed: \#{ex.message}"
-  #puts "\#{ex.backtrace.join("\\n")}"
+
+  include_context 'setup_store'
+#{specs_code.join("\n")}#{options[:tests].to_s.gsub("\n", "\n  ")}
 end
 }
 

data/spec/helper.rb

@@ -37,3 +37,42 @@ def marshal_error
     TypeError
   end
 end
+
+class InitializeStore
+  def initialize(&block)
+    instance_eval(&block)
+    store = new_store
+    store['foo'] = 'bar'
+    store.clear
+    store.close
+  end
+
+  def method_missing(*args)
+  end
+end
+
+def describe_juno(name, &block)
+  begin
+    InitializeStore.new(&block)
+    describe(name, &block)
+  rescue LoadError => ex
+    puts "\e[31mTest #{name} not executed: #{ex.message}\e[0m"
+  rescue Exception => ex
+    puts "\e[31mTest #{name} not executed: #{ex.message}\e[0m"
+    puts ex.backtrace.join("\n")
+  end
+end
+
+shared_context 'setup_store' do
+  let(:store) do
+    new_store
+  end
+
+  before do
+    store.clear
+  end
+
+  after do
+    store.close.should == nil if store
+  end
+end