kissifer-hash-persistent 0.0.0 → 0.0.3

data/spec/counter_spec.rb

@@ -1,61 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "HashPersistent::Counter" do
-  context "(instantiation)" do
-    it "should expect to persist to a HashPersistent::Store and a string-like key" do
-      HashPersistent::Counter.new(HashPersistent::Store.new({}, ""), "key")
-    end
-
-    it "should reject an incorrect store type" do
-      lambda {HashPersistent::Counter.new(1, "key")}.should raise_error(ArgumentError)
-    end
-
-    it "should reject a non-string-like key" do
-      lambda {HashPersistent::Counter.new(HashPersistent::Store.new({}, ""), Dummy_NoStringRep.new)}.should raise_error(ArgumentError)
-    end
-
-    it "should reject an empty string key" do
-      lambda {HashPersistent::Counter.new(HashPersistent::Store.new({}, ""), "")}.should raise_error(ArgumentError)
-    end
-
-    it "should add an count object to the store" do
-      store = HashPersistent::Store.new({}, "")
-      HashPersistent::Counter.new(store, "counter_name")
-      store.find("counter_name").count.should == 0
-    end
-
-    it "should not change the count object in the store if already present" do
-      store = HashPersistent::Store.new({}, "")
-      counter_1 = HashPersistent::Counter.new(store, "counter_name")
-      counter_1.next.should == 0
-      counter_1.next.should == 1
-      counter_1.next.should == 2
-
-      counter_2 = HashPersistent::Counter.new(store, "counter_name")
-      store.find("counter_name").count.should == 3
-    end
-  end
-  
-  context "(generating unique ids)" do    
-    it "should increment the count value in the store when a new id is requested" do
-      store = HashPersistent::Store.new({}, "")
-      counter = HashPersistent::Counter.new(store, "counter_name")
-      counter.next
-      store.find("counter_name").count.should == 1
-      counter.next
-      store.find("counter_name").count.should == 2
-    end
-    
-    it "should return the count held in the store when a new id is requested" do
-      store = HashPersistent::Store.new({}, "")
-      counter = HashPersistent::Counter.new(store, "counter_name")
-      counter.next.should == 0
-      counter.next.should == 1
-      counter.next.should == 2
-    end
-  end
-
-  context "(concurrent access)" do
-    it "should correctly protect against use by mutliple threads/processes"
-  end
-end

data/spec/extended_store_spec.rb

@@ -1,103 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "HashPersistent::ExtendedStore" do
-  context "(instantiation)" do
-    it "should initialise its store attribute" do
-      store = HashPersistent::Store.new(Hash.new, "prefix::")
-      extended_store = HashPersistent::ExtendedStore.new(store)
-      extended_store.store.should == store
-    end
-  end
-  
-  context "(in default configuration)" do
-    it "should delegate the find method to its store" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      extended_store.store.should_receive(:find).with("a_key")
-      extended_store.find("a_key")
-    end
-
-    it "should delegate the save method to its store" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      object = OpenStruct.new
-      object.key = "a_key"
-      extended_store.store.should_receive(:save).with(object)
-      extended_store.save(object)
-    end
-
-    it "should delegate the delete method to its store" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      object = OpenStruct.new
-      object.key = "a_key"
-      extended_store.store.should_receive(:delete).with(object)
-      extended_store.delete(object)
-    end
-
-    it "should delegate the create method to its store" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      extended_store.store.should_receive(:create).with("key", OpenStruct)
-      extended_store.create("key", OpenStruct)
-    end
-
-    it "should delegate the find_or_create method to its store" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      extended_store.store.should_receive(:find_or_create).with("key", OpenStruct)
-      extended_store.find_or_create("key", OpenStruct)
-    end
-  end
-  
-  context "(singleton keys)" do
-    it "should allow a singleton key pattern to be specified" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      extended_store.singleton_key("foo", OpenStruct)
-
-      HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, "")) do |store|
-        store.singleton_key "foo", OpenStruct
-      end
-    end
-
-    it "should reject a pattern that cannot be matched against a string" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      lambda{extended_store.singleton_key(1, OpenStruct)}.should raise_error
-    end
-
-    it "should not redirect find for keys that do not match the singleton pattern" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      extended_store.singleton_key("foo", OpenStruct)
-
-      extended_store.store.should_receive(:find).with("bar")
-      extended_store.store.should_not_receive(:find_or_create)
-
-      extended_store.find("bar")
-    end
-
-    it "should redirect find to find_or_create for keys that match the singleton pattern" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      extended_store.singleton_key("foo", OpenStruct, "arg1", "arg2")
-
-      extended_store.store.should_receive(:find_or_create).with("food", OpenStruct, "arg1", "arg2")
-      extended_store.store.should_not_receive(:find)
-
-      extended_store.find("food")
-    end
-
-    it "should allow multiple patterns to be specified" do
-      extended_store = HashPersistent::ExtendedStore.new(HashPersistent::Store.new({}, ""))
-      extended_store.singleton_key("foo", OpenStruct, "arg1", "arg2")
-      extended_store.singleton_key("bar", Object, "arg3", "arg4")
-
-      extended_store.store.should_receive(:find_or_create).with("food", OpenStruct, "arg1", "arg2")
-      extended_store.find("food")
-
-      extended_store.store.should_receive(:find_or_create).with("barney", Object, "arg3", "arg4")
-      extended_store.find("barney")
-    end
-  end
-  
-  context "(proxy stores)" do
-    it "should be clever"
-  end
-
-  context "(watching objects)" do
-    it "should be clever"
-  end
-end

