nexia_event_store 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17ccc001ca06cb2c0fdc059a29a30f63e00f028b
-  data.tar.gz: 8b3538b01bb2cb879905c4edd13dc92f708c4d8e
+  metadata.gz: f2dba3805be9987a863b9c80cad063ff5ce6ecd2
+  data.tar.gz: 735780ad87bad4795370e51bcf22b71f85184e51
 SHA512:
-  metadata.gz: 837398a20abc3b289698d61711da897da5824ceb384a4fdcd21b5143ad11f8a71552567c81d1202c643e1bf95a9178119027602d7a18a744e2352ed63c5023ec
-  data.tar.gz: 58671b2fe871f9664ddd1153528c27c55063b4665d8fccae638f62a191e8c6e86b31ed98047e1b2728013958e4e56acc1eb8ad19815eda2aa2d4edbff1875aea
+  metadata.gz: 2b3aac7d78671e3b9ffd7c136d88ebded20358121fdf9759762cdd846e697325972725e1183a570412e475fe7fbed5bc3fd9768e885037efb1cf848e122f9ad5
+  data.tar.gz: 4da1989af164abf4802e5e963491fd68a2da8993154f568107ed8e02d0e8f1e88b4a576371032ee787c16906151a89fa0fabef2e3d94286c69c9d21343d79ddd

data/lib/event_store/snapshot.rb

@@ -41,12 +41,7 @@ module EventStore
 
       t = Time.now
       result_hash = events_hash.inject([]) do |snapshot, (key, value)|
-        fully_qualified_name, _ = key.split(EventStore::SNAPSHOT_KEY_DELIMITER)
-        raw_event               = value.split(EventStore::SNAPSHOT_DELIMITER)
-        event_id                = raw_event.first.to_i
-        serialized_event        = EventStore.unescape_bytea(raw_event[1])
-        occurred_at             = Time.parse(raw_event.last)
-        snapshot + [SerializedEvent.new(fully_qualified_name, serialized_event, event_id, occurred_at)]
+        snapshot + [serialized_event_from_snapshot_event(key, value)]
       end
       logger.debug { "#{self.class.name} serializing events took #{Time.now - t} seconds" }
       result_hash.sort_by(&:event_id).each { |e| yield e }
@@ -99,16 +94,47 @@ module EventStore
     end
 
     def update_fqns!(logger = default_logger)
-      updated_events    = replace_fqns_in_snapshot_hash(read_with_rebuild(logger)) { |fqn| yield fqn }
+      logger.debug { "Replacing FQNs in snapshot events" }
+      updated_events = replace_fqns_in_snapshot_hash(read_with_rebuild(logger)) { |fqn| yield fqn }
+
+      logger.debug { "Replacing FQNs in snapshot event ids" }
       updated_event_ids = replace_fqns_in_snapshot_hash(current_event_id_numbers)  { |fqn|
         fqn == 'current_event_id' ? fqn : (yield fqn)
       }
 
-      update_snapshot_tables(updated_event_ids, updated_events, replace: true)
+      logger.debug "Updating snapshot tables in redis"
+      replace_snapshot_tables(updated_event_ids, updated_events)
+    end
+
+    def reject!(logger = default_logger)
+      events_to_keep = read_with_rebuild(logger)
+      event_ids = current_event_id_numbers
+
+      events_to_keep.dup.each { |snapshot_key, snapshot_event|
+        serialized_event = serialized_event_from_snapshot_event(snapshot_key, snapshot_event)
+        drop_it = yield serialized_event
+
+        if drop_it
+          events_to_keep.delete(snapshot_key)
+          event_ids.delete(snapshot_key)
+        end
+      }
+
+      replace_snapshot_tables(event_ids.flatten, events_to_keep.flatten)
     end
 
   private
 
