nexia_event_store 0.2.11 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dafb7ab4736d45906755a4126e7e6ace40bbb465
-  data.tar.gz: 77acaa03589add54ed164de75a59ac1214321ef6
+  metadata.gz: 8ca406d692ca12cea54e8e03cd222f28c3baf20a
+  data.tar.gz: 8d4d4206228a30c96f0b16df727cacb2daa80f21
 SHA512:
-  metadata.gz: c7a2b2a900507663b616b0ec80be72b3d3098cb327ab0a80973c5d3fb941fcdbc307d885f861f7ee089480fa68d36ce50420898033d179217d3f3b7f3701ff38
-  data.tar.gz: ab25dc86a6bc356bc6d6e78378e82ee6040fe25a89f66ba8b8abfdee32971ca4f6e8501cdc97b51a447fc67cf9e7bf2c84e205b723e36f60d3bd7b5d5c9c1d29
+  metadata.gz: 86744d003f7c506b25f84cb1318610a99ba79528e5eec47b013bf38c90a940004834b9baf0dc368b1c444402e41be10bca074124c28d21d1fb7d9f2840ecdb03
+  data.tar.gz: f01ac30941112234b5b841a8596146657bb7f5ace7a49fc41d100160a32bb40330e96910edea882d28234e4d72a7b8730f825bff33e54c1c8446e2d95aff353f

data/db/pg_migrations/002_create_event_store_events.rb

@@ -0,0 +1,8 @@
+require 'event_store'
+Sequel.migration do
+  change do
+    alter_table((EventStore.schema + "__" + EventStore.table_name).to_sym) do
+      add_column :sub_key, String
+    end
+  end
+end

data/lib/event_store/aggregate.rb

@@ -1,7 +1,26 @@
+require 'forwardable'
+
 module EventStore
   class Aggregate
-
-    attr_reader :id, :type, :snapshot_table, :snapshot_version_table, :event_table
+    extend Forwardable
+
+    attr_reader :id, :type, :event_table
+
+    def_delegators :@snapshot,
+      :last_event,
+      :snapshot,
+      :rebuild_snapshot!,
+      :delete_snapshot!,
+      :version,
+      :snapshot_version_table
+
+    def_delegators :@event_stream,
+      :events,
+      :events_from,
+      :event_stream,
+      :event_stream_between,
+      :event_table,
+      :delete_events!
 
     def self.count
       EventStore.db.from( EventStore.fully_qualified_table).distinct(:aggregate_id).count
@@ -14,80 +33,16 @@ module EventStore
     def initialize(id, type = EventStore.table_name)
       @id = id
       @type = type
-      @schema = EventStore.schema
-      @event_table = EventStore.fully_qualified_table
-      @snapshot_table = "#{@type}_snapshots_for_#{@id}"
-      @snapshot_version_table = "#{@type}_snapshot_versions_for_#{@id}"
-    end
-
-    def events
-      @events_query ||= EventStore.db.from(@event_table).where(:aggregate_id => @id.to_s).order(:version)
-    end
-
-    def snapshot
-      events_hash = auto_rebuild_snapshot(read_raw_snapshot)
-      snap = []
-      events_hash.each_pair do |key, value|
-        raw_event            = value.split(EventStore::SNAPSHOT_DELIMITER)
-        fully_qualified_name = key
-        version              = raw_event.first.to_i
-        serialized_event     = EventStore.unescape_bytea(raw_event[1])
-        occurred_at          = Time.parse(raw_event.last)
-        snap << SerializedEvent.new(fully_qualified_name, serialized_event, version, occurred_at)
-      end
-      snap.sort {|a,b| a.version <=> b.version}
-    end
 
-    def rebuild_snapshot!
-      delete_snapshot!
-      corrected_events = events.all.map{|e| e[:occurred_at] = TimeHacker.translate_occurred_at_from_local_to_gmt(e[:occurred_at]); e}
-      EventAppender.new(self).store_snapshot(corrected_events)
+      @snapshot     = Snapshot.new(self)
+      @event_stream = EventStream.new(self)
     end
 
-    def events_from(version_number, max = nil)
-      events.limit(max).where{ version >= version_number.to_i }.all.map do |event|
-        event[:serialized_event] = EventStore.unescape_bytea(event[:serialized_event])
-        event
+    def append(events)
+      @event_stream.append(events) do |prepared_events|
+        @snapshot.store_snapshot(prepared_events)
       end
     end
 
