entity_store 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2fd6deacb63e070d4f7052598ccc5e79679d1052
-  data.tar.gz: 4c3fcfb0cae2e37aaa699c39a3730dda39d9f217
+  metadata.gz: c1bf9f57ff36a9e94b582cec4dd38d5364536455
+  data.tar.gz: 27b4160e5a19ee2e315a8a4f526e7bfd46f0c39b
 SHA512:
-  metadata.gz: 676503735ad66f25dd174831c840ac9ec2d42616783aeaed0c8ba37fe50c33c00cf1e227284d84d4e08e76de9280c0f7b094e990dbe445f7937e1975545de288
-  data.tar.gz: 00516945f8fd853b07c982c823da8e911d8fee23630ba2f0ab68d751f36c2f277225722ed1055b8e849eea3969b32d1bfe3d1642e90f9cf4b4d891571760e238
+  metadata.gz: 763f6f18705899dcf36b63b526a7dd97dd40896409401a2405a1609c3ea4f026c344c7f0e8d66af5d8e1f77c5558dc98da044346b598064c02233e3c01e5fbae
+  data.tar.gz: cb1c725e9c7befe55fe237510bc20a37ab4752c375e7395373489ddfd8064f28b31de00c9752c8c73f58a2bcea2e68b5d6071dc6a6dc6b453dd362da4929aaaf

data/lib/entity_store/store.rb

@@ -57,6 +57,10 @@ module EntityStore
       storage_client.remove_snapshots type
     end
 
+    def clear_entity_events(id, excluded_types = [])
+      storage_client.clear_entity_events(id, excluded_types)
+    end
+
     def add_events(entity)
       items = entity.pending_events.map do |event|
         event.entity_id = entity.id.to_s

data/lib/entity_store/version.rb

@@ -1,3 +1,3 @@
 module EntityStore
-  VERSION = "0.6.0".freeze
+  VERSION = "1.0.0".freeze
 end

data/lib/entity_store.rb

@@ -14,9 +14,6 @@ module EntityStore
   require_relative 'entity_store/event_bus'
   require_relative 'entity_store/not_found'
 
-  require_relative 'entity_store/mongo_entity_store'
-  require_relative 'entity_store/external_store'
-
   class << self
     def setup
       yield EntityStore::Config.setup

data/spec/entity_store/event_bus_spec.rb

@@ -23,6 +23,9 @@ class DummyAllSubscriber
   end
 end
 
+class DummyExternalStore
+end
+
 describe EventBus do
   before(:each) do
     @entity_type = random_string
@@ -68,7 +71,7 @@ describe EventBus do
 
   describe ".publish_to_feed" do
     before(:each) do
-      @feed_store = double(ExternalStore)
+      @feed_store = double(DummyExternalStore)
       @event_bus.stub(:feed_store) { @feed_store }
     end
 
@@ -87,7 +90,7 @@ describe EventBus do
       @subscriber = double("Subscriber", :dummy_event => true)
       DummySubscriber.stub(:new) { @subscriber }
 
