sandthorn_driver_sequel 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3924bb5783466dc29b26e328fd109b286e72bed4
-  data.tar.gz: 464c30fdd02be1bbf86b60407aaa842a13719bae
+  metadata.gz: 6b8be400a63faf0cff694bfed4677cad95df61e2
+  data.tar.gz: 3ded4bab8764c6534f4580e16e78c6886f66f7f3
 SHA512:
-  metadata.gz: 29ee3fe2c3e741503c089cae89b5fa8b6efd3680c0d58dcfb57e9a5301d80a7f191c5aee54194194321c4c41ac4230162b5976acde1de5f49998796c349b5557
-  data.tar.gz: 54c2d0a99c0a9258ffd08f8bc13d43f319a696e1b7a9f362d2b1b9a1fe9c6e069e94e44badf30d7d501ed1952f912eaac7424192585ba8a0b5ad243cf342c1bf
+  metadata.gz: 955a9fc22846b2ec3e4a3091dd57a9b1e5b3a4bf16f740e81e4b8e3c5e27848c088b8511a72aba01e8765c91d9c811cdfa04a757cbe939c7d3811405aa2ba85a
+  data.tar.gz: b4149f981b2ac7b5a504ba8a55824ef55c9f88a239ffb37d703173387996fc5288ca124f6c7cfb6a15d63a3f71de762895ec0d499ee16958ed4fd2211c2064ce

data/Rakefile

@@ -6,5 +6,5 @@ RSpec::Core::RakeTask.new(:spec)
 task default: :spec
 
 task :benchmark do
-	sh "ulimit -n 8192 && rspec --tag benchmark"
+  sh "ulimit -n 8192 && rspec --tag benchmark"
 end

data/lib/sandthorn_driver_sequel/access/event_access.rb

@@ -54,7 +54,7 @@ module SandthornDriverSequel
     def build_event_data(aggregate, timestamp, event)
       {
           aggregate_table_id: aggregate.id,
-          aggregate_version: event.aggregate_version,
+          aggregate_version: aggregate.aggregate_version,
           event_name: event.event_name,
           event_data: event.event_data,
           timestamp: timestamp
@@ -73,7 +73,7 @@ module SandthornDriverSequel
     def store_event(aggregate, timestamp, event)
       event = EventWrapper.new(event)
       aggregate.aggregate_version += 1
-      check_versions!(aggregate, event)
+      check_versions!(aggregate, event) if event[:aggregate_version]
       data = build_event_data(aggregate, timestamp, event)
       storage.events.insert(data)
     end

data/lib/sandthorn_driver_sequel/version.rb

@@ -1,3 +1,3 @@
 module SandthornDriverSequel
-  VERSION = "2.0.1"
+  VERSION = "2.1.0"
 end

data/spec/asking_for_aggregates_to_snapshot_spec.rb

@@ -5,60 +5,60 @@ class Bar; end
 
 module SandthornDriverSequel
 
-	describe EventStore do
-		before(:each) { prepare_for_test }
-		context "when asking for aggregates to snapshot" do
-			let(:aggregates) {
-				[{id: "1", class_name: Foo}, {id: "2", class_name: Bar},{id: "3", class_name: Foo}]}
+  describe EventStore do
+    before(:each) { prepare_for_test }
+    context "when asking for aggregates to snapshot" do
+      let(:aggregates) {
+        [{id: "1", class_name: Foo}, {id: "2", class_name: Bar},{id: "3", class_name: Foo}]}
 
-			before(:each) {save_test_events}
+      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: [Bar], max_event_distance: 5 }
-				context "and no snapshots exist" do
-					it "should return that id 2 with class Bar 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 "Bar"
-					end
-				end
-				context "and a recent snapshot exists" do
-					before(:each) do
+      context "when asking for type 'Bar' and max event count 5" do
+        let(:needs_snapshot) { event_store.obsolete_snapshots aggregate_types: [Bar], max_event_distance: 5 }
+        context "and no snapshots exist" do
+          it "should return that id 2 with class Bar 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 "Bar"
+          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(snapshot_data, aggregates[1][:id])
           end
-					it "should return nil" do
-						expect(needs_snapshot).to be_empty
-					end
-				end
-			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 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_data: nil, event_name: "event_foo_#{i}" }
-					i += 1
-				end
-				events
-			end
-		end
-	end
+      def event_generator count: 1, start_at: 1
+        events = []
+        i = 0
+        while i < count do
+          events << { aggregate_version: i+start_at, event_data: nil, event_name: "event_foo_#{i}" }
+          i += 1
+        end
+        events
+      end
+    end
+  end
 end

