entity_store 0.2.13 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56a515dc52707cf7d8ad0a5442a6bbd50288c0d7
-  data.tar.gz: 5791edaf2c3fc2d42c5f3bffc014a67e372d41fb
+  metadata.gz: da47c343082dee8f07abfc0c3dd8a0f57418b4cd
+  data.tar.gz: 549266a31901d09c77a34839d6f5d8ddf8708364
 SHA512:
-  metadata.gz: cac64af74658627325f5cb1aef22e457a96e8712d25dfcebd700ae4a9aca2c108abbf5c6f2ebc76c657370244b35af632b72c27c772854da8c9c8dde8c7fc822
-  data.tar.gz: f8cd018700bc09fe40590d8b06f30bdbf80e8c16fc996106a9e9b2cd88a06877aff938a120f7aee1f25cf7c8d350de894a16f586da1045044f0e14ff6b8a3475
+  metadata.gz: 2b7a028a7f73a67ef28a09ccdf009e8ba8bcd02f34c8c31832c26d81a9ebbc8323dffe93854e06178b1851423c77f94e00654a489f8fa8af76883ce6cd90275d
+  data.tar.gz: 4317c2c625b7ffb233f1b6e1c6d7f04a9170c0a94d2245c6270e51afcd3887357dd0798679671662200d36ec223af92c63692d102d6022e478f0b0b6c6616307

data/lib/entity_store/mongo_entity_store.rb

@@ -52,23 +52,32 @@ module EntityStore
     end
 
     # Public - create a snapshot of the entity and store in the entities collection
-    # 
+    #
     def snapshot_entity(entity)
       query = {'_id' => BSON::ObjectId.from_string(entity.id)}
       updates = { '$set' => { 'snapshot' => entity.attributes } }
+
+      if entity.class.respond_to? :entity_store_snapshot_key
+        # If there is a snapshot key, store it too
+        updates['$set']['snapshot_key'] = entity.class.entity_store_snapshot_key
+      else
+        # Otherwise, make sure there isn't one set
+        updates['$unset'] = { 'snapshot_key' => '' }
+      end
+
       entities.update(query, updates, { :upsert => true} )
     end
 
     # Public - remove the snapshot for an entity
-    # 
+    #
     def remove_entity_snapshot(id)
       entities.update({'_id' => BSON::ObjectId.from_string(id)}, { '$unset' => { 'snapshot' => 1}})
     end
 
     # Public - remove all snapshots
-    # 
+    #
     # type        - String optional class name for the entity
-    # 
+    #
     def remove_snapshots type=nil
       query = {}
       query['_type'] = type if type
@@ -85,21 +94,29 @@ module EntityStore
 
     # Public - loads the entity from the store, including any available snapshots
     # then loads the events to complete the state
-    # 
+    #
     # id                - String representation of BSON::ObjectId
     # raise_exception   - Boolean indicating whether to raise an exception if not found (default=false)
-    # 
+    #
     # Returns an object of the entity type
     def get_entity(id, raise_exception=false)
       if attrs = entities.find_one('_id' => BSON::ObjectId.from_string(id))
         begin
           entity_type = EntityStore::Config.load_type(attrs['_type'])
+
+          # Check if there is a snapshot key in use
+          if entity_type.respond_to? :entity_store_snapshot_key
+            active_key = entity_type.entity_store_snapshot_key
+            # Discard the snapshot if the keys don't match
+            attrs.delete('snapshot') unless active_key == attrs['snapshot_key']
+          end
+
           entity = entity_type.new(attrs['snapshot'] || {'id' => id })
         rescue => e
           log_error "Error loading type #{attrs['_type']}", e
           raise
         end
-        
+
         entity
       else
         raise NotFound.new(id) if raise_exception
@@ -111,23 +128,24 @@ module EntityStore
     end
 
     def get_events(id, since_version=nil)
-
       query = { '_entity_id' => BSON::ObjectId.from_string(id) }
+
       query['entity_version'] = { '$gt' => since_version } if since_version
 
       options = {
         :sort => [['entity_version', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]]
       }
 
-      events.find(query, options).collect do |attrs|
+      loaded_events = events.find(query, options).collect do |attrs|
         begin
           EntityStore::Config.load_type(attrs['_type']).new(attrs)
         rescue => e
           log_error "Error loading type #{attrs['_type']}", e
           nil
         end