+    def serialized_event_from_snapshot_event(snapshot_key, snapshot_value)
+      fully_qualified_name, _ = snapshot_key.split(EventStore::SNAPSHOT_KEY_DELIMITER)
+      raw_event               = snapshot_value.split(EventStore::SNAPSHOT_DELIMITER)
+      event_id                = raw_event.first.to_i
+      serialized_event        = EventStore.unescape_bytea(raw_event[1])
+      occurred_at             = Time.parse(raw_event.last)
+
+      SerializedEvent.new(fully_qualified_name, serialized_event, event_id, occurred_at)
+    end
+
     def replace_fqns_in_snapshot_hash(snapshot_keyed_hash)
       snapshot_keyed_hash.inject([]) { |memo, (snapshot_key, value)|
         new_key = replace_fqn_in_snapshot_key(snapshot_key) { |fqn| yield fqn }
@@ -122,16 +148,21 @@ module EventStore
       [new_fqn, sub_key].compact.join(EventStore::SNAPSHOT_KEY_DELIMITER)
     end
 
-    # params are flattened hashes, i.e., [key1, val1, key2, val2, ...]
-    def update_snapshot_tables(event_ids_array, events_array, replace: false)
+    def replace_snapshot_tables(event_ids_array, events_array)
       @redis.multi do
-        @redis.del snapshot_event_id_table if replace
-        @redis.hmset(snapshot_event_id_table, event_ids_array)
-        @redis.del snapshot_table if replace
-        @redis.hmset(snapshot_table, events_array)
+        delete_snapshot!
+        update_snapshot_tables(event_ids_array, events_array)
       end
     end
 
+    # params are flattened hashes, i.e., [key1, val1, key2, val2, ...]
+    def update_snapshot_tables(event_ids_array, events_array)
+      return unless events_array.any?
+
+      @redis.hmset(snapshot_event_id_table, event_ids_array)
+      @redis.hmset(snapshot_table, events_array)
+    end
+
     def default_logger
       Logger.new('/dev/null')
     end

data/lib/event_store/version.rb

@@ -1,3 +1,3 @@
 module EventStore
-  VERSION = '0.9.1'
+  VERSION = '0.10.0'
 end

data/spec/event_store/snapshot_spec.rb

@@ -23,66 +23,110 @@ module EventStore
     end
 
     context "with events in the stream" do
-      let(:client)    { EventStore::Client.new(AGGREGATE_ID_TWO) }
+      let(:client)   { EventStore::Client.new(AGGREGATE_ID_TWO) }
+      let(:snapshot) { client.snapshot }
+      let(:events)   { events_for(AGGREGATE_ID_TWO) }
 
-      before do
-        expect(client.snapshot.count).to eq(0)
-        client.append events_for(AGGREGATE_ID_TWO)
-      end
+      before {
+        expect(snapshot.count).to eq(0)
+        client.append events
+      }
 
       describe "#count" do
         it "delegates to the snapshot hash" do
-          expect(client.snapshot.count).to eq(8)
+          expect(snapshot.count).to eq(8)
         end
       end
 
       describe "#update_fqns!" do
-        let(:original_events)  { client.snapshot.to_a }
+        let(:original_events)  { snapshot.to_a }
 
         it "replaces fully qualified names in the snapshot with the value of a block" do
-          client.snapshot.update_fqns! { |fqn|
+          snapshot.update_fqns! { |fqn|
             fqn =~ /^(e[0-9])/ ? fqn.upcase : fqn
           }
 
           expected_snapshot_events = original_events.map { |serialized_event| serialized_event.fully_qualified_name.upcase }
-          expect(client.snapshot.map(&:fully_qualified_name).to_set).to eq(expected_snapshot_events.to_set)
+          expect(snapshot.map(&:fully_qualified_name).to_set).to eq(expected_snapshot_events.to_set)
         end
 
         it "does not affect the current event id" do
-          old_event_id = client.snapshot.event_id
+          old_event_id = snapshot.event_id
 
-          client.snapshot.update_fqns! { |fqn| fqn.upcase }
+          snapshot.update_fqns! { |fqn| fqn.upcase }
 
-          new_event_id = client.snapshot.event_id
+          new_event_id = snapshot.event_id
 
           expect(new_event_id).to eq(old_event_id)
         end
 
         it "doesn't affect the fully qualified name when the block returns nil" do
           old_fqns = original_events.map(&:fully_qualified_name)
-          client.snapshot.update_fqns! { |_fqn| nil }
+          snapshot.update_fqns! { |_fqn| nil }
+
+          expect(snapshot.map(&:fully_qualified_name).to_set).to eq(old_fqns.to_set)
+        end
+      end
+
+      describe "#reject!" do
+        it "yields the serialized event to the block" do
+          snapshot.reject! { |serialized_event|
+            expect(events.map(&:fully_qualified_name)).to include(serialized_event.fully_qualified_name)
+            expect(events.map(&:serialized_event)).to include(serialized_event.serialized_event)
+          }
+        end
+
+        context "when the block returns true" do
+          before(:each) { snapshot.reject! { |serialized_event| serialized_event.fully_qualified_name == 'e1' } }
+
+          it "removes the event from the snapshot" do
+            expect(snapshot.map(&:fully_qualified_name)).not_to include('e1')
+          end
+
+          it "removes the event id from the snapshot" do
+            expect(snapshot.event_id_for('e1')).to eq(-1)
+          end
+        end
+
+        context "when the block returns false" do
+          before(:each) { snapshot.reject! { |serialized_event| serialized_event.fully_qualified_name != 'e1' } }
+
+          it "retains the event in the snapshot" do
+            expect(snapshot.map(&:fully_qualified_name)).to include('e1')
+          end
+
+          it "retains the event id in the snapshot" do
+            expect(snapshot.event_id_for('e1')).not_to eq(-1)
+          end
+        end
+
+        context "when all events are rejected" do
+          before(:each) { snapshot.reject! { true } }
 
-          expect(client.snapshot.map(&:fully_qualified_name).to_set).to eq(old_fqns.to_set)
+          it "deletes the snapshot out of Redis" do
+            expect(EventStore.redis.keys(snapshot.snapshot_table).length).to eq(0)
+            expect(EventStore.redis.keys(snapshot.snapshot_event_id_table).length).to eq(0)
+          end
         end
       end
 
       it "rebuilds a snapshot after it is deleted" do
-        snapshot = client.snapshot
+        snapshot = snapshot
         client.delete_snapshot!
         client.rebuild_snapshot!
-        expect(client.snapshot).to eq(snapshot)
+        expect(snapshot).to eq(snapshot)
       end
 
       it "automatically rebuilds the snapshot if events exist, but the snapshot is empty" do
-        snapshot = client.snapshot
+        snapshot = snapshot
         client.delete_snapshot!
-        expect(client.snapshot).to eq(snapshot)
+        expect(snapshot).to eq(snapshot)
       end
 
       it "finds the most recent records for each type" do
         expected_snapshot_events = %w{e3 e1 e2 e5 e4 e7 e8 e7} #sorted by version no
         expected_snapshot = serialized_events(expected_snapshot_events)
-        actual_snapshot = client.snapshot
+        actual_snapshot = snapshot
 
         expect(client.event_stream.count).to eq(15)
         expect(actual_snapshot.map(&:fully_qualified_name)).to eq(expected_snapshot_events)
@@ -91,7 +135,7 @@ module EventStore
       end
 
       it "increments the version number of the snapshot when an event is appended" do
-        expect(client.snapshot.event_id).to eq(client.raw_event_stream.last[:id])
+        expect(snapshot.event_id).to eq(client.raw_event_stream.last[:id])
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexia_event_store
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Paul Saieg, John Colvin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-16 00:00:00.000000000 Z
+date: 2016-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler