sandthorn_driver_sequel_2 0.0.1

data/lib/sandthorn_driver_sequel_2/migration.rb

@@ -0,0 +1,81 @@
+require 'sandthorn_driver_sequel_2/sequel_driver'
+module SandthornDriverSequel2
+  class Migration
+    include EventStoreContext
+    attr_reader :driver, :context
+    def initialize url: nil, context: nil
+      @driver = SequelDriver.new url: url
+      @context = context
+    end
+    def migrate!
+      ensure_migration_table!
+      events
+      snapshots
+    end
+    private
+    def clear_for_test
+      driver.execute do |db|
+        db[snapshots_table_name].truncate
+        db[events_table_name].truncate
+      end
+    end
+
+    def events
+      events_migration_0 = "#{events_table_name}-20130308"
+      unless has_been_migrated?(events_migration_0)
+        driver.execute_in_transaction do |db|
+          db.create_table(events_table_name) do
+            primary_key :sequence_number
+            String :aggregate_id, fixed: true, size: 36, null: false
+            Integer :aggregate_version, null: false
+            String :aggregate_type, size: 255, null: false
+            String :event_name, size: 255, null: false
+            String :event_data, text: true, null: true
+            DateTime :timestamp, null: false
+
+            index [:aggregate_type]
+            index [:event_name]
+            index [:aggregate_id]
+            index [:aggregate_id, :aggregate_version], unique: true
+          end
+          was_migrated events_migration_0, db
+        end
+      end
+    end
+    def snapshots
+      snapshot_migration_0 = "#{snapshots_table_name}-20130312"
+      unless has_been_migrated?(snapshot_migration_0)
+        driver.execute_in_transaction do |db|
+          db.create_table(snapshots_table_name) do
+            primary_key :id
+            Integer :aggregate_version, null: false
+            String :snapshot_data, text: true, null: false
+            String :aggregate_id, fixed: true, size: 36, null: false
+            index [:aggregate_id], unique: true
+          end
+          was_migrated snapshot_migration_0, db
+        end
+      end
+    end
+
+    def migration_table_name
+      :event_store_sequel_migrations
+    end
+    def ensure_migration_table!
+      driver.execute do |db|
+        db.create_table?(migration_table_name) do
+          primary_key :id
+          String :migration_name, null: false
+          index [:migration_name], unique: true
+          DateTime :timestamp, :null=>false
+        end
+      end
+    end
+    def has_been_migrated? migration_name
+      driver.execute {|db| db[migration_table_name].all.any? { |e| e[:migration_name]==migration_name } }
+    end
+    def was_migrated migration_name, db
+      db[migration_table_name].insert timestamp: Time.now.utc, migration_name: migration_name
+    end
+  end
+end

data/lib/sandthorn_driver_sequel_2/sequel_driver.rb

@@ -0,0 +1,23 @@
+require 'sequel'
+
+module SandthornDriverSequel2
+  class SequelDriver
+
+    def initialize args = {}
+      @url = args.fetch(:url)
+      Sequel.default_timezone = :utc
+      @db = Sequel.connect(@url)
+    end
+
+    def execute
+      yield @db
+    end
+
+    def execute_in_transaction &block
+      @db.transaction do
+        block.call(@db)
+      end
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel_2/storage.rb

@@ -0,0 +1,43 @@
+module SandthornDriverSequel2
+  class Storage
+    # = Storage
+    # Abstracts access to contextualized database tables.
+    #
+    # == Rationale
+    # Provide object-oriented access to the different tables to other objects.
+    # Make it unnecessary for them to know about the current context.
+    include EventStoreContext
+
+    attr_reader :db
+
+    def initialize(db, context, events_file_path)
+      @db = db
+      @context = context
+      @event_file = File.open(events_file_path, "a") if events_file_path
+      last_event = events_table.order(:sequence_number).limit(1).last
+      last_sequence_number = last_event ? last_event[:sequence_number] : 0
+      @event_file_output_wrapper = FileOutputWrapper::Events.new @event_file, last_sequence_number if @event_file
+    end
+
+    # Returns a Sequel::Model for accessing events
+    def events
+      agg = Class.new(Sequel::Model(events_table))
+      return @event_file_output_wrapper.events agg if @event_file
+      agg
+    end
+
+    # Returns a Sequel::Model for accessing snapshots
+    def snapshots
+      Class.new(Sequel::Model(snapshots_table))
+    end
+
+    def events_table
+      db[events_table_name]
+    end
+
+    def snapshots_table
+      db[snapshots_table_name]
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel_2/utilities/array.rb