-      @feed_store = double(ExternalStore)
+      @feed_store = double(DummyExternalStore)
       @id = random_object_id
       @feed_store.stub(:get_events) { |since| since == @id ? [] : [
         EventDataObject.new('_id' => @id, '_type' => DummyEvent.name, 'name' => random_string)

data/spec/entity_store_spec.rb

@@ -30,12 +30,60 @@ class DummyEntitySubscriber
   end
 end
 
+class DummyStore
+  def open
+  end
+
+  def entities
+    @entities ||= {}
+  end
+
+  def events
+    @events ||= {}
+  end
+
+  def add_entity(entity, id = BSON::ObjectId.new)
+    entities[id] = entity
+    id.to_s
+  end
+
+  def add_events(items)
+    items.each do |item|
+      events[item.entity_id] ||= []
+      events[item.entity_id] << item
+    end
+  end
+
+  def get_entities(ids, options={})
+    result = []
+    ids.each do |id|
+      if entity = entities[BSON::ObjectId.from_string(id)]
+        result << entity
+      end
+    end
+
+    result
+  end
+
+  def get_events(attrs)
+    result = {}
+
+    attrs.each do |attr|
+      result[attr[:id]] = events[attr[:id]]
+    end
+
+    result
+  end
+
+  def save_entity(entity)
+    entities[entity.id] = entity
+  end
+end
+
 describe "end to end" do
   before(:each) do
-    MongoEntityStore.connection_profile = "mongodb://localhost/entity_store_test"
-
     EntityStore::Config.setup do |config|
-      config.store = MongoEntityStore.new
+      config.store = DummyStore.new
       config.event_subscribers << DummyEntitySubscriber
     end
   end
@@ -55,4 +103,4 @@ describe "end to end" do
       EntityStore::Store.new.get(@entity.id).name.should eq(name)
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 require 'rake'
 require 'rspec'
-require 'mongo'
 require 'hatchet'
+require 'bson'
 
 require "#{Rake.application.original_dir}/lib/entity_store"
 

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: entity_store
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Adam Bird
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
+date: 2018-01-26 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: mongo
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.8'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: bson
   requirement: !ruby/object:Gem::Requirement
@@ -66,10 +52,8 @@ files:
 - lib/entity_store/event.rb
 - lib/entity_store/event_bus.rb
 - lib/entity_store/event_data_object.rb
-- lib/entity_store/external_store.rb
 - lib/entity_store/hash_serialization.rb
 - lib/entity_store/logging.rb
-- lib/entity_store/mongo_entity_store.rb
 - lib/entity_store/not_found.rb
 - lib/entity_store/store.rb
 - lib/entity_store/time_factory.rb
@@ -81,8 +65,6 @@ files:
 - spec/entity_store/entity_value_spec.rb
 - spec/entity_store/event_bus_spec.rb
 - spec/entity_store/event_spec.rb
-- spec/entity_store/external_store_spec.rb
-- spec/entity_store/mongo_entity_store_spec.rb
 - spec/entity_store/store_spec.rb
 - spec/entity_store_spec.rb
 - spec/spec_helper.rb
@@ -106,18 +88,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Event sourced entity store with a replaceable body
 test_files:
+- spec/spec_helper.rb
+- spec/entity_store_spec.rb
+- spec/entity_store/entity_value_spec.rb
 - spec/entity_store/config_spec.rb
 - spec/entity_store/entity_spec.rb
-- spec/entity_store/entity_value_spec.rb
-- spec/entity_store/event_bus_spec.rb
 - spec/entity_store/event_spec.rb
-- spec/entity_store/external_store_spec.rb
-- spec/entity_store/mongo_entity_store_spec.rb
+- spec/entity_store/event_bus_spec.rb
 - spec/entity_store/store_spec.rb
-- spec/entity_store_spec.rb
-- spec/spec_helper.rb

data/lib/entity_store/external_store.rb

@@ -1,62 +0,0 @@
-require 'mongo'
-require 'uri'
-
-module EntityStore
-  class ExternalStore
-    include Mongo
-
-    class << self
-      attr_accessor :connection_profile
-      attr_writer :connect_timeout
-
-      def connection
-        @_connection ||= Mongo::MongoClient.from_uri(ExternalStore.connection_profile, :connect_timeout => EntityStore::Config.connect_timeout)
-      end
-
-      def database
-        @_database ||= ExternalStore.connection_profile.split('/').last
-      end
-    end
-
-    def open
-      ExternalStore.connection.db(ExternalStore.database)
-    end
-    
-    def collection
-      @_collection ||= open['events']
-    end
-    
-    def ensure_indexes
-      collection.ensure_index([['_type', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])      
-    end
-    
-    def add_event(entity_type, event)
-      collection.insert({
-        '_entity_type' => entity_type, '_type' => event.class.name 
-        }.merge(event.attributes)
-      )
-    end
-    
-    # Public - get events since a Time or ID
-    # 
-    # since         - Time or String id to filter events from 
-    # type          - String optionally filter the event type to return (default=nil)
-    # max_items     - Fixnum max items to return (default=100)
-    # 
-    # Returns Enumerable EventDataObject
-    def get_events(since, type=nil, max_items=100)
-      since_id = since.is_a?(Time) ? BSON::ObjectId.from_time(since) : BSON::ObjectId.from_string(since)
-
-      query = { '_id' => { '$gt' => since_id } }
-      query['_type'] = type if type
-      
-      options = {
-        :sort => [['_id', Mongo::ASCENDING]],
-        :limit => max_items
-      }
-      
-      collection.find(query, options).collect { |e| EventDataObject.new(e)}
-    end
-    
-  end
-end

data/lib/entity_store/mongo_entity_store.rb

@@ -1,196 +0,0 @@
-require 'mongo'
-require 'uri'
-
-module EntityStore
-  class MongoEntityStore
-    include Mongo
-    include Logging
-
-    class << self
-      attr_accessor :connection_profile
-      attr_writer :connect_timeout
-
-      def connection
-        @_connection ||= Mongo::MongoClient.from_uri(MongoEntityStore.connection_profile, :connect_timeout => EntityStore::Config.connect_timeout, :refresh_mode => :sync)
-      end
-
-      def database
-        @_database ||= MongoEntityStore.connection_profile.split('/').last.split('?').first
-      end
-    end
-
-    def open
-      MongoEntityStore.connection.db(MongoEntityStore.database)
-    end
-
-    def entities
-      @entities_collection ||= open['entities']
-    end
-
-    def events
-      @events_collection ||= open['entity_events']
-    end
-
-    def clear
-      entities.drop
-      @entities_collection = nil
-      events.drop
-      @events_collection = nil
-    end
-
-    def ensure_indexes
-      events.ensure_index([['_entity_id', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])
-      events.ensure_index([['_entity_id', Mongo::ASCENDING], ['entity_version', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]])
-    end
-
-    def add_entity(entity, id = BSON::ObjectId.new)
-      entities.insert('_id' => id, '_type' => entity.class.name, 'version' => entity.version).to_s
-    end
-
-    def save_entity(entity)
-      entities.update({'_id' => BSON::ObjectId.from_string(entity.id)}, { '$set' => { 'version' => entity.version } })
-    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
-      entities.update(query, { '$unset' => { 'snapshot' => 1 } }, { multi: true })
-    end
-
-    def add_events(items)
-      events_with_id = items.map { |e| [ BSON::ObjectId.new, e ] }
-      add_events_with_ids(events_with_id)
-    end
-
-    def add_events_with_ids(event_id_map)
-      docs = event_id_map.map do |id, event|
-        {
-          '_id' => id,
-          '_type' => event.class.name,
-          '_entity_id' => BSON::ObjectId.from_string(event.entity_id)
-        }.merge(event.attributes)
-      end
-
-      events.insert(docs)
-    end
-
-    # Public: loads the entity from the store, including any available snapshots
-    # then loads the events to complete the state
-    #
-    # ids           - Array of Strings representation of BSON::ObjectId
-    # options       - Hash of options (default: {})
-    #                 :raise_exception - Boolean (default: true)
-    #
-    # Returns an array of entities
-    def get_entities(ids, options={})
-
-      object_ids = ids.map do |id|
-        begin
-          BSON::ObjectId.from_string(id)
-        rescue BSON::InvalidObjectId
-          raise NotFound.new(id) if options.fetch(:raise_exception, true)
-          nil
-        end
-      end
-
-      entities.find('_id' => { '$in' => object_ids }).map do |attrs|
-        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' => attrs['_id'].to_s })
-        rescue => e
-          log_error "Error loading type #{attrs['_type']}", e
-          raise
-        end
-
-        entity
-      end
-
-    end
-
-    # Public:  get events for an array of criteria objects
-    #           because each entity could have a different reference
-    #           version this allows optional criteria to be specifed
-    #
-    #
-    # criteria  - Hash :id mandatory, :since_version optional
-    #
-    # Examples
-    #
-    # get_events_for_criteria([ { id: "23232323"}, { id: "2398429834", since_version: 4 } ] )
-    #
-    # Returns Hash with id as key and Array of Event instances as value
-    def get_events(criteria)
-      return {} if criteria.empty?
-
-      query_items = criteria.map do |item|
-        raise ArgumentError.new(":id missing from criteria") unless item[:id]
-        item_query = { '_entity_id' => BSON::ObjectId.from_string(item[:id]) }
-        item_query['entity_version'] = { '$gt' => item[:since_version] } if item[:since_version]
-        item_query
-      end
-
-      query = { '$or' => query_items }
-
-      result = Hash[ criteria.map { |item| [ item[:id], [] ] } ]
-
-      events.find(query).each do |attrs|
-        result[attrs['_entity_id'].to_s] << attrs
-      end
-
-      result.each do |id, events|
-        # Have to do the sort client side as otherwise the query will not use
-        # indexes (http://docs.mongodb.org/manual/reference/operator/query/or/#or-and-sort-operations)
-        events.sort_by! { |attrs| [attrs['entity_version'], attrs['_id'].to_s] }
-
-        # Convert the attributes into event objects
-        events.map! do |attrs|
-          begin
-            EntityStore::Config.load_type(attrs['_type']).new(attrs)
-          rescue => e
-            log_error "Error loading type #{attrs['_type']}", e
-            nil
-          end
-        end
-
-        events.compact!
-      end
-
-      result
-    end
-  end
-end

data/spec/entity_store/external_store_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-class DummyEvent
-  include Event
-  attr_accessor :name
-end
-
-class DummyEventTwo
-  include Event
-  attr_accessor :name
-end
-
-describe ExternalStore do
-  before(:each) do
-    ExternalStore.connection_profile = "mongodb://localhost/external_store_default"
-    ExternalStore.new.collection.drop
-    @store = ExternalStore.new
-  end
-  describe "#add_event" do
-    before(:each) do
-      @entity_type = random_string
-      @event = DummyEvent.new(:name => random_string, :entity_id => random_object_id)
-    end
-    
-    subject { @store.add_event(@entity_type, @event) }
-    
-    it "creates a record in the collection" do
-      subject
-      item = @store.collection.find_one
-      item['_entity_type'].should eq(@entity_type)
-      item['_type'].should eq(@event.class.name)
-      item['name'].should eq(@event.name)
-      item['entity_id'].should eq(@event.entity_id)
-    end
-  end
-  
-  describe "#get_events" do
-    before(:each) do
-      @reference_time = Time.now
-      @ids = (-2..2).collect { |i| BSON::ObjectId.from_time(@reference_time + i) }
-
-      @store.collection.insert({'_id' => @ids[0], '_type' => 'DummyEvent'})
-      @store.collection.insert({'_id' => @ids[1], '_type' => 'DummyEventTwo'})
-      @store.collection.insert({'_id' => @ids[2], '_type' => 'DummyEvent'})
-      @store.collection.insert({'_id' => @ids[3], '_type' => 'DummyEventTwo'})
-      @store.collection.insert({'_id' => @ids[4], '_type' => 'DummyEvent'})
-    end
-       
-    subject { @store.get_events @since, @type }
-
-    context "when time passed as since" do
-      before(:each) do
-        @since = @reference_time
-      end
-      context "when no type filter" do
-        before(:each) do
-          @type = nil
-          @results = subject
-        end
-        it "returns two records" do
-          @results.count.should eq(2)
-        end
-        it "it returns the 4th item first" do
-          @results.first.id.should eq(@ids[3].to_s)
-        end
-        it "it returns the 5th item second" do
-          @results[1].id.should eq(@ids[4].to_s)
-        end
-      end
-      context "when type filter 'DummyEventTwo' passed" do
-        before(:each) do
-          @type = "DummyEventTwo"
-          @results = subject
-        end
-        it "returns 1 record" do
-          @results.count.should eq(1)
-        end
-        it "returns the 4th item" do
-          @results.first.id.should eq(@ids[3].to_s)
-        end
-      end
-    end
-
-    context "when id passed as since" do
-      before(:each) do
-        @since = @ids[1].to_s
-      end
-      context "when no type filter passed" do
-        before(:each) do
-          @type = nil
-          @results = subject
-        end
-        it "returns 3 records" do
-          @results.count.should eq(3)
-        end
-        it "it returns the 3rd item first" do
-          @results.first.id.should eq(@ids[2].to_s)
-        end
-        it "it returns the 4th item second" do
-          @results[1].id.should eq(@ids[3].to_s)
-        end
-        it "it returns the 5th item second" do
-          @results[2].id.should eq(@ids[4].to_s)
-        end
-      end
-      context "when type filter 'DummyEvent' passed" do
-        before(:each) do
-          @type = "DummyEvent"
-          @results = subject
-        end
-        it "returns 2 records" do
-          @results.count.should eq(2)
-        end
-        it "returns the 3rd item" do
-          @results.first.id.should eq(@ids[2].to_s)
-        end
-        it "returns the 5th item" do
-          @results[1].id.should eq(@ids[4].to_s)
-        end
-      end
-    end
-  end
-
-end

data/spec/entity_store/mongo_entity_store_spec.rb

@@ -1,200 +0,0 @@
-require 'spec_helper'
-
-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
-
-  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"
-    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 => 2, :name => random_string) }
-    let(:unrelated_event) { DummyEntityNameSet.new(:entity_id => random_object_id, :entity_version => 4, :name => random_string) }
-    let(:fourth_event)    { DummyEntityNameSet.new(:entity_id => entity_id, :entity_version => 3, :name => random_string) }
-
-    before do
-      store.add_events([ second_event, unrelated_event, first_event, third_event, fourth_event ])
-    end
-
-    subject { store.get_events( [{ id: event_entity_id, since_version: since_version }])[event_entity_id] }
-
-    context "all events" do
-      let(:event_entity_id) { entity_id }
-      let(:since_version) { 0 }
-
-      it "should return the four events in order" do
-        subject.should == [first_event, second_event, third_event, fourth_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 == [ fourth_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_entities" do
-    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
-
-    let(:id) { saved_entity.id }
-    let(:options) { { } }
-
-    subject { store.get_entities( [ id ], options) }
-
-    it "should retrieve an entity from the store with the same ID" do
-      subject.first.id.should == saved_entity.id
-    end
-
-    it "should retrieve an entity from the store with the same class" do
-      subject.first.class.should == saved_entity.class
-    end
-
-    it "should have the same version" do
-      subject.first.version.should == saved_entity.version
-    end
-
-    context "when a snapshot does not exist" do
-      it "should not have set the name" do
-        subject.first.name.should be_nil
-      end
-    end
-
-    context "when a snapshot exists" do
-      before do
-        saved_entity.version = 10
-        store.snapshot_entity(saved_entity)
-      end
-
-      context "when a snapshot key not in use" do
-        it "should have set the name" do
-          subject.first.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.first.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.first.name.should be_nil
-          end
-        end
-      end
-    end
-
-    describe "context when enable exceptions" do
-      let(:options) do
-        { raise_exception: true }
-      end
-
-      context "when invalid id format passed" do
-        let(:id) { random_string }
-
-        it "should raise not found" do
-          expect { subject }.to raise_error(NotFound)
-        end
-      end
-    end
-
-  end
-
-  describe "#snapshot_entity" do
-    let(:entity_class) { DummyEntity }
-
-    let(:entity) do
-      entity_class.new(:id => random_object_id, :version => random_integer, :name => random_string)
-    end
-
-    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
-      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