-      end.select { |e| !e.nil? }
-    end
+      end
 
+      loaded_events.compact
+    end
   end
 end

data/lib/entity_store/version.rb

@@ -1,3 +1,3 @@
 module EntityStore
-  VERSION = "0.2.13".freeze
+  VERSION = "0.2.14".freeze
 end

data/spec/entity_store/mongo_entity_store_spec.rb

@@ -1,99 +1,202 @@
 require 'spec_helper'
 
-module MongoEntityStoreSpec
+describe MongoEntityStore do
   class DummyEntity
     include EntityStore::Entity
 
     attr_accessor :name, :description
 
+    def set_name(new_name)
+      record_event DummyEntityNameSet.new(name: new_name)
+    end
   end
-end
 
-describe MongoEntityStore do
-  before(:each) do
+  class DummyEntityWithSnapshotKey < DummyEntity
+    def self.entity_store_snapshot_key
+      @entity_store_snapshot_key ||= 1
+    end
+
+    def self.increment_entity_store_snapshot_key!
+      @entity_store_snapshot_key = entity_store_snapshot_key + 1
+    end
+  end
+
+  class DummyEntityNameSet
+    include EntityStore::Event
+
+    attr_accessor :name
+
+    def apply(entity)
+      entity.name = self.name
+    end
+
+    def ==(other)
+      # Crude check relying on inspect, ok for tests
+      self.inspect == other.inspect
+    end
+  end
+
+  let(:store) do
     MongoEntityStore.connection_profile = "mongodb://localhost/entity_store_default"
-    @store = MongoEntityStore.new
+    MongoEntityStore.new
+  end
+
+  describe "event storage" do
+    let(:entity_id) { random_object_id }
+
+    let(:first_event)     { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 1, :name => random_string) }
+    let(:second_event)    { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 2, :name => random_string) }
+    let(:third_event)     { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 3, :name => random_string) }
+    let(:unrelated_event) { DummyEntityNameSet.new(:entity_id => random_object_id, :entity_version => 4, :name => random_string) }
+
+    before do
+      store.add_event(second_event)
+      store.add_event(unrelated_event)
+      store.add_event(first_event)
+      store.add_event(third_event)
+    end
+
+    subject { store.get_events(event_entity_id, since_version) }
+
+    context "all events" do
+      let(:event_entity_id) { entity_id }
+      let(:since_version) { 0 }
+
+      it "should return the three events in order" do
+        subject.should == [first_event, second_event, third_event]
+      end
+    end
+
+    context "subset of events" do
+      let(:event_entity_id) { entity_id }
+      let(:since_version) { second_event.entity_version }
+
+      it "should only include events greater than the given version" do
+        subject.should == [ third_event ]
+      end
+    end
+
+    context "no events" do
+      let(:event_entity_id) { random_object_id }
+      let(:since_version) { 0 }
+
+      it "should return an empty array" do
+        subject.should be_empty
+      end
+    end
   end
 
   describe "#get_entity" do
-    before(:each) do
-      @id = random_object_id
-      @attrs = { 
-        '_type' => MongoEntityStoreSpec::DummyEntity.name, 
-        'version' => @version = random_integer
-      }
-      @entity = MongoEntityStoreSpec::DummyEntity.new
-      MongoEntityStoreSpec::DummyEntity.stub(:new) { @entity }
-      @entities_collection = double('MongoCollection', :find_one => @attrs)
-      @store.stub(:entities) { @entities_collection }
-      @events = [
-        double('Event', :apply => true, :entity_version => random_integer), double('Event', :apply => true, :entity_version => random_integer)
-      ]
-      @store.stub(:get_events) { @events }
-    end
-
-    subject { @store.get_entity(@id) }
-
-    it "should attempt to retrieve the entity record from the store" do
-      @entities_collection.should_receive(:find_one).with({'_id' => BSON::ObjectId.from_string(@id)})
-      subject
+    let(:entity_class) { DummyEntity }
+
+    let(:saved_entity) do
+      entity = entity_class.new(:name => random_string, :description => random_string)
+      entity.id = store.add_entity(entity)
+      entity
     end
-    it "should construct a new entity" do
-      MongoEntityStoreSpec::DummyEntity.should_receive(:new).with({'id' => @id})
-      subject
+
+    subject { store.get_entity(saved_entity.id) }
+
+    it "should retrieve an entity from the store with the same ID" do
+      subject.id.should == saved_entity.id
     end
-    it "should return the entity" do
-      subject.should eq(@entity)
+
+    it "should retrieve an entity from the store with the same class" do
+      subject.class.should == saved_entity.class
+    end
+
+    it "should have the same version" do
+      subject.version.should == saved_entity.version
     end
+
+    context "when a snapshot does not exist" do
+      it "should not have set the name" do
+        subject.name.should be_nil
+      end
+    end
+
     context "when a snapshot exists" do
-      before(:each) do
-        @attrs['snapshot'] = {
-          'version' => @snapshot_version = random_integer,
-          'name' => @name = random_string
-        }
+      before do
+        saved_entity.version = 10
+        store.snapshot_entity(saved_entity)
       end
-      it "should construct a new entity with from the snapshot" do
-        MongoEntityStoreSpec::DummyEntity.should_receive(:new).with(@attrs['snapshot'])
-        subject
+
+      context "when a snapshot key not in use" do
+        it "should have set the name" do
+          subject.name.should == saved_entity.name
+        end
+      end
+
+      context "when a snapshot key is in use" do
+        let(:entity_class) { DummyEntityWithSnapshotKey }
+
+        context "when the key matches the class's key" do
+          it "should have set the name" do
+            subject.name.should == saved_entity.name
+          end
+        end
+
+        context "when the key does not match the class's key" do
+          before do
+            entity_class.increment_entity_store_snapshot_key!
+          end
+
+          it "should ignore the invalidated snapshot" do
+            subject.name.should be_nil
+          end
+        end
       end
     end
   end
 
   describe "#get_entity!" do
-
     context "when invalid id format passed" do
-      
-      subject { @store.get_entity!(random_string) }
-      
+      subject { store.get_entity!(random_string) }
+
       it "should raise not found" do
         expect { subject }.to raise_error(NotFound)
       end
     end
+
     context "when valid id format passed but no object exists" do
-      
-      subject { @store.get_entity!(random_object_id) }
-      
+      subject { store.get_entity!(random_object_id) }
+
       it "should raise not found" do
         expect { subject }.to raise_error(NotFound)
       end
     end
-    
   end
-  
+
   describe "#snapshot_entity" do
-    before(:each) do
-      @entity = MongoEntityStoreSpec::DummyEntity.new(:id => random_object_id, :version => random_integer, :name => random_string)
+    let(:entity_class) { DummyEntity }
+
+    let(:entity) do
+      entity_class.new(:id => random_object_id, :version => random_integer, :name => random_string)
     end
 
-    subject { @store.snapshot_entity(@entity) }
+    let(:saved_entity) do
+      store.entities.find_one({'_id' => BSON::ObjectId.from_string(entity.id)})
+    end
+
+    subject { store.snapshot_entity(entity) }
 
     it "should add a snaphot to the entity record" do
-      subject 
-      saved_entity = @store.entities.find_one({'_id' => BSON::ObjectId.from_string(@entity.id)})['snapshot']
-      saved_entity['id'].should eq(@entity.id)
-      saved_entity['version'].should eq(@entity.version)
-      saved_entity['name'].should eq(@entity.name)
-      saved_entity['description'].should eq(@entity.description)
+      subject
+      snapshot = saved_entity['snapshot']
+
+      snapshot['id'].should eq(entity.id)
+      snapshot['version'].should eq(entity.version)
+      snapshot['name'].should eq(entity.name)
+      snapshot['description'].should eq(entity.description)
+    end
+
+    context "entity with snapshot key" do
+      let(:entity_class) { DummyEntityWithSnapshotKey }
+
+      it "should store the snapshot key" do
+        subject
+        saved_entity['snapshot_key'].should == entity.class.entity_store_snapshot_key
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -35,5 +35,5 @@ def random_time
 end
 
 def random_object_id
-  BSON::ObjectId.from_time(random_time).to_s
-end
+  BSON::ObjectId.from_time(random_time, :unique => true).to_s
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: entity_store
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.14
 platform: ruby
 authors:
 - Adam Bird
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-25 00:00:00.000000000 Z
+date: 2014-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo