sandthorn_driver_sequel_2 0.0.1

data/spec/get_events_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+module SandthornDriverSequel2
+	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, SandthornDriverSequel2::EventStore
+			event_store.save_events test_events_c, aggregate_id_c, String
+			event_store.save_events test_events_b, aggregate_id_b, SandthornDriverSequel2::SequelDriver
+			event_store.save_events test_events_c_2, aggregate_id_c, String
+		end
+
+		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, 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 SandthornDriverSequel2::EventStore, and String after 0" do
+				let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel2::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 SandthornDriverSequel2::EventStore after 0" do
+				let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel2::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 SandthornDriverSequel2::EventStore after 0" do
+				let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel2::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, SandthornDriverSequel2::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, SandthornDriverSequel2::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

data/spec/migration_specifying_domain_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module SandthornDriverSequel2
+	describe Migration do
+		def check_tables context = nil
+			events = :events
+			snapshots = :snapshots
+			if context
+				events = "#{context}_#{events}".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? 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

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'msgpack'
+
+module SandthornDriverSequel2
+	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])
+        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
+
+		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 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
+      end
+
+		end
+
+	end
+end

data/spec/saving_snapshot_spec.rb

@@ -0,0 +1,77 @@
+# require 'spec_helper'
+# require 'yaml'
+
+# module SandthornDriverSequel2
+# 	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, SandthornDriverSequel2::EventStore }
+# 		let(:save_additional_events) { event_store.save_events additional_events, aggregate_id, SandthornDriverSequel2::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, SandthornDriverSequel2::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
+
+# 			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 SandthornDriverSequel2::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 SandthornDriverSequel2::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

data/spec/snapshot_access_spec.rb

@@ -0,0 +1,125 @@
+# require 'spec_helper'
+
+# module SandthornDriverSequel2
+#   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(:aggregate_access) { AggregateAccess.new(storage) }
+#     let(:event_access) { EventAccess.new(storage) }
+#     let(:aggregate) { aggregate_access.register_aggregate(aggregate_id, "foo") }
+#     let(:access) { SnapshotAccess.new(storage) }
+#     let(:events) do
+#       [
+#           {
+#               aggregate_id: aggregate_id,
+#               aggregate_type: "Foo",
+#               aggregate_version: 1,
+#               event_name: "new",
+#               event_data: "new_data"
+#           },{
+#               aggregate_id: aggregate_id,
+#               aggregate_type: "Foo",
+#               aggregate_version: 2,
+#               event_name: "foo",
+#               event_data: "foo_data"
+#           }
+#       ]
+#     end
+
+#     describe "#find_by_aggregate_id" do
+#       it "returns the correct data" do
+#         aggregate = aggregate_access.register_aggregate(aggregate_id, "foo")
+#         access.record_snapshot(aggregate.aggregate_id, { aggregate_version: 0, event_data: "data" })
+#         aggregate.update(aggregate_version: 1)
+#         snapshot = access.find_by_aggregate_id(aggregate.aggregate_id)
+#         expected = {
+#            # aggregate_table_id: aggregate.id,
+#             aggregate_id: aggregate.aggregate_id,
+#             aggregate_type: "Foo",
+#             aggregate_version: 0,
+#             snapshot_data: "data",
+#             id: snapshot.id
+#         }
+#         expect(snapshot.values).to eq(expected)
+#       end
+#     end
+
+#     describe "#record" do
+#       context "when the aggregate doesn't exist" do
+#         it "raises an error" do
+#           expect { access.record_snapshot("qux", "data") }.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
+#             #aggregate_table_id = aggregate_access.register_aggregate(aggregate_id, "foo").id
+#             expect(access.find_by_aggregate_id(aggregate_id)).to be_nil
+#             access.record_snapshot(aggregate_id, { aggregate_version: 0, event_data: "data"})
+
+#             snapshot = access.find_by_aggregate_id(aggregate_id)
+#             expect(snapshot).to_not be_nil
+#             expect(snapshot.aggregate_id).to eq(aggregate_id)
+#             expect(snapshot.snapshot_data).to eq("data")
+#             expect(snapshot.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
+#               #aggregate = aggregate_access.register_aggregate(aggregate_id, "foo")
+#               expect(access.find_by_aggregate_id(aggregate_id)).to be_nil
+#               access.record_snapshot(aggregate_id, { aggregate_version: 0, aggregate_type: "Foo", event_data: "data"})
+#               event_access.store_events(events)
+#               access.record_snapshot(aggregate_id, { aggregate_version: 2, aggregate_type: "Foo", event_data: "other_data"})
+
+#               snapshot = access.find_by_aggregate_id(aggregate_id)
+#               expect(snapshot).to_not be_nil
+#               expect(snapshot.aggregate_id).to eq(aggregate_id)
+#               expect(snapshot.snapshot_data).to eq("other_data")
+#               expect(snapshot.aggregate_version).to eq(2)
+#             end
+#           end
+
+#           # context "when the versions don't match" do
+#           #   it "raises an error" do
+#           #     aggregate = aggregate_access.register_aggregate(aggregate_id, "foo")
+#           #     aggregate.update(aggregate_version: 10)
+#           #     expect { access.record_snapshot(aggregate_id, snapshot_data) }.to raise_error
+#           #   end
+#           # end
+#         end
+#         context "when the snapshot is fresh" do
+#           it "doesn't record a snapshot" do
+#             aggregate = aggregate_access.register_aggregate(aggregate_id, "foo")
+#             expect(access.find_by_aggregate_id(aggregate_id)).to be_nil
+#             access.record_snapshot(aggregate_id, { aggregate_version: 0, event_data: "data"})
+#             access.record_snapshot(aggregate_id, { aggregate_version: 0, event_data: "new_data"})
+#             snapshot = access.find_by_aggregate_id(aggregate_id)
+#             expect(snapshot.snapshot_data).to eq("data")
+#           end
+#         end
+#       end
+#     end
+
+#     it "can write and read snapshots" do
+#       snapshot_id = access.record_snapshot(aggregate.aggregate_id, { aggregate_version: 0, event_data: "data" })
+#       snapshot = access.find(snapshot_id)
+#       expect(snapshot).to_not be_nil
+#       expect(snapshot.snapshot_data).to eq("data")
+#       expect(snapshot)
+#     end
+
+#     def generate_uuid
+#       SecureRandom.uuid
+#     end
+#   end
+# end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'sandthorn_driver_sequel_2'
+require 'sandthorn_driver_sequel_2/migration'
+require 'ap'
+require 'uuidtools'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.filter_run_excluding benchmark: true
+  config.order = 'random'
+end
+def prepare_for_test context: :test
+  migrator = SandthornDriverSequel2::Migration.new url: event_store_url, context: context
+  migrator.migrate!
+  migrator.send(:clear_for_test)
+end
+
+def event_store_url
+  "sqlite://spec/db/event_store.sqlite3"
+  #"postgres://morganhallgren@localhost:5432/test_1"
+end
+
+def event_store context: :test
+  SandthornDriverSequel2::EventStore.new url: event_store_url, context: context
+end