@@ -0,0 +1,13 @@
+module SandthornDriverSequel2
+  module Utilities
+    def self.array_wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/sandthorn_driver_sequel_2/utilities.rb

@@ -0,0 +1 @@
+require "sandthorn_driver_sequel_2/utilities/array"

data/lib/sandthorn_driver_sequel_2/version.rb

@@ -0,0 +1,3 @@
+module SandthornDriverSequel2
+  VERSION = "0.0.1"
+end

data/lib/sandthorn_driver_sequel_2/wrappers/event_wrapper.rb

@@ -0,0 +1,12 @@
+require 'delegate'
+module SandthornDriverSequel2
+  class EventWrapper < SimpleDelegator
+
+    [:aggregate_version, :event_name, :event_data, :timestamp, :aggregate_id, :aggregate_type].each do |attribute|
+      define_method(attribute) do
+        fetch(attribute)
+      end
+    end
+
+  end
+end

data/lib/sandthorn_driver_sequel_2/wrappers/snapshot_wrapper.rb

@@ -0,0 +1,11 @@
+module SandthornDriverSequel2
+  class SnapshotWrapper < SimpleDelegator
+    def aggregate_version
+      self[:aggregate_version]
+    end
+
+    def data
+      self[:event_data]
+    end
+  end
+end

data/lib/sandthorn_driver_sequel_2/wrappers.rb

@@ -0,0 +1,2 @@
+require "sandthorn_driver_sequel_2/wrappers/event_wrapper"
+require "sandthorn_driver_sequel_2/wrappers/snapshot_wrapper"

data/lib/sandthorn_driver_sequel_2.rb

@@ -0,0 +1,24 @@
+require "sandthorn_driver_sequel_2/version"
+require "sandthorn_driver_sequel_2/utilities"
+require "sandthorn_driver_sequel_2/wrappers"
+require "sandthorn_driver_sequel_2/event_query"
+require "sandthorn_driver_sequel_2/event_store_context"
+require "sandthorn_driver_sequel_2/access"
+require "sandthorn_driver_sequel_2/storage"
+require 'sandthorn_driver_sequel_2/event_store'
+require 'sandthorn_driver_sequel_2/errors'
+require 'sandthorn_driver_sequel_2/migration'
+require 'sandthorn_driver_sequel_2/file_output_wrappers/events'
+
+module SandthornDriverSequel2
+  class << self
+    def driver_from_url url: nil, context: nil, events_file_path: nil
+      EventStore.new url: url, context: context, events_file_path: events_file_path
+    end
+    def migrate_db url: nil, context: nil
+      migrator = Migration.new url: url, context: context
+      migrator.migrate!
+    end
+  end
+end
+

data/sandthorn_driver_sequel_2.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sandthorn_driver_sequel_2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sandthorn_driver_sequel_2"
+  spec.version       = SandthornDriverSequel2::VERSION
+  spec.authors       = ["Lars Krantz", "Morgan Hallgren", "Jesper Josefsson"]
+  spec.email         = ["lars.krantz@alaz.se", "morgan.hallgren@gmail.com", "jesper.josefsson@gmail.com"]
+  spec.description   = %q{Sequel driver for Sandthorn}
+  spec.summary       = %q{Sequel driver for Sandthorn that store all data to events table and makes it possible to dump instert to disk}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "gem-release"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-doc"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "autotest-standalone"
+  spec.add_development_dependency "uuidtools"
+  spec.add_development_dependency "ruby-beautify"
+  spec.add_development_dependency "msgpack"
+  spec.add_development_dependency "snappy"
+  spec.add_development_dependency "guard-rspec"
+
+  spec.add_runtime_dependency     "sequel", "~> 4.17"
+  spec.add_runtime_dependency     "pg"
+end

data/spec/asking_for_aggregates_to_snapshot_spec.rb

@@ -0,0 +1,64 @@
+# require 'spec_helper'
+
+# class Foo; end
+# class Bar; end
+
+# module SandthornDriverSequel2
+
+# 	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}
+
+# 			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
+
+
+# 			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
+# end

data/spec/benchmark_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'benchmark'
+require 'yaml'
+
+module Sandthorn
+  module AggregateRoot
+
+    describe "benchmark", benchmark: true do
+
+      before(:each) { prepare_for_test }
+      let(:test_events_20_events) 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"}
+        19.times do |i| 
+           e << {aggregate_version: i+2, event_name: "foo", event_data: "A2"}
+        end
+        e
+      end
+      let(:test_events_one_event) do
+        e = [] 
+        e << {aggregate_version: 1, event_name: "new", event_data: "B1" }
+      end
+      let(:test_events_two_events) 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"}
+      end
+      let(:aggregate_id) {"c0456e26-2345-4f67-92fa-130b3a31a39a"}
+      let(:es) { event_store }
+
+      
+      n = 500
+      describe "save" do
+        it "one event save 500 times" do
+          Benchmark.bm do |x|
+            x.report("new change save find") { for i in 1..n; es.save_events(test_events_one_event, 0, i.to_s, SandthornDriverSequel2::EventStore); end }
+          end
+        end
+        it "two events save 500 times" do
+          Benchmark.bm do |x|
+            x.report("new change save find") { for i in 1..n; es.save_events(test_events_two_events, 0, i.to_s, SandthornDriverSequel2::EventStore); end }
+          end
+        end
+        it "twenty events save 500 times" do
+          Benchmark.bm do |x|
+            x.report("new change save find") { for i in 1..n; es.save_events(test_events_20_events, 0, i.to_s, SandthornDriverSequel2::EventStore); end }
+          end
+        end
+      end
+
+      describe "find" do
+        it "should find one event 500 times" do
+          es.save_events(test_events_one_event, 0, aggregate_id, SandthornDriverSequel2::EventStore)
+
+          Benchmark.bm do |x|
+            x.report("find") { for i in 1..n; es.get_aggregate(aggregate_id, SandthornDriverSequel2::EventStore);  end }
+          end
+        end
+        it "should find two events 500 times" do
+          es.save_events(test_events_two_events, 0, aggregate_id, SandthornDriverSequel2::EventStore)
+
+          Benchmark.bm do |x|
+            x.report("find") { for i in 1..n; es.get_aggregate(aggregate_id, SandthornDriverSequel2::EventStore);  end }
+          end
+        end
+        it "should find twenty events 500 times" do
+          es.save_events(test_events_20_events, 0, aggregate_id, SandthornDriverSequel2::EventStore)
+
+          Benchmark.bm do |x|
+            x.report("find") { for i in 1..n; es.get_aggregate(aggregate_id, SandthornDriverSequel2::EventStore);  end }
+          end
+        end
+
+      end
+       describe "find with snapshot" do
+
+        it "should find one event that is snapshoted 500 times" do
+          snapshot_data = { event_data: YAML.dump(Object.new), aggregate_version: 1 } 
+          es.save_events(test_events_one_event, 0, aggregate_id, SandthornDriverSequel2::EventStore)
+          es.save_snapshot(snapshot_data, aggregate_id, SandthornDriverSequel2::EventStore)
+
+          Benchmark.bm do |x|
+            x.report("find") { for i in 1..n; es.get_aggregate(aggregate_id, SandthornDriverSequel2::EventStore);  end }
+          end
+        end
+        it "should find two events that is snapshoted 500 times" do
+          snapshot_data = { event_data: YAML.dump(Object.new), aggregate_version: 2 } 
+          es.save_events(test_events_two_events, 0, aggregate_id, SandthornDriverSequel2::EventStore)
+          es.save_snapshot(snapshot_data, aggregate_id, SandthornDriverSequel2::EventStore)
+          Benchmark.bm do |x|
+            x.report("find") { for i in 1..n; es.get_aggregate(aggregate_id, SandthornDriverSequel2::EventStore);  end }
+          end
+        end
+        it "should find twenty events that is snapshoted 500 times" do
+          snapshot_data = { event_data: YAML.dump(Object.new), aggregate_version: 19 } 
+          es.save_events(test_events_20_events, 0, aggregate_id, SandthornDriverSequel2::EventStore)
+          es.save_snapshot(snapshot_data, aggregate_id, SandthornDriverSequel2::EventStore)
+
+          Benchmark.bm do |x|
+            x.report("find") { for i in 1..n; es.get_aggregate(aggregate_id, SandthornDriverSequel2::EventStore);  end }
+          end
+        end
+
+      end
+      # it "new save and find 500 aggregates" do
+
+      #   Benchmark.bm do |x|
+      #     x.report("new change save find") { for i in 1..n; es.save_events(test_events_a, 0, i.to_s, SandthornDriverSequel2::EventStore); es.get_aggregate(i.to_s, SandthornDriverSequel2::EventStore);  end }
+      #   end
+
+      # end
+      
+      # it "should commit 500 actions" do
+      #   Benchmark.bm do |x|
+      #     x.report("commit") { for i in 1..n; test_object.change_name "#{i}";  end }
+      #   end
+      # end
+      # it "should commit and save 500 actions" do
+      #   Benchmark.bm do |x|
+      #     x.report("commit save") { for i in 1..n; test_object.change_name("#{i}").save;  end }
+      #   end
+      # end
+    end
+  end
+end