-    def event_stream_between(start_time, end_time, fully_qualified_names = [])
-      query = events.where(occurred_at: start_time..end_time)
-      query = query.where(fully_qualified_name: fully_qualified_names) if fully_qualified_names && fully_qualified_names.any?
-      query.all.map {|e| e[:serialized_event] = EventStore.unescape_bytea(e[:serialized_event]); e}
-    end
-
-    def event_stream
-      events.all.map {|e| e[:serialized_event] = EventStore.unescape_bytea(e[:serialized_event]); e}
-    end
-
-    def last_event
-      snapshot.last
-    end
-
-    def version
-      (EventStore.redis.hget(@snapshot_version_table, :current_version) || -1).to_i
-    end
-
-    def delete_snapshot!
-      EventStore.redis.del [@snapshot_table, @snapshot_version_table]
-    end
-
-    def delete_events!
-      events.delete
-    end
-
-  private
-    def auto_rebuild_snapshot(events_hash)
-      return events_hash unless events_hash.empty?
-      event = events.select(:version).limit(1).all
-      return events_hash if event.nil?
-      rebuild_snapshot!
-      events_hash = read_raw_snapshot
-    end
-
-    def read_raw_snapshot
-      EventStore.redis.hgetall(@snapshot_table)
-    end
   end
 end

data/lib/event_store/client.rb

@@ -1,5 +1,8 @@
 module EventStore
   class Client
+    extend Forwardable
+
+    def_delegators :@aggregate, :delete_snapshot!, :snapshot_version_table
 
     def self.count
       Aggregate.count
@@ -9,7 +12,7 @@ module EventStore
       Aggregate.ids(offset, limit)
     end
 
-    def initialize( aggregate_id, aggregate_type = EventStore.table_name)
+    def initialize(aggregate_id, aggregate_type = EventStore.table_name)
       @aggregate = Aggregate.new(aggregate_id, aggregate_type)
     end
 
@@ -25,8 +28,8 @@ module EventStore
       @aggregate.event_table
     end
 
-    def append event_data
-      event_appender.append(event_data)
+    def append(event_data)
+      @aggregate.append(event_data)
       yield(event_data) if block_given?
       nil
     end
@@ -36,19 +39,19 @@ module EventStore
     end
 
     def event_stream
-      translate_events raw_event_stream
+      translate_events(raw_event_stream)
     end
 
-    def event_stream_from version_number, max=nil
-      translate_events @aggregate.events_from(version_number, max)
+    def event_stream_from(version_number, max=nil)
+      translate_events(@aggregate.events_from(version_number, max))
     end
 
     def event_stream_between(start_time, end_time, fully_qualified_names = [])
-      translate_events @aggregate.event_stream_between(start_time, end_time, fully_qualified_names)
+      translate_events(@aggregate.event_stream_between(start_time, end_time, fully_qualified_names))
     end
 
     def peek
-      translate_event @aggregate.last_event
+      translate_event(@aggregate.last_event)
     end
 
     def raw_snapshot
@@ -83,10 +86,6 @@ module EventStore
 
     private
 
-    def event_appender
-      EventAppender.new(@aggregate)
-    end
-
     def translate_events(event_hashs)
       event_hashs.map { |eh| translate_event(eh) }
     end

data/lib/event_store/event_stream.rb

@@ -0,0 +1,81 @@
+module EventStore
+  class EventStream
+
+    attr_reader :event_table
+
+    def initialize aggregate
+      @aggregate = aggregate
+      @id = @aggregate.id
+      @event_table = EventStore.fully_qualified_table
+    end
+
+    def append(raw_events)
+      EventStore.db.transaction do
+        next_version = last_version + 1
+
+        prepared_events = raw_events.map do |raw_event|
+          event = prepare_event(raw_event, next_version)
+          next_version += 1
+          ensure_all_attributes_have_values!(event)
+          event
+        end
+
+        events.multi_insert(prepared_events)
+
+        yield(prepared_events) if block_given?
+      end
+    end
+
+    def events
+      @events_query ||= EventStore.db.from(@event_table).where(:aggregate_id => @id.to_s).order(:version)
+    end
+
+    def events_from(version_number, max = nil)
+      events.limit(max).where{ version >= version_number.to_i }.all.map do |event|
+        event[:serialized_event] = EventStore.unescape_bytea(event[:serialized_event])
+        event
+      end
+    end
+
+    def event_stream_between(start_time, end_time, fully_qualified_names = [])
+      query = events.where(occurred_at: start_time..end_time)
+      query = query.where(fully_qualified_name: fully_qualified_names) if fully_qualified_names && fully_qualified_names.any?
+      query.all.map {|e| e[:serialized_event] = EventStore.unescape_bytea(e[:serialized_event]); e}
+    end
+
+    def event_stream
+      events.all.map {|e| e[:serialized_event] = EventStore.unescape_bytea(e[:serialized_event]); e}
+    end
+
+    def delete_events!
+      events.delete
+    end
+
+  private
+
+    def prepare_event(raw_event, version_number)
+      raise ArgumentError.new("Cannot Append a Nil Event") unless raw_event
+      { :version              => version_number,
+        :aggregate_id         => raw_event.aggregate_id,
+        :occurred_at          => Time.parse(raw_event.occurred_at.to_s).utc, #to_s truncates microseconds, which brake Time equality
+        :serialized_event     => EventStore.escape_bytea(raw_event.serialized_event),
+        :fully_qualified_name => raw_event.fully_qualified_name,
+        :sub_key              => raw_event.sub_key
+      }
+    end
+
+    def ensure_all_attributes_have_values!(event_hash)
+      [:aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event, :version].each do |attribute_name|
+        if event_hash[attribute_name].to_s.strip.empty?
+          raise AttributeMissingError, "value required for #{attribute_name}"
+        end
+      end
+    end
+
+    def last_version
+      last = events.last
+      last && last[:version] || -1
+    end
+
+  end
+end

data/lib/event_store/snapshot.rb

@@ -0,0 +1,111 @@
+module EventStore
+  class Snapshot
+
+    attr_reader :snapshot_version_table
+
+    def initialize aggregate
+      @aggregate = aggregate
+      @redis = EventStore.redis
+      @snapshot_table = "#{@aggregate.type}_snapshots_for_#{@aggregate.id}"
+      @snapshot_version_table = "#{@aggregate.type}_snapshot_versions_for_#{@aggregate.id}"
+    end
+
+    def last_event
+      snapshot.last
+    end
+
+    def version
+      (@redis.hget(@snapshot_version_table, :current_version) || -1).to_i
+    end
+
+    def snapshot
+      events_hash = auto_rebuild_snapshot(read_raw_snapshot)
+      snap = []
+      events_hash.each_pair do |key, value|
+        fully_qualified_name, _ = key.split(EventStore::SNAPSHOT_KEY_DELIMITER)
+        raw_event               = value.split(EventStore::SNAPSHOT_DELIMITER)
+        version                 = raw_event.first.to_i
+        serialized_event        = EventStore.unescape_bytea(raw_event[1])
+        occurred_at             = Time.parse(raw_event.last)
+        snap << SerializedEvent.new(fully_qualified_name, serialized_event, version, occurred_at)
+      end
+      snap.sort {|a,b| a.version <=> b.version}
+    end
+
+    def rebuild_snapshot!
+      delete_snapshot!
+      corrected_events = @aggregate.events.all.map{|e| e[:occurred_at] = TimeHacker.translate_occurred_at_from_local_to_gmt(e[:occurred_at]); e}
+      store_snapshot(corrected_events)
+    end
+
+    def delete_snapshot!
+      EventStore.redis.del [@snapshot_table, @snapshot_version_table]
+    end
+
+    def store_snapshot(prepared_events)
+      valid_snapshot_events = []
+      valid_snapshot_versions = []
+
+      prepared_events.each do |event_hash|
+        if event_hash[:version].to_i > current_version_numbers[snapshot_key(event_hash)].to_i
+          valid_snapshot_events   += snapshot_event(event_hash)
+          valid_snapshot_versions += snapshot_version(event_hash)
+        end
+      end
+
+      unless valid_snapshot_versions.empty?
+        valid_snapshot_versions += [:current_version, valid_snapshot_versions.last.to_i]
+
+        @redis.multi do
+          @redis.hmset(@snapshot_version_table, valid_snapshot_versions)
+          @redis.hmset(@snapshot_table, valid_snapshot_events)
+        end
+      end
+    end
+
+  private
+
+    def snapshot_key(event)
+      [event[:fully_qualified_name], event[:sub_key] || EventStore::NO_ZONE].join(EventStore::SNAPSHOT_KEY_DELIMITER)
+    end
+
+    def snapshot_event(event)
+      [
+        snapshot_key(event),
+        [ event[:version].to_s,
+          event[:serialized_event],
+          event[:occurred_at].to_s
+        ].join(EventStore::SNAPSHOT_DELIMITER)
+      ]
+    end
+
+    def snapshot_version(event)
+      [
+        snapshot_key(event),
+        event[:version]
+      ]
+    end
+
+    def current_version_numbers
+      current_versions = @redis.hgetall(@snapshot_version_table)
+      current_versions.default = -1
+      current_versions
+    end
+
+    def read_raw_snapshot
+      @redis.hgetall(@snapshot_table)
+    end
+
+    def auto_rebuild_snapshot(events_hash)
+      return events_hash unless events_hash.empty? #got it? return it
+
+      event = @aggregate.events.select(:version).limit(1).all
+      return events_hash if event.nil? #return nil if no events in the ES
+
+      # so there are events in the ES but there is no redis snapshot
+      rebuild_snapshot!
+      events_hash = read_raw_snapshot
+    end
+
+  end
+end

data/lib/event_store/version.rb

@@ -1,3 +1,3 @@
 module EventStore
-  VERSION = '0.2.11'
+  VERSION = '0.3.0'
 end

data/lib/event_store.rb

@@ -6,7 +6,8 @@ require 'redis'
 require 'hiredis'
 require 'event_store/version'
 require 'event_store/time_hacker'
-require 'event_store/event_appender'
+require 'event_store/event_stream'
+require 'event_store/snapshot'
 require 'event_store/aggregate'
 require 'event_store/client'
 require 'event_store/errors'
@@ -15,9 +16,11 @@ require 'yaml'
 Sequel.extension :migration
 
 module EventStore
-  Event = Struct.new(:aggregate_id, :occurred_at, :fully_qualified_name, :serialized_event, :version)
+  Event = Struct.new(:aggregate_id, :occurred_at, :fully_qualified_name, :sub_key, :serialized_event)
   SerializedEvent = Struct.new(:fully_qualified_name, :serialized_event, :version, :occurred_at)
-  SNAPSHOT_DELIMITER = "__NexEvStDelim__"
+  SNAPSHOT_DELIMITER     = "__NexEvStDelim__"
+  SNAPSHOT_KEY_DELIMITER = ":"
+  NO_SUB_KEY              = "NO_SUB_KEY"
 
   def self.db_config
     raw_db_config[@environment.to_s][@adapter.to_s]

data/spec/event_store/client_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'securerandom'
+
 AGGREGATE_ID_ONE   = SecureRandom.uuid
 AGGREGATE_ID_TWO   = SecureRandom.uuid
 AGGREGATE_ID_THREE = SecureRandom.uuid
@@ -13,8 +14,10 @@ describe EventStore::Client do
 
     events_by_aggregate_id  = {AGGREGATE_ID_ONE => [], AGGREGATE_ID_TWO => []}
     @event_time = Time.parse("2001-01-01 00:00:00 UTC")
-    ([AGGREGATE_ID_ONE]*10 + [AGGREGATE_ID_TWO]*10).shuffle.each_with_index do |aggregate_id, version|
-      events_by_aggregate_id[aggregate_id.to_s] << EventStore::Event.new(aggregate_id.to_s, @event_time, 'event_name', serialized_binary_event_data, version)
+    ([AGGREGATE_ID_ONE]*5 + [AGGREGATE_ID_TWO]*5).shuffle.each_with_index do |aggregate_id, version|
+      events_by_aggregate_id[aggregate_id.to_s] << EventStore::Event.new(aggregate_id.to_s, @event_time, "zone_1_event", "1", serialized_binary_event_data)
+      events_by_aggregate_id[aggregate_id.to_s] << EventStore::Event.new(aggregate_id.to_s, @event_time, "zone_2_event", "2", serialized_binary_event_data)
+      events_by_aggregate_id[aggregate_id.to_s] << EventStore::Event.new(aggregate_id.to_s, @event_time, "system_event", EventStore::NO_SUB_KEY, serialized_binary_event_data)
     end
     client_1.append events_by_aggregate_id[AGGREGATE_ID_ONE]
     client_2.append events_by_aggregate_id[AGGREGATE_ID_TWO]
@@ -36,7 +39,7 @@ describe EventStore::Client do
       expect(raw_stream.class).to eq(Array)
       raw_event = raw_stream.first
       expect(raw_event.class).to eq(Hash)
-      expect(raw_event.keys).to eq([:id, :version, :aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event])
+      expect(raw_event.keys).to eq([:id, :version, :aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event, :sub_key])
     end
 
     it 'should be empty for aggregates without events' do
@@ -51,7 +54,7 @@ describe EventStore::Client do
 
     it 'should have all events for that aggregate' do
       stream = es_client.new(AGGREGATE_ID_ONE, :device).raw_event_stream
-      expect(stream.count).to eq(10)
+      expect(stream.count).to eq(15)
     end
   end
 
@@ -76,14 +79,14 @@ describe EventStore::Client do
 
     it 'should have all events for that aggregate' do
       stream = es_client.new(AGGREGATE_ID_ONE, :device).event_stream
-      expect(stream.count).to eq(10)
+      expect(stream.count).to eq(15)
     end
 
     context "when the serialized event is terminated prematurely with a null byte" do
       it "does not truncate the serialized event when there is a binary zero value is at the end" do
         serialized_event = serialized_event_data_terminated_by_null
         client = es_client.new("any_device", :device)
-        event = EventStore::Event.new("any_device", @event_time, 'other_event_name', serialized_event, client.version + 1)
+        event = EventStore::Event.new("any_device", @event_time, 'other_event_name', "nozone", serialized_event)
         client.append([event])
         expect(client.event_stream.last[:serialized_event]).to eql(serialized_event)
       end
@@ -91,7 +94,7 @@ describe EventStore::Client do
       it "conversion of byte array to and from hex should be lossless" do
         client = es_client.new("any_device", :device)
         serialized_event = serialized_event_data_terminated_by_null
-        event = EventStore::Event.new("any_device", @event_time, 'terminated_by_null_event', serialized_event, client.version + 1)
+        event = EventStore::Event.new("any_device", @event_time, 'terminated_by_null_event', "zone_number", serialized_event)
         client.append([event])
         hex_from_db = EventStore.db.from(EventStore.fully_qualified_table).where(fully_qualified_name: 'terminated_by_null_event').first[:serialized_event]
         expect(hex_from_db).to eql(EventStore.escape_bytea(serialized_event))
@@ -150,15 +153,14 @@ describe EventStore::Client do
     subject {es_client.new(AGGREGATE_ID_ONE, :device)}
 
     before do
-      version = subject.version
       @oldest_event_time = @event_time + 1
       @middle_event_time = @event_time + 2
       @newest_event_time = @event_time + 3
 
-      @outside_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time).utc, "middle_event", "#{1002.to_s(2)}_foo", version += 1)
-      @event = EventStore::Event.new(AGGREGATE_ID_ONE, (@oldest_event_time).utc, "oldest_event", "#{1002.to_s(2)}_foo", version += 1)
-      @new_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@middle_event_time).utc, "middle_event", "#{1002.to_s(2)}_foo", version += 1)
-      @newest_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@newest_event_time).utc, "newest_event_type", "#{1002.to_s(2)}_foo", version += 1)
+      @outside_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time).utc, "middle_event", "zone", "#{1002.to_s(2)}_foo")
+      @event = EventStore::Event.new(AGGREGATE_ID_ONE, (@oldest_event_time).utc, "oldest_event", "zone", "#{1002.to_s(2)}_foo")
+      @new_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@middle_event_time).utc, "middle_event", "zone", "#{1002.to_s(2)}_foo")
+      @newest_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@newest_event_time).utc, "newest_event_type", "zone", "#{1002.to_s(2)}_foo")
       subject.append([@event, @new_event, @newest_event])
     end
 
@@ -237,11 +239,10 @@ describe EventStore::Client do
     before do
       @client = EventStore::Client.new(AGGREGATE_ID_ONE, :device)
       @event = @client.peek
-      version = @client.version
-      @old_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time - 2000).utc, "old", "#{1000.to_s(2)}_foo", version += 1)
-      @new_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time - 1000).utc, "new", "#{1001.to_s(2)}_foo", version += 1)
-      @really_new_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time + 100).utc, "really_new", "#{1002.to_s(2)}_foo", version += 1)
-      @duplicate_event  = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time).utc, 'duplicate', "#{12.to_s(2)}_foo", version += 1)
+      @old_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time - 2000).utc, "old", "zone", "#{1000.to_s(2)}_foo")
+      @new_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time - 1000).utc, "new", "zone", "#{1001.to_s(2)}_foo")
+      @really_new_event = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time + 100).utc, "really_new", "zone", "#{1002.to_s(2)}_foo")
+      @duplicate_event  = EventStore::Event.new(AGGREGATE_ID_ONE, (@event_time).utc, 'duplicate', "zone", "#{12.to_s(2)}_foo")
     end
 
     describe "when expected version number is greater than the last version" do
@@ -292,7 +293,7 @@ describe EventStore::Client do
       end
 
       describe 'with prior events of same type' do
-        it 'should raise a ConcurrencyError if the the event version is less than current version' do
+        xit 'should raise a ConcurrencyError if the the event version is less than current version' do
           @client.append([@duplicate_event])
           reset_current_version_for(@client)
           expect { @client.append([@duplicate_event]) }.to raise_error(EventStore::ConcurrencyError)
@@ -300,7 +301,6 @@ describe EventStore::Client do
 
         it 'should not raise an error when two events of the same type are appended' do
           @client.append([@duplicate_event])
-          @duplicate_event[:version] += 1
           @client.append([@duplicate_event]) #will fail automatically if it throws an error, no need for assertions (which now print warning for some reason)
         end
 
@@ -313,10 +313,15 @@ describe EventStore::Client do
           expect(@client.snapshot).to eq(expected)
         end
 
-        it "should increment the version number by the number of unique events added" do
+        #TODO if we let the db assign version# then this can't be true anymore
+        #     the current snapshot version will be the last version number inserted
+        #     if you give me duplicate events, I'm gonna append them and the last one in
+        #     is the one that will be in the snapshot
+        xit "should increment the version number by the number of unique events added" do
           events = [@old_event, @old_event, @old_event]
           initial_version = @client.version
           @client.append(events)
+          byebug
           expect(@client.version).to eq(initial_version + events.uniq.length)
         end
 
@@ -362,37 +367,6 @@ describe EventStore::Client do
       end
     end
 
-    describe 'snapshot' do
-      before do
-        @client = es_client.new(AGGREGATE_ID_THREE, :device)
-        expect(@client.snapshot.length).to eq(0)
-        version = @client.version
-        @client.append %w{ e1 e2 e3 e1 e2 e4 e5 e2 e5 e4}.map {|fqn|EventStore::Event.new(AGGREGATE_ID_THREE, Time.now.utc, fqn, serialized_binary_event_data, version += 1)}
-      end
-
-      it "finds the most recent records for each type" do
-        version = @client.version
-        expected_snapshot = %w{ e1 e2 e3 e4 e5 }.map {|fqn| EventStore::SerializedEvent.new(fqn, serialized_binary_event_data, version +=1 ) }
-        actual_snapshot = @client.snapshot
-        expect(@client.event_stream.length).to eq(10)
-        expect(actual_snapshot.length).to eq(5)
-        expect(actual_snapshot.map(&:fully_qualified_name)).to eq(["e3", "e1", "e2", "e5", "e4"]) #sorted by version no
-        expect(actual_snapshot.map(&:serialized_event)).to eq(expected_snapshot.map(&:serialized_event))
-        most_recent_events_of_each_type = {}
-        @client.event_stream.each do |e|
-          if most_recent_events_of_each_type[e.fully_qualified_name].nil? || most_recent_events_of_each_type[e.fully_qualified_name].version < e.version
-            most_recent_events_of_each_type[e.fully_qualified_name] = e
-          end
-        end
-        expect(actual_snapshot.map(&:version)).to eq(most_recent_events_of_each_type.values.map(&:version).sort)
-      end
-
-      it "increments the version number of the snapshot when an event is appended" do
-        expect(@client.snapshot.last.version).to eq(@client.raw_event_stream.last[:version])
-      end
-    end
-
-
     def reset_current_version_for(client)
       aggregate = client.instance_variable_get("@aggregate")
       EventStore.redis.hset(aggregate.snapshot_version_table, :current_version, 1000)

data/spec/event_store/snapshot_spec.rb

@@ -1,45 +1,88 @@
 require 'spec_helper'
+require 'securerandom'
+
+AGGREGATE_ID_ONE = SecureRandom.uuid
+AGGREGATE_ID_TWO = SecureRandom.uuid
+
 module EventStore
   describe "Snapshots" do
