nexia_event_store 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d0343124beb0b58cbd89357ae7faefe2fddec53
-  data.tar.gz: 77595f7c4826c2f732a4fb6cca2e6a955d751e5a
+  metadata.gz: a53b46ee6253d85453dc97abcaea3cf60d1b6cd6
+  data.tar.gz: 717b8827588f413f87b41513c2ef8539254140fb
 SHA512:
-  metadata.gz: a2e7aee13bbb0afd22c5165a467071cabe04a045ebd246f6bcc8149a180ed4af2849e865c898e4734f7c9434b5eb4e90eaf1c7e715f5361a7e241f4fc0b0a20b
-  data.tar.gz: 99586d4de51eaad607c346b6776183e85304cc4d4fa7b01544d20b37c49f002b2c368c52a5dd04edd439725ca04c152d57d8dcb38791f8d636ce8f06eb13e2d6
+  metadata.gz: b96e05c1a31be2b889a473e86ea7254f506d946be4ef505d6fb2522a3b6c23a425cdc3a0debd3b3ba73d9e0eae386e06e71f4378735a09fc64dd6e452f516971
+  data.tar.gz: 8e2ecbf2ca66a91042dda7fd790f2b61f328a432232045c27b16d1d8fa5807a8a123033345fee46718c65a2a5e5ec7e4c0d6693e945f1dd43e1ee6233f8cdc1c

data/lib/event_store/aggregate.rb

@@ -22,6 +22,10 @@ module EventStore
       :event_table,
       :delete_events!
 
+    def snapshot_exists?
+      @snapshot.exists?
+    end
+
     def self.count
       EventStore.db.from( EventStore.fully_qualified_table).distinct(:aggregate_id).count
     end

data/lib/event_store/client.rb

@@ -2,7 +2,7 @@ module EventStore
   class Client
     extend Forwardable
 
-    def_delegators :@aggregate, :delete_snapshot!, :snapshot_version_table
+    def_delegators :aggregate, :delete_snapshot!, :snapshot_version_table
 
     def self.count
       Aggregate.count
@@ -16,20 +16,24 @@ module EventStore
       @aggregate = Aggregate.new(aggregate_id, aggregate_type)
     end
 
+    def exists?
+      aggregate.snapshot_exists?
+    end
+
     def id
-      @aggregate.id
+      aggregate.id
     end
 
     def type
-      @aggregate.type
+      aggregate.type
     end
 
     def event_table
-      @aggregate.event_table
+      aggregate.event_table
     end
 
     def append(event_data)
-      @aggregate.append(event_data)
+      aggregate.append(event_data)
       yield(event_data) if block_given?
       nil
     end
@@ -43,31 +47,31 @@ module EventStore
     end
 
     def event_stream_from(version_number, max=nil)
-      translate_events(@aggregate.events_from(version_number, max))
+      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
-      @aggregate.last_event
+      aggregate.last_event
     end
 
     def raw_snapshot
-      @aggregate.snapshot
+      aggregate.snapshot
     end
 
     def raw_event_stream
-      @aggregate.event_stream
+      aggregate.event_stream
     end
 
     def raw_event_stream_from version_number, max=nil
-      @aggregate.events_from(version_number, max)
+      aggregate.events_from(version_number, max)
     end
 
     def version
-      @aggregate.version
+      aggregate.version
     end
 
     def count
@@ -75,17 +79,19 @@ module EventStore
     end
 
     def destroy!
-      @aggregate.delete_events!
-      @aggregate.delete_snapshot!
+      aggregate.delete_events!
+      aggregate.delete_snapshot!
     end
 
     def rebuild_snapshot!
-      @aggregate.delete_snapshot!
-      @aggregate.rebuild_snapshot!
+      aggregate.delete_snapshot!
+      aggregate.rebuild_snapshot!
     end
 
     private
 
+    attr_reader :aggregate
+
     def translate_events(event_hashs)
       event_hashs.map { |eh| translate_event(eh) }
     end

data/lib/event_store/snapshot.rb

@@ -1,7 +1,7 @@
 module EventStore
   class Snapshot
 
-    attr_reader :snapshot_version_table
+    attr_reader :snapshot_version_table, :snapshot_table
 
     def initialize aggregate
       @aggregate = aggregate
@@ -10,12 +10,20 @@ module EventStore
       @snapshot_version_table = "#{@aggregate.type}_snapshot_versions_for_#{@aggregate.id}"
     end
 
+    def exists?
+      @redis.exists(snapshot_table)
+    end
+
     def last_event
       snapshot.last
     end
 
     def version
-      (@redis.hget(@snapshot_version_table, :current_version) || -1).to_i
+      (@redis.hget(snapshot_version_table, :current_version) || -1).to_i
+    end
+
+    def size
+      snapshot.size
     end
 
     def snapshot
@@ -39,7 +47,7 @@ module EventStore
     end
 
     def delete_snapshot!
-      EventStore.redis.del [@snapshot_table, @snapshot_version_table]
+      EventStore.redis.del [snapshot_table, snapshot_version_table]
     end
 
     def store_snapshot(prepared_events)
@@ -57,8 +65,8 @@ module EventStore
         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)
+          @redis.hmset(snapshot_version_table, valid_snapshot_versions)
+          @redis.hmset(snapshot_table, valid_snapshot_events)
         end
       end
     end
@@ -87,13 +95,13 @@ module EventStore
     end
 
     def current_version_numbers
-      current_versions = @redis.hgetall(@snapshot_version_table)
+      current_versions = @redis.hgetall(snapshot_version_table)
       current_versions.default = -1
       current_versions
     end
 
     def read_raw_snapshot
-      @redis.hgetall(@snapshot_table)
+      @redis.hgetall(snapshot_table)
     end
 
     def auto_rebuild_snapshot(events_hash)

data/lib/event_store/version.rb

@@ -1,3 +1,3 @@
 module EventStore
-  VERSION = '0.3.3'
+  VERSION = '0.4.0'
 end

data/spec/event_store/client_spec.rb

@@ -6,7 +6,7 @@ AGGREGATE_ID_TWO   = SecureRandom.uuid
 AGGREGATE_ID_THREE = SecureRandom.uuid
 
 describe EventStore::Client do
-  let(:es_client) { EventStore::Client }
+  subject(:es_client) { EventStore::Client }
 
   before do
     client_1 = es_client.new(AGGREGATE_ID_ONE, :device)
@@ -33,6 +33,19 @@ describe EventStore::Client do
     expect(es_client.ids(offset, limit)).to eq([[AGGREGATE_ID_ONE, AGGREGATE_ID_TWO].sort.first])
   end
 
+  describe "#exists?" do
+    let(:fake_aggregate) { double("Aggregate") }
+
+    subject(:client) { es_client.new(AGGREGATE_ID_ONE, :device) }
+
+    before(:each) { expect(client).to receive(:aggregate).and_return(fake_aggregate) }
+
+    it "checks if the snapshot exists" do
+      expect(fake_aggregate).to receive(:snapshot_exists?).and_return(true)
+      expect(client.exists?).to eq(true)
+    end
+  end
+
   describe '#raw_event_stream' do
     it "should be an array of hashes that represent database records, not EventStore::SerializedEvent objects" do
       raw_stream = es_client.new(AGGREGATE_ID_ONE, :device).raw_event_stream
@@ -373,10 +386,12 @@ describe EventStore::Client do
     end
 
   end
+
   def serialized_event_data_terminated_by_null
     @term_data ||= File.open(File.expand_path("../binary_string_term_with_null_byte.txt", __FILE__), 'rb') {|f| f.read}
     @term_data
   end
+
   def serialized_binary_event_data
     @event_data ||= File.open(File.expand_path("../serialized_binary_event_data.txt", __FILE__), 'rb') {|f| f.read}
     @event_data

data/spec/unit/aggregate_unit_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'mock_redis'
+
+module EventStore
+  describe Aggregate do
+    let(:aggregate_id)  { "014001A8" }
+    let(:type)          { "fake_events" }
+    let(:fake_snapshot) { double("Snapshot", exists?: true) }
+    let(:fake_stream)   { double("EventStream") }
+
+    before(:each) { allow(Snapshot).to receive(:new).and_return(fake_snapshot) }
+    before(:each) { allow(EventStream).to receive(:new).and_return(fake_stream) }
+
+    subject(:aggregate) { EventStore::Aggregate.new(aggregate_id, type) }
+
+    describe "#count" do
+      it "has tests"
+    end
+
+    describe "#ids" do
+      it "has tests"
+    end
+
+    describe "#append" do
+      it "has tests"
+    end
+
+    describe "#snapshot_exists?" do
+      it "delegates to its snapshot" do
+        expect(fake_snapshot).to receive(:exists?).and_return(true)
+        expect(aggregate.snapshot_exists?).to eq(true)
+      end
+
+      it "does not build a snapshot" do
+        expect(fake_snapshot).to_not receive(:snapshot) # :(
+        aggregate.snapshot_exists?
+      end
+    end
+  end
+end

data/spec/unit/snapshot_unit_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'mock_redis'
+
+module EventStore
+  describe Snapshot do
+    let(:redis)          { EventStore.redis }
+    let(:aggregate_type) { "awesome" }
+    let(:aggregate_id)   { "superman" }
+    let(:events)         { [] }
+    let(:aggregate)      { double("Aggregate", type: aggregate_type, id: aggregate_id, events: double(all: events)) }
+
+    subject(:snapshot)   { EventStore::Snapshot.new(aggregate) }
+
+    it "has a version table for the snapshot" do
+      expect(snapshot.snapshot_version_table).to eq "#{aggregate_type}_snapshot_versions_for_#{aggregate_id}"
+    end
+
+    context "with events in the snapshot table" do
+      let(:first_event) {
+        { version: 1,
+          fully_qualified_name: "fqn",
+          sub_key: "sub",
+          serialized_event: EventStore.escape_bytea("cheerios"),
+          occurred_at: Time.at( (Time.now - 3600).to_i )
+        }
+      }
+      let(:last_event) {
+        { version: 2,
+          fully_qualified_name: "fqn2",
+          sub_key: "sub2",
+          serialized_event: EventStore.escape_bytea("cheerios2"),
+          occurred_at: Time.at( (Time.now - 1800).to_i )
+        }
+      }
+      let(:events) { [ first_event, last_event ] }
+
+      before(:each) { snapshot.store_snapshot(events) }
+
+      describe "#last_event" do
+        let(:events) { [ last_event, first_event ] }
+
+        it "returns the event with the highest version" do
+          expect(snapshot.last_event.fully_qualified_name).to eq(last_event[:fully_qualified_name])
+        end
+      end
+
+      describe "#version" do
+        it "is the highest version of the last inserted event in the snapshot" do
+          expect(snapshot.version).to eq(last_event[:version])
+        end
+      end
+
+      describe "#rebuild_snapshot!" do
+        it "deletes the existing snapshot" do
+          expect(redis).to receive(:del).with([snapshot.snapshot_table , snapshot.snapshot_version_table])
+          snapshot.rebuild_snapshot!
+        end
+
+        it "stores a a new snapshot from the aggregate's events" do
+          snapshot.rebuild_snapshot!
+          expect(snapshot.size).to eq(2)
+          # TODO: remove #snapshot in favor of Enumerable
+          names = snapshot.snapshot.map(&:fully_qualified_name)
+          expect(names).to eq(events.map { |e| e[:fully_qualified_name] })
+        end
+      end
+
+      # TODO: remove this in favor of #each and include Enumerable
+      describe "#snapshot" do
+        let(:event_snapshot)   { snapshot.snapshot }
+        let(:serialized_attrs) { [ :fully_qualified_name,
+                                   :serialized_event,
+                                   :version,
+                                   :occurred_at ] }
+
+        it "contains SerializedEvents" do
+          event_snapshot.each { |e| expect(e).to be_a(SerializedEvent) }
+        end
+
+        it "corresponds to the events used to build the snapshot" do
+          (serialized_attrs - [ :serialized_event ]).each { |attr|
+            expect(event_snapshot.first.send(attr)).to eq(first_event[attr])
+            expect(event_snapshot.last.send(attr)).to eq(last_event[attr])
+          }
+        end
+
+        it "unescapes the serialized events" do
+          expected_event = EventStore.unescape_bytea(last_event[:serialized_event])
+          expect(event_snapshot.last.serialized_event).to eq(expected_event)
+        end
+      end
+
+      describe "#exists?" do
+        it "does exist" do
+          expect(snapshot.exists?).to eq(true)
+        end
+
+        context "without a snapshot" do
+          before(:each) { snapshot.delete_snapshot! }
+
+          it "does not exist" do
+            expect(snapshot.exists?).to eq(false)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexia_event_store
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Paul Saieg, John Colvin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-17 00:00:00.000000000 Z
+date: 2015-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -251,6 +251,8 @@ files:
 - spec/event_store/snapshot_spec.rb
 - spec/event_store/vertica guy notes.txt
 - spec/spec_helper.rb
+- spec/unit/aggregate_unit_spec.rb
+- spec/unit/snapshot_unit_spec.rb
 homepage: https://github.com/nexiahome/event_store
 licenses:
 - MIT
@@ -271,7 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of an EventSource (A+ES) for the Nexia Ecosystem
@@ -286,3 +288,5 @@ test_files:
 - spec/event_store/snapshot_spec.rb
 - spec/event_store/vertica guy notes.txt
 - spec/spec_helper.rb
+- spec/unit/aggregate_unit_spec.rb
+- spec/unit/snapshot_unit_spec.rb