data/spec/driver_interface_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module SandthornDriverSequel2
+	describe EventStore do
+		before(:each) { prepare_for_test }
+		context "interface structure" do
+			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,100 @@
+require 'spec_helper'
+
+module SandthornDriverSequel2
+  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, nil) }
+    let(:aggregate_access) { AggregateAccess.new(storage) }
+    let(:snapshot_access) { SnapshotAccess.new(storage)}
+    let(:access) { EventAccess.new(storage) }
+
+    let(:events) do
+      [
+        {
+          aggregate_version: 1,
+          aggregate_id: aggregate_id,
+          aggregate_type: "Foo",
+          event_name: "new",
+          event_data: "new_data"
+        },{
+          aggregate_version: 2,
+          aggregate_id: aggregate_id,
+          aggregate_type: "Foo",
+          event_name: "foo",
+          event_data: "foo_data"
+        }
+      ]
+    end
+
+    describe "#store_events" do
+
+      it "handles both arrays and single events" do
+        access.store_events(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(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(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, aggregate_id: aggregate_id, aggregate_type: "Foo", event_name: "new", event_data: "noop" }
+          expect { access.store_events([event])}.not_to raise_error
+        end
+      end
+    end
+
+    describe "#find_events_by_aggregate_id" do
+      context "when there are events" do
+        it "returns correct events" do
+          access.store_events(events)
+
+          stored_events = access.find_events_by_aggregate_id(aggregate_id)
+          expect(stored_events.map(&:aggregate_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(events.first)
+
+        snapshot_id = snapshot_access.record_snapshot(aggregate_id, { aggregate_version: 1, event_data: "foo"})
+        snapshot = snapshot_access.find(snapshot_id)
+
+        access.store_events(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_file_output_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module SandthornDriverSequel2
+	describe EventStore do
+		before(:each) { prepare_for_test context: nil; }
+		#after(:each) {File.delete(aggregates_file); File.delete(events_file);}
+		let(:events_file) {"spec/db_file/test_events.csv"}
+		let(:aggregates_file) {"spec/db_file/test_aggregates.csv"}
+		let(:event_store_file_output) { EventStore.new url: event_store_url, events_file_path: events_file }
+		
+		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"}
+
+
+
+		context("when saving to a event_store that store its data to file") do
+			
+			before(:each) { event_store_file_output.save_events test_events, aggregate_id, String }
+				
+			it "should store but not find" do
+				event_store_file_output.save_events test_events, aggregate_id, String
+				expect(event_store_file_output.get_aggregate_events(aggregate_id)).to eq([])
+			end
+			# it "should output one line to aggregates file" do
+			# 	event_store_file_output.save_events test_events, aggregate_id, String
+				
+			# 	fd = File.open aggregates_file
+				
+			# 	l = 0
+			# 	puts "!!!!!"
+			# 	fd.each do |line|
+			# 		l += 1
+			# 		puts "HERE!!! #{line}"
+			# 	end
+			# 	expect(l).to eql 1
+
+			# end
+		end
+	end
+end

data/spec/event_store_with_context_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module SandthornDriverSequel2
+	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