data/spec/driver_interface_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 module SandthornDriverSequel
-	describe EventStore do
-		before(:each) { prepare_for_test }
-		context "interface structure" do
-			let(:subject) { event_store }
+  describe EventStore do
+    before(:each) { prepare_for_test }
+    context "interface structure" do
+      let(:subject) { event_store }
       methods = [
         :save_events,
         :save_snapshot,
@@ -27,5 +27,5 @@ module SandthornDriverSequel
       end
 
     end
-	end
+  end
 end

data/spec/event_store_with_context_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 module SandthornDriverSequel
-	describe EventStore do
-		let(:context) { :event_store_spec }
-		before(:each) { prepare_for_test context: context; prepare_for_test context: nil; }
-		let(:event_store_with_context) { EventStore.new url: event_store_url, context: context }	
-		let(:event_store_without_context) { EventStore.new url: event_store_url }
-		context("when saving in one context and retrieving in another") do
-			let(:test_events) do
-				e = [] 
-				e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
-				e << {aggregate_version: 2, event_name: "foo", event_args: ["bar"], event_data: "noop"}
-				e << {aggregate_version: 3, event_name: "flubber", event_args: ["bar"] , event_data: "noop"}
-			end
-			let(:aggregate_id) {"c0456e26-e29a-4f67-92fa-130b3a31a39b"}
-			it "should not find them" do
-				event_store_without_context.save_events test_events, aggregate_id, String
-				events = event_store_without_context.get_aggregate_events aggregate_id
-				expect(events.length).to eql test_events.length
-				events_2 = event_store_with_context.get_aggregate_events aggregate_id
-				expect(events_2.length).to eql 0
-			end
-		end
-	end
+  describe EventStore do
+    let(:context) { :event_store_spec }
+    before(:each) { prepare_for_test context: context; prepare_for_test context: nil; }
+    let(:event_store_with_context) { EventStore.new url: event_store_url, context: context }  
+    let(:event_store_without_context) { EventStore.new url: event_store_url }
+    context("when saving in one context and retrieving in another") do
+      let(:test_events) do
+        e = [] 
+        e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
+        e << {aggregate_version: 2, event_name: "foo", event_args: ["bar"], event_data: "noop"}
+        e << {aggregate_version: 3, event_name: "flubber", event_args: ["bar"] , event_data: "noop"}
+      end
+      let(:aggregate_id) {"c0456e26-e29a-4f67-92fa-130b3a31a39b"}
+      it "should not find them" do
+        event_store_without_context.save_events test_events, aggregate_id, String
+        events = event_store_without_context.get_aggregate_events aggregate_id
+        expect(events.length).to eql test_events.length
+        events_2 = event_store_with_context.get_aggregate_events aggregate_id
+        expect(events_2.length).to eql 0
+      end
+    end
+  end
 end

data/spec/get_events_spec.rb

@@ -1,128 +1,128 @@
 require 'spec_helper'
 
 module SandthornDriverSequel
-	describe EventStore do
-		before(:each) { prepare_for_test }
-		let(:test_events_a) do
-			e = []
-			e << {aggregate_version: 1, event_name: "new", event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
-			e << {aggregate_version: 2, event_name: "foo", event_data: "A2"}
-			e << {aggregate_version: 3, event_name: "bard", event_data: "A3"}
-		end
-		let(:aggregate_id_a) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
-		let(:test_events_b) do
-			e = []
-			e << {aggregate_version: 1, event_name: "new", event_data: "B1" }
-			e << {aggregate_version: 2, event_name: "foo", event_data: "B2"}
-			e << {aggregate_version: 3, event_name: "bar", event_data: "B3"}
-		end
-		let(:aggregate_id_b) {"c0456e26-1234-4f67-92fa-130b3a31a39a"}
-		let(:test_events_c) do
-			e = []
-			e << {aggregate_version: 1, event_name: "new", event_data: "C1" }
-		end
-		let(:test_events_c_2) do
-			e = []
-			e << {aggregate_version: 2, event_name: "flubber", event_data: "C2" }
-		end
-		let(:aggregate_id_c) {"c0456e26-2345-4f67-92fa-130b3a31a39a"}
-		before(:each) do
-			event_store.save_events test_events_a, aggregate_id_a, SandthornDriverSequel::EventStore
-			event_store.save_events test_events_c, aggregate_id_c, String
-			event_store.save_events test_events_b, aggregate_id_b, SandthornDriverSequel::SequelDriver
-			event_store.save_events test_events_c_2, aggregate_id_c, String
-		end
+  describe EventStore do
+    before(:each) { prepare_for_test }
+    let(:test_events_a) do
+      e = []
+      e << {aggregate_version: 1, event_name: "new", event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
+      e << {aggregate_version: 2, event_name: "foo", event_data: "A2"}
+      e << {aggregate_version: 3, event_name: "bard", event_data: "A3"}
+    end
+    let(:aggregate_id_a) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
+    let(:test_events_b) do
+      e = []
+      e << {aggregate_version: 1, event_name: "new", event_data: "B1" }
+      e << {aggregate_version: 2, event_name: "foo", event_data: "B2"}
+      e << {aggregate_version: 3, event_name: "bar", event_data: "B3"}
+    end
+    let(:aggregate_id_b) {"c0456e26-1234-4f67-92fa-130b3a31a39a"}
+    let(:test_events_c) do
+      e = []
+      e << {aggregate_version: 1, event_name: "new", event_data: "C1" }
+    end
+    let(:test_events_c_2) do
+      e = []
+      e << {aggregate_version: 2, event_name: "flubber", event_data: "C2" }
+    end
+    let(:aggregate_id_c) {"c0456e26-2345-4f67-92fa-130b3a31a39a"}
+    before(:each) do
+      event_store.save_events test_events_a, aggregate_id_a, SandthornDriverSequel::EventStore
+      event_store.save_events test_events_c, aggregate_id_c, String
+      event_store.save_events test_events_b, aggregate_id_b, SandthornDriverSequel::SequelDriver
+      event_store.save_events test_events_c_2, aggregate_id_c, String
+    end
 
-		let(:event) { event_store.get_events(take: 1).first }
+    let(:event) { event_store.get_events(take: 1).first }
 
-		it "returns events that can be merged" do
-			expect(event).to respond_to(:merge)
-		end
+    it "returns events that can be merged" do
+      expect(event).to respond_to(:merge)
+    end
 
-		context "when using get_events" do
-			context "and using take" do
-				let(:events) {event_store.get_events after_sequence_number: 0, take: 2}
-				it "should find 2 events" do
-					expect(events.length).to eql 2
-				end
-			end
-			context "and combining args" do
-				let(:events) do
-					all = event_store.get_events after_sequence_number: 0
-					first_seq_number = all[0][:sequence_number]
-					event_store.get_events after_sequence_number: first_seq_number, take: 100
-				end
-				it "should find 7 events" do
-					expect(events.length).to eql 7
-				end
-				
-			end
-			context "and getting events for SandthornDriverSequel::EventStore, and String after 0" do
-				let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel::EventStore, String]}
-				it "should find 5 events" do
-					expect(events.length).to eql 5
-				end
-				it "should be in sequence_number order" do
-					check = 0
-					events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
-				end
-				it "should contain only events for aggregate_id_a and aggregate_id_c" do
-					events.each { |e| expect([aggregate_id_a, aggregate_id_c].include?(e[:aggregate_id])).to be_truthy }
-				end
-			end
-			context "and getting events for SandthornDriverSequel::EventStore after 0" do
-				let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel::EventStore]}
-				it "should find 3 events" do
-					expect(events.length).to eql 3
-				end
-				it "should be in sequence_number order" do
-					check = 0
-					events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
-				end
-				it "should contain only events for aggregate_id_a" do
-					events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a  }
-				end
-			end
-		end
-		context "when using :get_new_events_after_event_id_matching_classname to get events" do
-			context "and getting events for SandthornDriverSequel::EventStore after 0" do
-				let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore}
-				it "should find 3 events" do
-					expect(events.length).to eql 3
-				end
-				it "should be in sequence_number order" do
-					check = 0
-					events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
-				end
-				it "should contain only events for aggregate_id_a" do
-					events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a  }
-				end
-				it "should be able to get events after a sequence number" do
-					new_from = events[1][:sequence_number]
-					ev = event_store.get_new_events_after_event_id_matching_classname new_from, SandthornDriverSequel::EventStore
-					expect(ev.last[:aggregate_version]).to eql 3
-					expect(ev.length).to eql 1
-				end
-				it "should be able to limit the number of results" do
-					ev = event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore, take: 2
-					expect(ev.length).to eql 2
-					expect(ev.last[:aggregate_version]).to eql 2
-				end
-			end
-			context "and getting events for String after 0" do
-				let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, "String"}
-				it "should find 3 events" do
-					expect(events.length).to eql 2
-				end
-				it "should be in sequence_number order" do
-					check = 0
-					events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
-				end
-				it "should contain only events for aggregate_id_c" do
-					events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_c  }
-				end
-			end
-		end
+    context "when using get_events" do
+      context "and using take" do
+        let(:events) {event_store.get_events after_sequence_number: 0, take: 2}
+        it "should find 2 events" do
+          expect(events.length).to eql 2
+        end
+      end
+      context "and combining args" do
+        let(:events) do
+          all = event_store.get_events after_sequence_number: 0
+          first_seq_number = all[0][:sequence_number]
+          event_store.get_events after_sequence_number: first_seq_number, take: 100
+        end
+        it "should find 7 events" do
+          expect(events.length).to eql 7
+        end
+        
+      end
+      context "and getting events for SandthornDriverSequel::EventStore, and String after 0" do
+        let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel::EventStore, String]}
+        it "should find 5 events" do
+          expect(events.length).to eql 5
+        end
+        it "should be in sequence_number order" do
+          check = 0
+          events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
+        end
+        it "should contain only events for aggregate_id_a and aggregate_id_c" do
+          events.each { |e| expect([aggregate_id_a, aggregate_id_c].include?(e[:aggregate_id])).to be_truthy }
+        end
+      end
+      context "and getting events for SandthornDriverSequel::EventStore after 0" do
+        let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel::EventStore]}
+        it "should find 3 events" do
+          expect(events.length).to eql 3
+        end
+        it "should be in sequence_number order" do
+          check = 0
+          events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
+        end
+        it "should contain only events for aggregate_id_a" do
+          events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a  }
+        end
+      end
+    end
+    context "when using :get_new_events_after_event_id_matching_classname to get events" do
+      context "and getting events for SandthornDriverSequel::EventStore after 0" do
+        let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore}
+        it "should find 3 events" do
+          expect(events.length).to eql 3
+        end
+        it "should be in sequence_number order" do
+          check = 0
+          events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
+        end
+        it "should contain only events for aggregate_id_a" do
+          events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a  }
+        end
+        it "should be able to get events after a sequence number" do
+          new_from = events[1][:sequence_number]
+          ev = event_store.get_new_events_after_event_id_matching_classname new_from, SandthornDriverSequel::EventStore
+          expect(ev.last[:aggregate_version]).to eql 3
+          expect(ev.length).to eql 1
+        end
+        it "should be able to limit the number of results" do
+          ev = event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore, take: 2
+          expect(ev.length).to eql 2
+          expect(ev.last[:aggregate_version]).to eql 2
+        end
+      end
+      context "and getting events for String after 0" do
+        let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, "String"}
+        it "should find 3 events" do
+          expect(events.length).to eql 2
+        end
+        it "should be in sequence_number order" do
+          check = 0
+          events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
+        end
+        it "should contain only events for aggregate_id_c" do
+          events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_c  }
+        end
+      end
+    end
 
-	end
+  end
 end

data/spec/migration_specifying_domain_spec.rb

@@ -1,35 +1,35 @@
 require 'spec_helper'
 
 module SandthornDriverSequel
-	describe Migration do
-		def check_tables context = nil
-			events = :events
-			aggregates = :aggregates
-			snapshots = :snapshots
-			if context
-				events = "#{context}_#{events}".to_sym
-				aggregates = "#{context}_#{aggregates}".to_sym
-				snapshots = "#{context}_#{snapshots}".to_sym
-			end
-			migration.driver.execute do |db|
-				expect(db.table_exists? events).to be_truthy, "expected table :#{events} to exist, but it didn't"
-				expect(db.table_exists? aggregates).to be_truthy, "expected table :#{aggregates} to exist, but it didn't"
-				expect(db.table_exists? snapshots).to be_truthy, "expected table :#{snapshots} to exist, but it didn't"
-			end
-		end
-		let(:migration) { Migration.new url: event_store_url, context: context  }
-		before(:each) { migration.migrate! }
-		context "when default (nil) eventstore contex" do
-			let(:context) { nil }
-			it "should create the tables events, aggregates and snapshots" do
-				check_tables
-			end
-		end
-		context "when specifying context" do
-			let(:context) { :another_domain }
-			it "should create the tables events, aggregates and snapshots" do
-				check_tables context
-			end
-		end
-	end
+  describe Migration do
+    def check_tables context = nil
+      events = :events
+      aggregates = :aggregates
+      snapshots = :snapshots
+      if context
+        events = "#{context}_#{events}".to_sym
+        aggregates = "#{context}_#{aggregates}".to_sym
+        snapshots = "#{context}_#{snapshots}".to_sym
+      end
+      migration.driver.execute do |db|
+        expect(db.table_exists? events).to be_truthy, "expected table :#{events} to exist, but it didn't"
+        expect(db.table_exists? aggregates).to be_truthy, "expected table :#{aggregates} to exist, but it didn't"
+        expect(db.table_exists? snapshots).to be_truthy, "expected table :#{snapshots} to exist, but it didn't"
+      end
+    end
+    let(:migration) { Migration.new url: event_store_url, context: context  }
+    before(:each) { migration.migrate! }
+    context "when default (nil) eventstore contex" do
+      let(:context) { nil }
+      it "should create the tables events, aggregates and snapshots" do
+        check_tables
+      end
+    end
+    context "when specifying context" do
+      let(:context) { :another_domain }
+      it "should create the tables events, aggregates and snapshots" do
+        check_tables context
+      end
+    end
+  end
 end

data/spec/saving_events_spec.rb

@@ -2,89 +2,118 @@ require 'spec_helper'
 require 'msgpack'
 
 module SandthornDriverSequel
-	describe EventStore do
-		before(:each) { prepare_for_test }
-		context "when saving a prefectly sane event stream" do
-			let(:test_events) do
-				e = []
-				e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
-				e << {aggregate_version: 2, event_name: "foo", event_args: ["bar"], event_data: "noop"}
-				e << {aggregate_version: 3, event_name: "flubber", event_args: ["bar"] , event_data: "noop"}
-			end
+  describe EventStore do
+    before(:each) { prepare_for_test }
+    context "when saving a prefectly sane event stream" do
+      let(:test_events) do
+        e = []
+        e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
+        e << {aggregate_version: 2, event_name: "foo", event_args: ["bar"], event_data: "noop"}
+        e << {aggregate_version: 3, event_name: "flubber", event_args: ["bar"] , event_data: "noop"}
+      end
 
       let(:aggregate_id) { "c0456e26-e29a-4f67-92fa-130b3a31a39a" }
 
       it "should be able to save and retrieve events on the aggregate" do
-				event_store.save_events test_events, aggregate_id, String
-				events = event_store.get_aggregate_events aggregate_id
-				expect(events.length).to eql test_events.length
-			end
-
-			it "should have correct keys when asking for events" do
-				event_store.save_events test_events, aggregate_id, String
-				events = event_store.get_aggregate aggregate_id, String
-				event = events.first
-				expect(event[:event_data]).to eql(test_events.first[:event_data])
+        event_store.save_events test_events, aggregate_id, String
+        events = event_store.get_aggregate_events aggregate_id
+        expect(events.length).to eql test_events.length
+      end
+
+      it "should have correct keys when asking for events" do
+        event_store.save_events test_events, aggregate_id, String
+        events = event_store.get_aggregate aggregate_id, String
+        event = events.first
+        expect(event[:event_data]).to eql(test_events.first[:event_data])
         expect(event[:event_name]).to eql("new")
         expect(event[:aggregate_id]).to eql aggregate_id
         expect(event[:aggregate_version]).to eql 1
         expect(event[:sequence_number]).to be_a(Fixnum)
         expect(event[:timestamp]).to be_a(Time)
-			end
+      end
+    end
+
+    context "when saving two aggregate types" do
+      let(:test_events_1) do
+        e = []
+        e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
+        e << {aggregate_version: 2, event_name: "foo", event_args: "bar", event_data: "noop"}
+        e << {aggregate_version: 3, event_name: "flubber", event_args: "bar", event_data: "noop"}
+      end
+      let(:test_events_2) do
+        e = []
+        e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
+      end
+      let(:aggregate_id_1) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
+      let(:aggregate_id_2) {"c0456e26-e92b-4f67-92fa-130b3a31b93b"}
+      let(:aggregate_id_3) {"c0456e26-e92b-1234-92fa-130b3a31b93b"}
+
+      before(:each) do
+        event_store.save_events test_events_1, aggregate_id_1, String
+        event_store.save_events test_events_2, aggregate_id_2, Hash
+        event_store.save_events test_events_2, aggregate_id_3, String
+      end
+
+      it "both types should exist in get_all_typenames in alphabetical order" do
+        names = event_store.get_all_types
+        expect(names.length).to eql 2
+        expect(names.first).to eql "Hash"
+        expect(names.last).to eql "String"
+      end
+
+      it "should list the aggregate ids when asking for get_aggregate_list_by_typename" do
+        ids = event_store.get_aggregate_ids(aggregate_type: String)
+        expect(ids.length).to eql 2
+        expect(ids.any? { |e| e == aggregate_id_1 }).to be_truthy
+        expect(ids.any? { |e| e == aggregate_id_3 }).to be_truthy
+      end
     end
 
