sandthorn_driver_sequel 3.2.1 → 4.0.0

data/lib/sandthorn_driver_sequel/wrappers/snapshot_wrapper.rb

@@ -1,19 +0,0 @@
-module SandthornDriverSequel
-  class SnapshotWrapper < SimpleDelegator
-    def aggregate_version
-      self[:aggregate].aggregate_version
-    end
-
-    def data
-      self[:aggregate]
-    end
-
-    def snapshot_id
-      self[:snapshot_id]
-    end
-
-    def aggregate_table_id
-      self[:aggregate_table_id]
-    end
-  end
-end

data/spec/asking_for_aggregates_to_snapshot_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-class Foo; end
-class Bar; end
-
-module SandthornDriverSequel
-
-  describe EventStore do
-    before(:each) { prepare_for_test }
-    let(:aggregate) { Struct::AggregateMock.new(aggregate_id, 11) }
-    let(:aggregate_id) { @id ||= UUIDTools::UUID.random_create.to_s }
-    context "when asking for aggregates to snapshot" do
-      let(:aggregates) {
-        [{id: "1", class_name: Foo}, {id: aggregate_id, class_name: Struct::AggregateMock},{id: "3", class_name: Foo}]}
-
-      before(:each) {save_test_events}
-
-      context "when asking for type 'Bar' and max event count 5" do
-        let(:needs_snapshot) { event_store.obsolete_snapshots aggregate_types: [Struct::AggregateMock], max_event_distance: 5 }
-        context "and no snapshots exist" do
-          it "should return that id 2 with class Struct::AggregateMock need to be snapshotted" do
-            expect(needs_snapshot.length).to eql 1
-            expect(needs_snapshot.first[:aggregate_id]).to eql aggregates[1][:id]
-            expect(needs_snapshot.first[:aggregate_type]).to eql "Struct::AggregateMock"
-          end
-        end
-        context "and a recent snapshot exists" do
-          before(:each) do
-            snapshot_data = { event_data: "YO MAN", aggregate_version: 11 }
-            event_store.save_snapshot(aggregate)
-          end
-          it "should return nil" do
-            expect(needs_snapshot).to be_empty
-          end
-        end
-      end
-
-
-      def save_test_events
-        for_1 = event_generator count: 4, start_at: 1
-        for_2 = event_generator count: 3, start_at: 1
-        for_3 = event_generator count: 6, start_at: 1
-        for_2_2 = event_generator count: 10, start_at: 4
-        for_1_2 = event_generator count: 1, start_at: 5
-        save_events for_1, 0
-        save_events for_2, 1
-        save_events for_3, 2
-        save_events for_1_2, 0
-        save_events for_2_2, 1
-      end
-      def save_events events, aggregate_index
-        event_store.save_events events, aggregates[aggregate_index][:id], aggregates[aggregate_index][:class_name]
-      end
-
-      def event_generator count: 1, start_at: 1
-        events = []
-        i = 0
-        while i < count do
-          events << { aggregate_version: i+start_at, event_args: nil, event_name: "event_foo_#{i}" }
-          i += 1
-        end
-        events
-      end
-    end
-  end
-end

data/spec/saving_snapshot_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'yaml'
-
-module SandthornDriverSequel
-  describe EventStore do
-    before(:each) { prepare_for_test }
-    let(:aggregate_id) { @id ||= UUIDTools::UUID.random_create.to_s }
-    let(:test_events) { [{aggregate_version: 1, event_args: nil, event_name: "new"},{aggregate_version: 2, event_args: nil, event_name: "foo"}] } 
-    let(:additional_events) { [{aggregate_version: 3, event_args: nil, event_name: "klopp"},{aggregate_version: 4, event_args: nil, event_name: "flipp"}] } 
-    let(:aggregate) { Struct::AggregateMock.new aggregate_id, 2 }
-    let(:save_snapshot) { event_store.save_snapshot aggregate }
-    let(:save_events) { event_store.save_events test_events, aggregate_id, Struct::AggregateMock }
-    let(:save_additional_events) { event_store.save_events additional_events, aggregate_id, Struct::AggregateMock }
-    context "when loading an aggregate using get_aggregate" do
-      context "and it has a snapshot" do
-        before(:each) do
-          save_events
-          save_snapshot
-          save_additional_events
-        end
-        let(:events) { event_store.get_aggregate aggregate_id, Struct::AggregateMock }
-        it "should have the first event as :aggregate_set_from_snapshot" do
-          expect(events.first[:aggregate]).to eql aggregate
-        end
-        it "should have additional events after first snapshot-event" do
-          expect(events.length).to eql 1+additional_events.length
-          expect(events[1][:aggregate_version]).to eql additional_events[0][:aggregate_version]
-          expect(events.last[:aggregate_version]).to eql additional_events.last[:aggregate_version]
-        end
-      end
-
-    end
-    context "when saving a snapshot" do
-
-      context "and events are saved beforehand" do
-        before(:each) { save_events }
-        it "should be able to save snapshot" do
-          expect { save_snapshot }.to_not raise_error
-        end
-        it "should be able to save and get snapshot" do
-          save_snapshot
-          snap = event_store.get_snapshot(aggregate_id)
-          expect(snap).to eql aggregate
-        end
-      end
-      context "when trying to save a snapshot on a non-existing aggregate" do
-        it "should raise a NonAggregateError" do
-          expect { save_snapshot }.to raise_error SandthornDriverSequel::Errors::NoAggregateError
-        end
-      end
-
-      context "when saving a snapshot twice" do
-        before(:each) { save_events; save_snapshot }
-        it "should not raise error" do
-          expect { save_snapshot }.to_not raise_error
-        end
-      end
-      context "when saving a snapshot on a version less than current version" do
-        before(:each) { save_events; }
-        it "should save without protesting" do
-          data = Struct::AggregateMock.new aggregate_id, 1
-          event_store.save_snapshot(data)
-          snap = event_store.get_snapshot(aggregate_id)
-          expect(snap).to eql data
-        end
-      end
-    end
-  end
-end

data/spec/snapshot_access_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-module SandthornDriverSequel
-  describe SnapshotAccess do
-    include EventStoreContext
-
-    before do
-      prepare_for_test
-    end
-
-    let(:context) { :test }
-    let(:db) { Sequel.connect(event_store_url)}
-    let(:aggregate_id) { generate_uuid }
-    let(:storage) { Storage.new(db, :test) }
-    let(:event_serializer) { -> (data) { YAML.dump(data) } }
-    let(:event_deserializer) { -> (data) { YAML.load(data) } }
-    let(:snapshot_serializer) { -> (data) { YAML.dump(data) } }
-    let(:snapshot_deserializer) { -> (data) { YAML.load(data) } }
-    let(:aggregate_access) { AggregateAccess.new(storage) }
-    let(:event_access) { EventAccess.new(storage, event_serializer, event_deserializer) }
-    let(:aggregate) { aggregate_access.register_aggregate(aggregate_id, "foo") }
-    let(:access) { SnapshotAccess.new(storage, snapshot_serializer, snapshot_deserializer) }
-    let(:events) do
-      [
-          {
-              aggregate_version: 1,
-              event_name: "new",
-              event_args: "new_data"
-          },{
-              aggregate_version: 2,
-              event_name: "foo",
-              event_args: "foo_data"
-          }
-      ]
-    end
-    let(:snapshot_aggregate) { 
-      aggregate #register the aggregate
-      Struct::AggregateMock.new aggregate_id, 0
-    }
-
-    let(:snapshot_aggregate_2) { 
-      Struct::AggregateMock.new aggregate_id, 2
-    }
-
-    describe "#find_by_aggregate_id" do
-      it "returns the correct data" do
-        access.record_snapshot(snapshot_aggregate)
-        aggregate.update(aggregate_version: 1)
-        snapshot = access.find_by_aggregate_id(aggregate.aggregate_id)
-        expect(snapshot.data).to eql snapshot_aggregate
-        
-      end
-    end
-
-    describe "#record" do
-      context "when the aggregate doesn't exist" do
-        it "raises an error" do
-          agg = Struct::AggregateMock.new "qux", 1
-          expect { access.record_snapshot(agg) }.to raise_error(Errors::NoAggregateError)
-        end
-      end
-      context "when the aggregate exists" do
-        context "when no previous snapshot exists" do
-          it "records the snapshot" do
-            
-            expect(access.find_by_aggregate_id(aggregate_id)).to be_nil
-            access.record_snapshot(snapshot_aggregate)
-
-            snapshot = access.find_by_aggregate_id(aggregate_id)
-            expect(snapshot).to_not be_nil
-            expect(snapshot.data).to eq(snapshot_aggregate)
-            expect(snapshot.data.aggregate_version).to eq(0)
-          end
-        end
-        context "when the snapshot isn't fresh" do
-          context "when the versions match" do
-            it "records a new snapshot" do
-              expect(access.find_by_aggregate_id(aggregate_id)).to be_nil
-              access.record_snapshot(snapshot_aggregate)
-              event_access.store_events(aggregate, events)
-              access.record_snapshot(snapshot_aggregate_2)
-
-              snapshot = access.find_by_aggregate_id(aggregate_id)
-              expect(snapshot).to_not be_nil
-              expect(snapshot.data).to eq(snapshot_aggregate_2)
-              expect(snapshot.data.aggregate_version).to eq(2)
-            end
-          end
-
-        end
-        
-      end
-    end
-
-    it "can write and read snapshots" do
-      
-      snapshot_id = access.record_snapshot(snapshot_aggregate)
-      snapshot = access.find(snapshot_id)
-      
-      expect(snapshot).to_not be_nil
-      expect(snapshot.data).to eq(snapshot_aggregate)
-      expect(snapshot)
-
-    end
-
-    def generate_uuid
-      SecureRandom.uuid
-    end
-  end
-end