data/spec/storage_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module SandthornDriverSequel2
+
+  describe Storage do
+    let(:context) { :test }
+    before do
+      prepare_for_test(context: context)
+    end
+    let(:db) { Sequel.connect(event_store_url) }
+    let(:driver) { SequelDriver.new(event_store_url)}
+    let(:storage) { Storage.new(db, context, nil) }
+
+    # describe "anonymous aggegrate class" do
+    #   it "can insert and read data" do
+    #     create_aggregate
+    #     aggregate = storage.aggregates.first(aggregate_id: "foo", aggregate_type: "Foo")
+    #     expect(aggregate).to_not be_nil
+    #   end
+
+    #   it "can update data" do
+    #     create_aggregate
+    #     storage.aggregates.where(aggregate_id: "foo").update(aggregate_version: 2)
+    #     aggregate = storage.aggregates.first(aggregate_id: "foo")
+    #     expect(aggregate.aggregate_version).to eq(2)
+    #   end
+    # end
+
+    describe "anonymous event class" do
+      it "can insert and read data" do
+        data, event_id = create_event
+        event = storage.events.first(sequence_number: event_id).values
+        expected = data.merge(sequence_number: event_id)
+        expected_time = expected.delete(:timestamp)
+        actual_time = event.delete(:timestamp)
+        expect(event).to eq(expected)
+        expect(actual_time.to_i).to eq(actual_time.to_i)
+      end
+
+      it "can update data" do
+        data, event_id = create_event
+        storage.events.where(sequence_number: event_id).update(event_name: "qux")
+        event = storage.events.first(sequence_number: event_id)
+        expect(event.event_name).to eq("qux")
+      end
+    end
+
+    # def create_aggregate
+    #   storage.aggregates.insert(aggregate_id: "foo", aggregate_type: "Foo")
+    # end
+
+    def create_event
+      data = {
+          aggregate_id: "foo",
+          aggregate_version: 1,
+          aggregate_type: "Foo",
+          event_name: "foo",
+          event_data: "bar",
+          timestamp: Time.now.utc
+      }
+      event_id = storage.events.insert(data)
+      return data, event_id
+    end
+
+  end
+end

data/spec/storage_to_file_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module SandthornDriverSequel2
+
+  describe Storage do
+
+    context "ToFile" do
+
+      let(:context) { :test }
+      let(:event_file) { "spec/db_file/events.csv" }
+
+      before do
+        prepare_for_test(context: context)
+      end
+      after(:each) do
+        File.delete(event_file)
+      end
+      let(:db) { Sequel.connect(event_store_url) }
+      let(:driver) { SequelDriver.new(event_store_url)}
+      let(:storage) { Storage.new(db, context, event_file) }
+
+      describe "anonymous event class" do
+        it "insert no data to the db" do
+          data, event_id = create_event
+          event = storage.events.first
+          
+          expect(event).to be_nil
+        end
+
+        it "can read data from file" do
+          data, event_id = create_event
+          file = File.open event_file
+          expect(file.first).to eq("1;foo;1;Foo;foo;bar;#{data[:timestamp]}\n")
+        end
+      end
+
+      def create_event
+        data = {
+            aggregate_id: "foo",
+            aggregate_version: 1,
+            aggregate_type: "Foo",
+            event_name: "foo",
+            event_data: "bar",
+            timestamp: Time.now.utc
+        }
+        event_id = storage.events.insert(data)
+        storage.events.flush
+        return data, event_id
+      end
+
+    end
+  end
+end