-		context "when saving two aggregate types" do
-			let(:test_events_1) do
-				e = []
-				e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
-				e << {aggregate_version: 2, event_name: "foo", event_args: "bar", event_data: "noop"}
-				e << {aggregate_version: 3, event_name: "flubber", event_args: "bar", event_data: "noop"}
-			end
-			let(:test_events_2) do
-				e = []
-				e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
-			end
-			let(:aggregate_id_1) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
-			let(:aggregate_id_2) {"c0456e26-e92b-4f67-92fa-130b3a31b93b"}
-			let(:aggregate_id_3) {"c0456e26-e92b-1234-92fa-130b3a31b93b"}
-
-			before(:each) do
-				event_store.save_events test_events_1, aggregate_id_1, String
-				event_store.save_events test_events_2, aggregate_id_2, Hash
-				event_store.save_events test_events_2, aggregate_id_3, String
+    context "when saving events that are serilized with msgpack" do
+      let(:test_data) { {name: "test", hash: {t: 123}} }
+      let(:test_events) do
+        e = []
+        data = MessagePack.pack(test_data, symbolize_keys: true)
+        e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: data}
       end
+      let(:aggregate_id_1) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
 
-			it "both types should exist in get_all_typenames in alphabetical order" do
-				names = event_store.get_all_types
-				expect(names.length).to eql 2
-				expect(names.first).to eql "Hash"
-				expect(names.last).to eql "String"
+      it "should save and get events that are serialized with msgpack" do
+        event_store.save_events test_events, aggregate_id_1, String
+        events = event_store.get_aggregate aggregate_id_1, String
+        expect(MessagePack.unpack(events.first[:event_data], symbolize_keys: true)).to eql test_data
       end
 
-			it "should list the aggregate ids when asking for get_aggregate_list_by_typename" do
-				ids = event_store.get_aggregate_ids(aggregate_type: String)
-				expect(ids.length).to eql 2
-				expect(ids.any? { |e| e == aggregate_id_1 }).to be_truthy
-				expect(ids.any? { |e| e == aggregate_id_3 }).to be_truthy
-			end
     end
 
-		context "when saving events that are serilized with msgpack" do
-			let(:test_data) { {name: "test", hash: {t: 123}} }
-			let(:test_events) do
-				e = []
-				data = MessagePack.pack(test_data, symbolize_keys: true)
-				e << {aggregate_version: 1, event_name: "new", event_args: nil, event_data: data}
-			end
-			let(:aggregate_id_1) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
-
-			it "should save and get events that are serialized with msgpack" do
-				event_store.save_events test_events, aggregate_id_1, String
-				events = event_store.get_aggregate aggregate_id_1, String
-				expect(MessagePack.unpack(events.first[:event_data], symbolize_keys: true)).to eql test_data
+    context "when saving events that have no aggregate_version" do
+      let(:test_events) do
+        e = []
+        e << {aggregate_version: nil, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
+        e << {aggregate_version: nil, event_name: "foo", event_args: ["bar"], event_data: "noop"}
+        e << {aggregate_version: nil, event_name: "flubber", event_args: ["bar"] , event_data: "noop"}
       end
 
-		end
+      let(:aggregate_id) { "c0456e26-e29a-4f67-92fa-130b3a31a39a" }
+
+      it "should be able to save and retrieve events on the aggregate" do
+        event_store.save_events test_events, aggregate_id, String
+        events = event_store.get_aggregate_events aggregate_id
+        expect(events.length).to eql test_events.length
+      end
+
+      it "should have correct keys when asking for events" do
+        event_store.save_events test_events, aggregate_id, String
+        events = event_store.get_aggregate aggregate_id, String
+        event = events.first
+        expect(event[:event_data]).to eql(test_events.first[:event_data])
+        expect(event[:event_name]).to eql("new")
+        expect(event[:aggregate_id]).to eql aggregate_id
+        expect(event[:aggregate_version]).to eql 1
+        expect(event[:sequence_number]).to be_a(Fixnum)
+        expect(event[:timestamp]).to be_a(Time)
+      end
+    end
 
-	end
+  end
 end

data/spec/saving_snapshot_spec.rb

@@ -2,76 +2,76 @@ 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_data: nil, event_name: "new"},{aggregate_version: 2, event_data: nil, event_name: "foo"}] } 
-		let(:additional_events) { [{aggregate_version: 3, event_data: nil, event_name: "klopp"},{aggregate_version: 4, event_data: nil, event_name: "flipp"}] } 
-		let(:snapshot_data) { { event_data: YAML.dump(Object.new), aggregate_version: 2 } }		
-		let(:save_snapshot) { event_store.save_snapshot snapshot_data, aggregate_id }
-		let(:save_events) { event_store.save_events test_events, aggregate_id, SandthornDriverSequel::EventStore }
-		let(:save_additional_events) { event_store.save_events additional_events, aggregate_id, SandthornDriverSequel::EventStore }
-		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, SandthornDriverSequel::EventStore }
-				it "should have the first event as :aggregate_set_from_snapshot" do
-					expect(events.first[:event_name]).to eql "aggregate_set_from_snapshot"
-				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
+  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_data: nil, event_name: "new"},{aggregate_version: 2, event_data: nil, event_name: "foo"}] } 
+    let(:additional_events) { [{aggregate_version: 3, event_data: nil, event_name: "klopp"},{aggregate_version: 4, event_data: nil, event_name: "flipp"}] } 
+    let(:snapshot_data) { { event_data: YAML.dump(Object.new), aggregate_version: 2 } }    
+    let(:save_snapshot) { event_store.save_snapshot snapshot_data, aggregate_id }
+    let(:save_events) { event_store.save_events test_events, aggregate_id, SandthornDriverSequel::EventStore }
+    let(:save_additional_events) { event_store.save_events additional_events, aggregate_id, SandthornDriverSequel::EventStore }
+    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, SandthornDriverSequel::EventStore }
+        it "should have the first event as :aggregate_set_from_snapshot" do
+          expect(events.first[:event_name]).to eql "aggregate_set_from_snapshot"
+        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
+    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 snapshot_data
-				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 trying to save a snapshot with a non-existing aggregate_version" do
-				before(:each) { save_events }
-				it "should raise a WrongAggregateVersion error" do
-					data = snapshot_data
-					data[:aggregate_version] = 100
-					expect { event_store.save_snapshot data, aggregate_id }.to raise_error SandthornDriverSequel::Errors::WrongSnapshotVersionError
-				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 = snapshot_data
-					data[:aggregate_version] = 1
-					event_store.save_snapshot(data, aggregate_id)
-					snap = event_store.get_snapshot(aggregate_id)
-					expect(snap).to eql data
-				end
-			end
-		end
-	end
+      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 snapshot_data
+        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 trying to save a snapshot with a non-existing aggregate_version" do
+        before(:each) { save_events }
+        it "should raise a WrongAggregateVersion error" do
+          data = snapshot_data
+          data[:aggregate_version] = 100
+          expect { event_store.save_snapshot data, aggregate_id }.to raise_error SandthornDriverSequel::Errors::WrongSnapshotVersionError
+        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 = snapshot_data
+          data[:aggregate_version] = 1
+          event_store.save_snapshot(data, aggregate_id)
+          snap = event_store.get_snapshot(aggregate_id)
+          expect(snap).to eql data
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sandthorn_driver_sequel
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Lars Krantz
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-01 00:00:00.000000000 Z
+date: 2016-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -309,7 +309,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Sequel driver for Sandthorn