sandthorn_driver_sequel 1.1.0 → 2.0.0

data/spec/asking_for_aggregates_to_snapshot_spec.rb

@@ -14,7 +14,7 @@ module SandthornDriverSequel
 			before(:each) {save_test_events}
 
 			context "when asking for type 'Bar' and max event count 5" do
-				let(:needs_snapshot) { event_store.obsolete_snapshots class_names: [Bar], max_event_distance: 5 }
+				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
@@ -23,8 +23,11 @@ module SandthornDriverSequel
 					end
 				end
 				context "and a recent snapshot exists" do
-					before(:each) { event_store.save_snapshot({ event_data: "YO MAN", aggregate_version: 11 }, aggregates[1][:id], aggregates[1][:class_name])}
-					it "should return empty array" 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
@@ -44,7 +47,7 @@ module SandthornDriverSequel
 				save_events for_2_2, 1
 			end
 			def save_events events, aggregate_index
-				event_store.save_events events, events.first[:aggregate_version]-1, aggregates[aggregate_index][:id], aggregates[aggregate_index][:class_name]
+				event_store.save_events events, aggregates[aggregate_index][:id], aggregates[aggregate_index][:class_name]
 			end
 
 			def event_generator count: 1, start_at: 1

data/spec/driver_interface_spec.rb

@@ -4,45 +4,28 @@ module SandthornDriverSequel
 	describe EventStore do
 		before(:each) { prepare_for_test }
 		context "interface structure" do
-			let(:subject) {event_store}
-			it "should respond to save_events" do
-				subject.should respond_to("save_events")
-			end
-
-			it "should respond to save_snapshot" do
-				subject.should respond_to("save_snapshot")
-			end
-
-			it "should respond to get_aggregate" do
-				subject.should respond_to("get_aggregate")
-			end
-
-			it "should respond to get_aggregate_events" do
-				subject.should respond_to("get_aggregate_events")
-			end
-
-			it "should respond to get_aggregate_list_by_typename" do
-				subject.should respond_to("get_aggregate_list_by_typename")
-			end
-
-			it "should respond to get_all_typenames" do
-				subject.should respond_to("get_all_typenames")
-			end
-
-			it "should respond to get_snapshot" do
-				subject.should respond_to("get_snapshot")
-			end
-
-			it "should respond to get_new_events_after_event_id_matching_classname" do
-				subject.should respond_to("get_new_events_after_event_id_matching_classname")
-			end
-
-			it "should respond to get_events_after_sequence_id" do
-				subject.should respond_to(:get_events)
-			end
-			it("should respond to url"){ expect(subject).to respond_to :url }
-			it("should respond to context"){ expect(subject).to respond_to :context }
-			it("should respond to driver"){ expect(subject).to respond_to :driver }
-		end
+			let(:subject) { event_store }
+      methods = [
+        :save_events,
+        :save_snapshot,
+        :get_aggregate_events_from_snapshot,
+        :get_aggregate,
+        :get_aggregate_events,
+        :get_aggregate_ids,
+        :get_all_types,
+        :get_snapshot,
+        :get_events,
+        :url,
+        :context,
+        :driver
+      ]
+
+      methods.each do |method|
+        it "responds to #{method}" do
+          expect(subject).to respond_to(method)
+        end
+      end
+
+    end
 	end
 end

data/spec/event_access_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module SandthornDriverSequel
+  describe EventAccess do
+    include EventStoreContext
+
+    before do
+      prepare_for_test
+    end
+
+    let(:context) { :test }
+    let(:db) { Sequel.connect(event_store_url)}
+    let(:aggregate_id) { SecureRandom.uuid }
+    let(:aggregate) do
+      aggregate_access.register_aggregate(aggregate_id, "foo")
+    end
+    let(:storage) { Storage.new(db, :test) }
+    let(:aggregate_access) { AggregateAccess.new(storage) }
+    let(:snapshot_access) { SnapshotAccess.new(storage)}
+    let(:access) { EventAccess.new(storage) }
+
+    let(:events) do
+      [
+        {
+          aggregate_version: 1,
+          event_name: "new",
+          event_data: "new_data"
+        },{
+          aggregate_version: 2,
+          event_name: "foo",
+          event_data: "foo_data"
+        }
+      ]
+    end
+
+    describe "#store_events" do
+
+      it "handles both arrays and single events" do
+        access.store_events(aggregate, events[0])
+        events = access.find_events_by_aggregate_id(aggregate_id)
+        expect(events.length).to eq(1)
+      end
+
+      it "adds timestamps to all events and associates them to the aggregate" do
+        access.store_events(aggregate, events)
+        events = access.find_events_by_aggregate_id(aggregate_id)
+        expect(events.map(&:timestamp).all?).to be_truthy
+      end
+
+      it "updates the aggregate version" do
+        access.store_events(aggregate, events)
+        events = access.find_events_by_aggregate_id(aggregate_id)
+        version = events.map(&:aggregate_version).max
+
+        reloaded_aggregate = aggregate_access.find(aggregate.id)
+        expect(reloaded_aggregate.aggregate_version).to eq(version)
+      end
+
+      context "when the aggregate version of an event is incorrect" do
+        it "throws an error" do
+          event = { aggregate_version: 100 }
+          expect { access.store_events(aggregate, [event])}.to raise_error(Errors::ConcurrencyError)
+        end
+      end
+    end
+
+    describe "#find_events_by_aggregate_id" do
+      context "when there are events" do
+        it "returns correct events" do
+          access.store_events(aggregate, events)
+
+          stored_events = access.find_events_by_aggregate_id(aggregate.aggregate_id)
+          expect(stored_events.map(&:aggregate_table_id)).to all(eq(aggregate.id))
+          expect(stored_events.size).to eq(events.size)
+          expect(stored_events).to all(respond_to(:merge))
+        end
+      end
+    end
+
+    describe "#after_snapshot" do
+      it "returns events after the given snapshot" do
+        access.store_events(aggregate, events.first)
+
+        snapshot_id = snapshot_access.record_snapshot(aggregate.aggregate_id, { aggregate_version: 1, event_data: "foo"})
+        snapshot = snapshot_access.find(snapshot_id)
+
+        access.store_events(aggregate, events.last)
+
+        events = access.after_snapshot(snapshot)
+        expect(events.count).to eq(1)
+        expect(events.first[:event_data]).to eq("foo_data")
+      end
+    end
+
+  end
+end

data/spec/event_store_with_context_spec.rb

@@ -5,7 +5,7 @@ module SandthornDriverSequel
 		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 retreiving in another") do
+		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"}
@@ -14,10 +14,10 @@ module SandthornDriverSequel
 			end
 			let(:aggregate_id) {"c0456e26-e29a-4f67-92fa-130b3a31a39b"}
 			it "should not find them" do
-				event_store_without_context.save_events test_events, 0, aggregate_id, String
-				events = event_store_without_context.get_aggregate_events aggregate_id, String
+				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, String
+				events_2 = event_store_with_context.get_aggregate_events aggregate_id
 				expect(events_2.length).to eql 0
 			end
 		end

data/spec/get_events_spec.rb

@@ -4,35 +4,42 @@ module SandthornDriverSequel
 	describe EventStore do
 		before(:each) { prepare_for_test }
 		let(:test_events_a) do
-			e = [] 
+			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 = []
 			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 = []
 			e << {aggregate_version: 1, event_name: "new", event_data: "C1" }
 		end
 		let(:test_events_c_2) do
-			e = [] 
+			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, 0, aggregate_id_a, SandthornDriverSequel::EventStore
-			event_store.save_events test_events_c, 0, aggregate_id_c, String
-			event_store.save_events test_events_b, 0, aggregate_id_b, SandthornDriverSequel::SequelDriver
-			event_store.save_events test_events_c_2, 1, aggregate_id_c, String
+			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
-		context "when using get_events" do 
+
+		let(:event) { event_store.get_events(take: 1).first }
+
+		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, include_events: [:new], take: 2}
 				it "should find 2 events" do
@@ -51,8 +58,8 @@ module SandthornDriverSequel
 			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 , exclude_events: [:foo],  include_events: [:new, :foo, "bar", :flubber], take: 100 
+					first_seq_number = all[0][:sequence_number]
+					event_store.get_events after_sequence_number: first_seq_number , exclude_events: [:foo],  include_events: [:new, "bar", :flubber], take: 100
 				end
 				it "should find 4 events" do
 					events.length.should eql 4
@@ -89,7 +96,7 @@ module SandthornDriverSequel
 					events.each { |e| e[:sequence_number].should be > check; check = e[:sequence_number] }
 				end
 				it "should contain only events for aggregate_id_a and aggregate_id_c" do
-					events.each { |e| [aggregate_id_a, aggregate_id_c].include?(e[:aggregate_id]).should be_true }
+					events.each { |e| [aggregate_id_a, aggregate_id_c].include?(e[:aggregate_id]).should be_truthy }
 				end
 			end
 			context "and getting events for SandthornDriverSequel::EventStore after 0" do
@@ -147,4 +154,4 @@ module SandthornDriverSequel
 		end
 
 	end
-end
+end

data/spec/migration_specifying_domain_spec.rb

@@ -7,29 +7,29 @@ module SandthornDriverSequel
 			aggregates = :aggregates
 			snapshots = :snapshots
 			if context
-				events = "#{context}_#{events}".to_sym 
-				aggregates = "#{context}_#{aggregates}".to_sym 
-				snapshots = "#{context}_#{snapshots}".to_sym 
+				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_true, "expected table :#{events} to exist, but it didn't"
-				expect(db.table_exists? aggregates).to be_true, "expected table :#{aggregates} to exist, but it didn't"
-				expect(db.table_exists? snapshots).to be_true, "expected table :#{snapshots} to exist, but it didn't"
-			end	
+				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 
+		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 
+		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
+end

data/spec/saving_events_spec.rb

@@ -6,68 +6,69 @@ module SandthornDriverSequel
 		before(:each) { prepare_for_test }
 		context "when saving a prefectly sane event stream" do
 			let(:test_events) do
-				e = [] 
+				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 retreive events on the aggregate" do
-				event_store.save_events test_events, 0, aggregate_id, String
-				events = event_store.get_aggregate_events aggregate_id, String
+
+      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
 				events.length.should eql test_events.length
 			end
-			it "should fail if aggregate does not exist and version is above 0" do
-				expect { event_store.save_events test_events, 1, aggregate_id, String }.to raise_error SandthornDriverSequel::Errors::NoAggregateError
-			end
-			it "should fail if originating version is wrong" do
-				event_store.save_events test_events, 0, aggregate_id, String
-				expect { event_store.save_events test_events, 102, aggregate_id, String }.to raise_error SandthornDriverSequel::Errors::WrongAggregateVersionError
-			end
+
 			it "should have correct keys when asking for events" do
-				event_store.save_events test_events, 0, aggregate_id, String
+				event_store.save_events test_events, aggregate_id, String
 				events = event_store.get_aggregate aggregate_id, String
 				event = events.first
 				event[:event_data].should eql(test_events.first[:event_data])
-      			event[:event_name].should eql("new")
-      			event[:aggregate_id].should eql aggregate_id
-      			event[:aggregate_version].should eql 1
-      			event[:sequence_number].should be_a(Fixnum)
-      			event[:timestamp].should be_a(Time)
+        event[:event_name].should eql("new")
+        event[:aggregate_id].should eql aggregate_id
+        event[:aggregate_version].should eql 1
+        event[:sequence_number].should be_a(Fixnum)
+        event[:timestamp].should be_a(Time)
 			end
-		end
+    end
+
 		context "when saving two aggregate types" do
 			let(:test_events_1) do
-				e = [] 
+				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	
+				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 = []
 				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	
+			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, 0, aggregate_id_1, String
-				event_store.save_events test_events_2, 0, aggregate_id_2, Hash
-				event_store.save_events test_events_2, 0, aggregate_id_3, String
-			end
+				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_typenames
+				names = event_store.get_all_types
 				names.length.should eql 2
 				names.first.should eql "Hash"
 				names.last.should eql "String"
-			end
+      end
+
 			it "should list the aggregate ids when asking for get_aggregate_list_by_typename" do
-				ids = event_store.get_aggregate_list_by_typename String
+				ids = event_store.get_aggregate_ids(aggregate_type: String)
 				ids.length.should eql 2
-				ids.any? { |e| e == aggregate_id_1 }.should be_true
-				ids.any? { |e| e == aggregate_id_3 }.should be_true
+				ids.any? { |e| e == aggregate_id_1 }.should be_truthy
+				ids.any? { |e| e == aggregate_id_3 }.should be_truthy
 			end
-		end
+    end
+
 		context "when saving events that are serilized with msgpack" do
 			let(:test_data) { {name: "test", hash: {t: 123}} }
 			let(:test_events) do
@@ -76,12 +77,14 @@ module SandthornDriverSequel
 				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 serilized with msgpack" do
-				event_store.save_events test_events, 0, aggregate_id_1, 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
+      end
+
 		end
 
 	end
-end
+end