data/spec/resource_spec.rb

@@ -1,48 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-class ResourceFoo
-  include HashPersistent::Resource
-end
-
-
-describe "A class that includes HashPersistent::Resource" do
-  it "should acquire a store attribute" do
-    resource = ResourceFoo.new
-    resource.store = "foo"
-    resource.store.should == "foo"
-  end
-
-  it "should acquire a key attribute" do
-    resource = ResourceFoo.new
-    resource.key = "foo"
-    resource.key.should == "foo"
-  end
-
-  it "should be savable to its store" do
-    resource = ResourceFoo.new
-    mock_store = "dummy"
-    resource.store = mock_store
-    
-    mock_store.should_receive(:save).with(resource)
-    resource.save
-  end
-
-  it "should be deletable from its store" do
-    resource = ResourceFoo.new
-    mock_store = "dummy"
-    resource.store = mock_store
-    
-    mock_store.should_receive(:delete).with(resource)
-    resource.delete
-  end
-
-  it "should be movable from one store to another" do
-    resource = ResourceFoo.new
-    mock_store = "dummy" # We use only one so that we can use rspec to check the order of the messages...
-    resource.store = mock_store
-    
-    mock_store.should_receive(:delete).with(resource).ordered
-    mock_store.should_receive(:save).with(resource).ordered
-    resource.move(mock_store)
-  end
-end

data/spec/store_spec.rb

@@ -1,370 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-class ClassWithKey
-  attr_accessor :key, :var
-  def initialize(key, var)
-    @key = key
-    @var = var
-  end
-  
-  def ==(other)
-    (other.class == ClassWithKey) && (key == other.key) && (var == other.var)
-  end
-end
-
-class ClassWithKeyAndStore
-  attr_accessor :key, :store, :var
-
-  def initialize(key = nil)
-    @key = key
-  end
-end
-
-describe "HashPersistent::Store" do
-  context "(instantiation)" do
-    it "should expect to persist to a hash-like key_value_store, with a string-like key_prefix" do
-      HashPersistent::Store.new({}, "_prefix")
-    end
-
-    it "should reject a non-hash-like key_value_store" do
-      lambda {HashPersistent::Store.new(1, "_prefix")}.should raise_error(ArgumentError)
-    end
-
-    it "should reject a non-string-like key_prefix" do
-      lambda {HashPersistent::Store.new({}, Dummy_NoStringRep.new)}.should raise_error(ArgumentError)
-    end
-    
-    it "should maintain a key_value_store attribute" do
-      a_hash = {}
-      HashPersistent::Store.new(a_hash, "").key_value_store.should == a_hash
-    end
-
-    it "should maintain a key_prefix attribute" do
-      HashPersistent::Store.new({}, "foo_bar").key_prefix.should == "foo_bar"
-    end
-  end
-  
-  context "(saving)" do
-    it "should refuse to save an object that does not provide a non-nil key" do
-      lambda{HashPersistent::Store.new({}, "").save(1)}.should raise_error
-      object = ClassWithKey.new(nil, "foo")
-      lambda{HashPersistent::Store.new({}, "").save(object)}.should raise_error
-    end
-    
-    it "should add the object, referenced by its prefixed key, to the store" do
-      store = HashPersistent::Store.new({}, "prefix::")
-      object = ClassWithKey.new("foo", "bar")
-      store.save(object).key_value_store["prefix::foo"].should == object
-    end
-    
-    it "should overwrite an object with same prefixed key in the store" do
-      store = HashPersistent::Store.new({}, "prefix::")
-      object_1 = ClassWithKey.new("foo", "bar")
-      object_2 = ClassWithKey.new("foo", "baz")
-      store.save(object_1).save(object_2).key_value_store["prefix::foo"].should == object_2
-    end
-  end
-  
-  context "(deleting)" do
-    it "should refuse to delete an object that does not provide a non-nil key" do
-      lambda{HashPersistent::Store.new({}, "").delete(1)}.should raise_error
-      object = ClassWithKey.new(nil, "foo")
-      lambda{HashPersistent::Store.new({}, "").delete(object)}.should raise_error
-    end
-
-    it "should delete a pair from the store based on the object's prefixed key" do
-      store = HashPersistent::Store.new({}, "prefix::")
-      object = ClassWithKey.new("foo", "bar")
-      store.save(object).delete(object).key_value_store["prefix::foo"].should be_nil
-    end
-
-    it "should not complain if the prefixed key does not exist in the store" do
-      store = HashPersistent::Store.new({}, "prefix::")
-      object = ClassWithKey.new("foo", "bar")
-      lambda{store.delete(object)}.should_not raise_error
-    end
-  end
-
-  context "(finding)" do
-    it "should retrieve an object that has the correct key" do
-      store = HashPersistent::Store.new({}, "prefix::")
-      object = ClassWithKey.new("foo", "bar")
-      store.save(object).find("foo").should == object
-    end
-
-    it "should return nil if no object is found with the correct key" do
-      store = HashPersistent::Store.new({}, "prefix::")
-      object = ClassWithKey.new("foo", "bar")
-      store.find("foo").should be_nil
-      store.save(object).delete(object).find("foo").should be_nil
-    end
-  end
-
-  context "(creating)" do
-    it "should create objects on request" do
-      new_object = ClassWithKeyAndStore.new
-      ClassWithKeyAndStore.should_receive(:new).with("arg1", "arg2").and_return(new_object)
-      object = HashPersistent::Store.new({}, "prefix::").create("a_key", ClassWithKeyAndStore, "arg1", "arg2")
-      object.should == new_object
-    end
-    
-    it "should set the key attribute of created objects" do
-      block = lambda{"foo"}
-      object = HashPersistent::Store.new({}, "prefix::").create("a_key", ClassWithKeyAndStore)
-      object.key.should == "a_key"
-    end
-    
-    it "should be able to create and save when the requested key is not found" do
-      store = HashPersistent::Store.new({}, "")
-      store.find_or_create("a_key", OpenStruct, {:foo => "bar"})
-      store.find("a_key").should_not be_nil
-      store.find("a_key").foo.should == "bar"
-    end
-
-    it "should not create or modify when the requested key is found" do
-      store = HashPersistent::Store.new({}, "")
-      store.save(store.create("a_key", OpenStruct, {:foo => "bar"}))
-
-      store.find_or_create("a_key", OpenStruct, {:foo => "baz", :fred => "barney"})
-
-      store.find("a_key").should_not be_nil
-      store.find("a_key").fred.should be_nil
-      store.find("a_key").foo.should == "bar"
-    end
-  end
-  
-  context "(isolation of objects in in-memory stores)" do
-    it "should return a copy of the object found in the store" do
-      store = HashPersistent::Store.new({}, "")
-      object = ClassWithKey.new("foo", "bar")
-      store.save(object).find("foo").should_not equal(store.key_value_store["foo"])
-    end
-    
-    it "should save a copy of the object being saved" do
-      store = HashPersistent::Store.new({}, "")
-      object = ClassWithKey.new("foo", "bar")
-      store.save(object)
-      store.key_value_store["foo"].should_not equal(object)
-    end
-  end
-  
-  context "(handling objects that expose a store attribute)" do
-    it "should set the store attribute of a created object" do
-      store = HashPersistent::Store.new({}, "prefix::")
-      store.create("key", ClassWithKeyAndStore).store.should == store
-    end
-
-    it "should set the store attribute of a saved object" do
-      object = ClassWithKeyAndStore.new("foo")
-      store = HashPersistent::Store.new({}, "")
-      store.save(object)
-      object.store.should == store
-    end
-
-    it "should not save the store attribute into the store" do
-      object = ClassWithKeyAndStore.new("foo")
-      object.store = "faa"
-
-      store = HashPersistent::Store.new({}, "")
-      store.save(object)
-
-      store.key_value_store["foo"].store.should be_nil
-    end
-
-    it "should set the store attribute of a found object" do
-      object = ClassWithKeyAndStore.new("foo")
-      object.store = "faa"
-
-      store = HashPersistent::Store.new({}, "")
-      store.save(object).find("foo").store.should == store
-    end
-
-    it "leave the in-store object's store attribute nil after finding/returning the object" do
-      object = ClassWithKeyAndStore.new("foo")
-      object.store = "faa"
-
-      store = HashPersistent::Store.new({}, "")
-      store.save(object).find("foo")
-      store.key_value_store["foo"].store.should be_nil
-    end
-
-    it "set the object's store attribute after deleting the object" do
-      store = HashPersistent::Store.new({}, "")
-      object = ClassWithKeyAndStore.new("foo")
-
-      store.save(object)
-      object.store = nil
-      store.delete(object)
-      object.store.should == store
-    end
-  end
-
-  context "(use of restricted Hash API)" do
-    it "should not require Hash methods that are not implemented in Moneta"
-  end
-
-  context "(caching)" do
-    it "should accept a HashPersistent::Store cache" do
-      cache = HashPersistent::Store.new({}, "")
-      store = HashPersistent::Store.new({}, "") do |the_store|
-        the_store.cached_to = cache
-      end
-      store.cached_to.should == cache
-    end
-
-    # TODO: can relax this?
-    # We'd like to reproduce some nice behaviours in the cache (like unsetting object.store on saving)
-    it "should reject a cache of the wrong type" do
-      store = HashPersistent::Store.new({}, "")
-      lambda{store.cached_to = {}}.should raise_error(ArgumentError)
-    end
-
-    it "should allow the cache to be unset using nil" do
-      store = HashPersistent::Store.new({}, "")
-      store.cached_to = nil
-      store.cached_to.should == nil
-    end
-    
-    context "if supplied a cache" do
-      it "should also save an object to the cache when saving" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        store.cached_to = cache
-        
-        object = ClassWithKeyAndStore.new("foo")
-        cache.should_receive(:save) do |the_save_object|
-          the_save_object.key.should == "foo"
-        end
-        store.save(object)
-      end
-      
-      it "should also delete an object from the cache when deleting" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        store.cached_to = cache
-        
-        object = ClassWithKeyAndStore.new("foo")
-        store.save(object)
-
-        cache.should_receive(:delete) do |the_delete_object|
-          the_delete_object.key.should == "foo"
-        end
-        store.delete(object)
-      end
-      
-      it "should save an object to the cache if it is not present on find()" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        
-        object = ClassWithKeyAndStore.new("foo")
-        store.save(object)
-
-        # We're making an assumption here that no data is copied to the cache when we do this
-        store.cached_to = cache
-
-        cache.should_receive(:save) do |the_save_object|
-          the_save_object.key.should == "foo"
-        end
-        store.find("foo")
-      end
-      
-      it "should return the object from the cache if it is present on find()" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        store.cached_to = cache
-        
-        object = ClassWithKeyAndStore.new("foo")
-        object.var = "bar"
-        store.save(object)
-        
-        object.var = "baz"
-        cache.save(object)
-        
-        store.find("foo").var.should == "baz"
-      end
-
-      it "should not hit the store if the object is present in the cache on find()" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        store.cached_to = cache
-        
-        object = ClassWithKeyAndStore.new("foo")
-        store.save(object)
-        
-        # We assume that Fixnum is missing methods required in find(), but we verify this assumption below
-        class HashPersistent::Store
-          def hack_key_value_store
-            @key_value_store = 1
-          end
-        end
-        
-        store.hack_key_value_store
-
-        lambda{store.find("foo")}.should_not raise_error
-
-        store.cached_to = nil
-        lambda{store.find("foo")}.should raise_error
-
-        class HashPersistent::Store
-          undef hack_key_value_store
-        end        
-      end
-      
-      it "should correctly set the object's store attribute when saving" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        store.cached_to = cache
-        
-        object = ClassWithKeyAndStore.new("foo")
-        store.save(object)
-        object.store.should == store
-      end
-
-      it "should correctly set the object's store attribute when deleting" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        store.cached_to = cache
-        
-        object = ClassWithKeyAndStore.new("foo")
-
-        store.save(object)
-        object.store = nil
-
-        store.delete(object)
-        object.store.should == store
-      end
-      
-      it "should correctly set the object's store attribute when finding/caching" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        
-        object = ClassWithKeyAndStore.new("foo")
-        store.save(object)
-
-        store.cached_to = cache
-        found = store.find("foo")
-        
-        found.store.should == store
-      end
-      
-      it "should correctly set the object's store attribute when finding from the cache" do
-        cache = HashPersistent::Store.new({}, "")
-        store = HashPersistent::Store.new({}, "")
-        store.cached_to = cache
-        
-        object = ClassWithKeyAndStore.new("foo")
-        store.save(object)
-        
-        store.find("foo").store.should == store
-      end
-    end
-  end
-  
-  context "(consistency of store, watched store and cache after errors occur)" do
-    it "should do something both boring and predictable"
-  end
-  
-  context "(concurrent access)" do
-    it "should use locks and such to handle access from multiple threads/processes"
-  end
-end