-    let(:aggregate_id)  {'100A' }
-    let(:new_aggregate) { Aggregate.new(aggregate_id) }
-    let(:client)        { Client.new(aggregate_id) }
-    let(:appender)      { EventAppender.new(new_aggregate) }
-    let(:events)        { Array.new }
-
-    before do
-      @event_time = Time.parse("2001-01-01 00:00:00 UTC")
-      (0...10).to_a.each_with_index do |version|
-        events << EventStore::Event.new(aggregate_id, @event_time, 'event_name', "#{234532.to_s(2)}_foo}", version)
+
+    context "when there are no events" do
+      let(:client)    { EventStore::Client.new(AGGREGATE_ID_ONE) }
+
+      it "should build an empty snapshot for a new client" do
+        expect(client.snapshot).to eq([])
+        expect(client.version).to eq(-1)
+        expect(EventStore.redis.hget(client.snapshot_version_table, :current_version)).to eq(nil)
+      end
+
+      it "a client should rebuild a snapshot" do
+        expect_any_instance_of(EventStore::Aggregate).to receive(:delete_snapshot!)
+        expect_any_instance_of(EventStore::Aggregate).to receive(:rebuild_snapshot!)
+        client.rebuild_snapshot!
+      end
+    end
+
+    context "with events in the stream" do
+      let(:client)    { EventStore::Client.new(AGGREGATE_ID_TWO) }
+
+      before do
+        expect(client.snapshot.length).to eq(0)
+        client.append events_for(AGGREGATE_ID_TWO)
+      end
+
+      it "rebuilds a snapshot after it is deleted" do
+        snapshot = client.snapshot
+        client.delete_snapshot!
+        client.rebuild_snapshot!
+        expect(client.snapshot).to eq(snapshot)
+      end
+
+      it "automatically rebuilds the snapshot if events exist, but the snapshot is empty" do
+        snapshot = client.snapshot
+        client.delete_snapshot!
+        expect(client.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
+
+        expect(client.event_stream.length).to eq(15)
+        expect(actual_snapshot.map(&:fully_qualified_name)).to eq(expected_snapshot_events)
+        expect(actual_snapshot.length).to eq(8)
+        expect(actual_snapshot.map(&:serialized_event)).to eq(expected_snapshot.map(&:serialized_event))
+      end
+
+      it "increments the version number of the snapshot when an event is appended" do
+        expect(client.snapshot.last.version).to eq(client.raw_event_stream.last[:version])
       end
     end
 
-    it "should build an empty snapshot for a new client" do
-      expect(new_aggregate.snapshot).to eq([])
-      expect(new_aggregate.version).to eq(-1)
-      expect(EventStore.redis.hget(new_aggregate.snapshot_version_table, :current_version)).to eq(nil)
+    def events_for(device_id)
+      events = %w{ e1 e2 e3 e1 e2 e4 e5 e2 e5 e4 }.map {|fqn| event_hash(device_id, fqn, EventStore::NO_SUB_KEY) }
+      events += %w{ e7 e7 e8 }.map {|fqn| event_hash(device_id, fqn, "zone1") }
+      events += %w{ e7 e7 }.map {|fqn| event_hash(device_id, fqn, "zone2") }
     end
 
-    it "should rebuild a snapshot after it is deleted" do
-      appender.append(events)
-      snapshot = new_aggregate.snapshot
-      version  = new_aggregate.version
-      new_aggregate.delete_snapshot!
-      new_aggregate.rebuild_snapshot!
-      expect(new_aggregate.snapshot).to eq(snapshot)
+    def event_hash(device_id, fqn, zone_id)
+      EventStore::Event.new(device_id,
+                            Time.now.utc,
+                            fqn,
+                            zone_id,
+                            serialized_binary_event_data
+                            )
     end
 
-    it "a client should rebuild a snapshot" do
-      expect_any_instance_of(Aggregate).to receive(:delete_snapshot!)
-      expect_any_instance_of(Aggregate).to receive(:rebuild_snapshot!)
-      client.rebuild_snapshot!
+    def serialized_events(events)
+      events.map {|fqn| EventStore::SerializedEvent.new(fqn, serialized_binary_event_data, 1 ) }
     end
 
-    it "should rebuild the snapshot if events exist, but the snapshot is empty" do
-      appender.append(events)
-      snapshot = new_aggregate.snapshot
-      new_aggregate.delete_snapshot!
-      expect(new_aggregate.snapshot).to eq(snapshot)
+    def serialized_binary_event_data
+      @event_data ||= File.open(File.expand_path("../serialized_binary_event_data.txt", __FILE__), 'rb') {|f| f.read}
+      @event_data
     end
+
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require 'simplecov'
 require 'simplecov-rcov'
+require 'ostruct'
 require 'pry'
+require 'pry-byebug'
 require 'rspec'
 
 class SimpleCov::Formatter::MergedFormatter

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexia_event_store
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.3.0
 platform: ruby
 authors:
 - Paul Saieg, John Colvin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2014-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -230,13 +230,15 @@ files:
 - db/event_store_sample_data_generator.rb
 - db/migrations/001_create_event_store_events.rb
 - db/pg_migrations/001_create_event_store_events.rb
+- db/pg_migrations/002_create_event_store_events.rb
 - db/setup_db_user.sql
 - event_store.gemspec
 - lib/event_store.rb
 - lib/event_store/aggregate.rb
 - lib/event_store/client.rb
 - lib/event_store/errors.rb
-- lib/event_store/event_appender.rb
+- lib/event_store/event_stream.rb
+- lib/event_store/snapshot.rb
 - lib/event_store/time_hacker.rb
 - lib/event_store/version.rb
 - spec/benchmark/bench.rb

data/lib/event_store/event_appender.rb

@@ -1,84 +0,0 @@
-module EventStore
-  class EventAppender
-
-    def initialize aggregate
-      @aggregate = aggregate
-    end
-
-    def append raw_events
-      EventStore.db.transaction do
-        set_current_version
-
-        prepared_events = raw_events.map do |raw_event|
-          event = prepare_event(raw_event)
-          validate! event
-          raise concurrency_error(event) if has_concurrency_issue?(event)
-          event
-        end
-        # All concurrency issues need to be checked before persisting any of the events
-        # Otherwise, the newly appended events may raise erroneous concurrency errors
-        result = @aggregate.events.multi_insert(prepared_events)
-        store_snapshot(prepared_events) unless result.nil?
-        result
-      end
-    end
-
-    def store_snapshot(prepared_events)
-      r = EventStore.redis
-      current_version_numbers = r.hgetall(@aggregate.snapshot_version_table)
-      current_version_numbers.default = -1
-      valid_snapshot_events = []
-      valid_snapshot_versions = []
-      prepared_events.each do |event|
-        if event[:version].to_i > current_version_numbers[event[:fully_qualified_name]].to_i
-          valid_snapshot_events   << event[:fully_qualified_name]
-          valid_snapshot_events   << (event[:version].to_s + EventStore::SNAPSHOT_DELIMITER + event[:serialized_event] + EventStore::SNAPSHOT_DELIMITER + event[:occurred_at].to_s)
-          valid_snapshot_versions << event[:fully_qualified_name]
-          valid_snapshot_versions << event[:version]
-        end
-      end
-      unless valid_snapshot_versions.empty?
-        last_version            = valid_snapshot_versions.last
-        valid_snapshot_versions << :current_version
-        valid_snapshot_versions << last_version.to_i
-        r.multi do
-          r.hmset(@aggregate.snapshot_version_table, valid_snapshot_versions)
-          r.hmset(@aggregate.snapshot_table, valid_snapshot_events)
-        end
-      end
-    end
-
-  private
-    def has_concurrency_issue? event
-      event[:version] <= current_version
-    end
-
-    def prepare_event raw_event
-      raise ArgumentError.new("Cannot Append a Nil Event") unless raw_event
-      { :version              => raw_event.version.to_i,
-        :aggregate_id         => raw_event.aggregate_id,
-        :occurred_at          => Time.parse(raw_event.occurred_at.to_s).utc, #to_s truncates microseconds, which brake Time equality
-        :serialized_event     => EventStore.escape_bytea(raw_event.serialized_event),
-        :fully_qualified_name => raw_event.fully_qualified_name }
-    end
-
-    def concurrency_error event
-      ConcurrencyError.new("The version of the event being added (version #{event[:version]}) is <= the current version (version #{current_version})")
-    end
-
-    private
-    def current_version
-      @current_version ||= @aggregate.version
-    end
-    alias :set_current_version :current_version
-
-    def validate! event_hash
-      [:aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event, :version].each do |attribute_name|
-        if event_hash[attribute_name].to_s.strip.empty?
-          raise AttributeMissingError, "value required for #{attribute_name}"
-        end
-      end
-    end
-
-  end
-end