sandthorn_driver_event_store 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72f4778deae2b0d24a481a8665fcdbb3ee98b55a
+  data.tar.gz: b6474c0758bf60c41f95b4189229dd364dcc4bed
+SHA512:
+  metadata.gz: a693d6007d3b25e7d685c97458cf7ef58e02a4b66e376adb27238c6a88d706fc0203c01dcc21e555d8dc77edd914a448d52d880a78207ca23342c520c5251686
+  data.tar.gz: 374ab395ffefc0f14d3d55922656db88ff2eaba211aafb2616785629af92d0c07e18fdfdf6aaed2f765512075ea45c21d30e2dffb3acaa484e08ab46fa938cf9

data/.autotest

@@ -0,0 +1,3 @@
+Autotest.add_hook :initialize do |at|
+    %w{.git spec/db coverage}.each {|exception| at.add_exception(exception)}
+end

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.sqlite3
+.idea
+spec/db_file/test_events.csv

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format d

data/.ruby-gemset

@@ -0,0 +1 @@
+sandthorn_driver_event_store

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'http_eventstore', git: 'git://github.com/hallgren/http_eventstore.git', branch: 'event_store_version_3' #path: '../http_eventstore'

data/Guardfile

@@ -0,0 +1,7 @@
+interactor :simple
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/sandthorn_driver_event_store/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Morgan Hallgren
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# Sandthorn Event Store driver
+
+A [Event Store](geteventstore.com) driver for [Sandthorn](https://github.com/Sandthorn/sandthorn).
+
+This driver is a write upon [http_eventstore](https://github.com/arkency/http_eventstore) from [Arkency](http://arkency.com)
+
+Currently only a subset of functionallity is implemented contra the [sandthorn_sequel_driver](https://github.com/Sandthorn/sandthorn_sequel_driver)
+
+* save_events
+* find
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sandthorn_driver_event_store'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sandthorn_driver_event_store
+
+## Usage
+
+    SandthornDriverEventStore.driver host: "localhost", port: 2113
+   
+## Todo
+
+ * All - Get all events based on Aggregate type (Class)
+ * Get events - Functionallity for [Sandthorn Sequel Projection](https://github.com/Sandthorn/sandthorn_sequel_projection) 
+ * Implement snapshoting, now all event of an aggregate has to be fetched to build the aggregate.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+task :benchmark do
+	sh "ulimit -n 8192 && rspec --tag benchmark"
+end

data/lib/sandthorn_driver_event_store/access/event_access.rb

@@ -0,0 +1,57 @@
+module SandthornDriverEventStore
+  class EventAccess < Access::Base
+    # = EventAccess
+    # Reads and writes events.
+
+    def store_events(events = [])
+      events = Utilities.array_wrap(events)
+      timestamp = Time.now.utc
+      stream_name = events.first[:aggregate_id]
+
+      event_store_events = events.map do |event|
+        build_event_data(timestamp, event)
+      end
+
+      if event_store_events.any?
+        expected_version = event_store_events.first[:position] > 0 ? event_store_events.first[:position]-1 : nil
+        storage.append_to_stream(stream_name, event_store_events, expected_version)
+      end
+    end
+
+    def find_events_by_aggregate_id(aggregate_id)
+      return storage.read_all_events_forward(aggregate_id).map { |event|
+        {
+          event_args:         JSON.parse(event.data.to_json, symbolize_names: true),
+          aggregate_id:       event.stream_name,
+          aggregate_version:  event.position+1,
+          event_name:         event.type
+        }
+      }
+    end
+
+    def get_events(*args)
+      query_builder = EventQuery.new(storage)
+      query_builder.build(*args)
+      wrap(query_builder.events)
+    end
+
+    private
+
+    def wrap(arg)
+      events = Utilities.array_wrap(arg)
+      events.map { |e| EventWrapper.new(e.values) }
+    end
+
+    def build_event_data(timestamp, event)
+      {
+        event_type: event[:event_name].to_s,
+        data: event[:event_args],
+        event_id: SecureRandom.uuid,
+        id: event[:aggregate_id],
+        position: event[:aggregate_version]-1,
+        created_time: timestamp
+      }
+    end
+
+  end
+end

data/lib/sandthorn_driver_event_store/access.rb

@@ -0,0 +1,18 @@
+module SandthornDriverEventStore
+  module Access
+    class Base
+      # = Access::Base
+      # Inheriting classes use +storage+ to provide access to a
+      # particular database model/table.
+      def initialize(storage)
+        @storage = storage
+      end
+
+      private
+
+      attr_reader :storage
+    end
+  end
+end
+
+require "sandthorn_driver_event_store/access/event_access"

data/lib/sandthorn_driver_event_store/errors.rb

@@ -0,0 +1,49 @@
+module SandthornDriverEventStore::Errors
+  Error = Class.new(StandardError)
+  InternalError = Class.new(Error)
+  NoAggregateError = Class.new(Error)
+  EventFormatError = Class.new(Error)
+
+  class ConcurrencyError < Error
+    attr_reader :event, :aggregate
+    def initialize(event, aggregate)
+      @event = event
+      @aggregate = aggregate
+      super(create_message)
+    end
+
+    def create_message
+      "#{aggregate.aggregate_type} with id #{aggregate.aggregate_id}: " +
+      "expected event with version #{aggregate.aggregate_version}, but got #{event.aggregate_version}"
+    end
+  end
+
+  class WrongAggregateVersionError < Error;
+    def initialize(aggregate, version)
+      @aggregate = aggregate
+      @version = version
+      super(create_message)
+    end
+
+    def create_message
+      "#{@aggregate[:aggregate_type]} with id #{@aggregate[:aggregate_id]}" +
+      " should be at version #{@version}" +
+      " but was #{@aggregate[:aggregate_version]} in the event store."
+    end
+  end
+
+  class WrongSnapshotVersionError < Error
+    attr_reader :aggregate, :version
+    def initialize(aggregate, version)
+      @aggregate = aggregate
+      @version = version
+      super(create_message)
+    end
+
+    def create_message
+      "#{aggregate[:aggregate_type]} with id #{aggregate[:aggregate_id]}: tried to save snapshot with version "+
+      "#{version}, but current version is at #{aggregate[:aggregate_version]}"
+    end
+  end
+
+end

data/lib/sandthorn_driver_event_store/event_query.rb

@@ -0,0 +1,65 @@
+module SandthornDriverEventStore
+  class EventQuery
+    def initialize(storage)
+      @storage = storage
+    end
+
+    def build(
+      stream_name:,
+      take: 0,
+      after_sequence_number: 0)
+
+      query = storage.events
+      query = add_sequence_number(query, after_sequence_number)
+      query = add_select(query)
+      query = add_limit(query, take)
+      @query = query.order(:sequence_number)
+    end
+
+    def events
+      @query.all
+    end
+
+    private
+
+    attr_reader :storage
+
+    def add_limit(query, take)
+      if take > 0
+        query.limit(take)
+      else
+        query
+      end
+    end
+
+    def add_select(query)
+      query.select(*select_columns)
+    end
+
+    def select_columns
+      aggregate_version = Sequel.qualify(storage.events_table_name, :aggregate_version)
+      aggregate_id = Sequel.qualify(storage.events_table_name, :aggregate_id)
+      [
+        :aggregate_type,
+        aggregate_version,
+        aggregate_id,
+        :sequence_number,
+        :event_name,
+        :event_data,
+        :timestamp
+      ]
+    end
+
+    def add_sequence_number(query, after_sequence_number)
+      query.where { sequence_number > after_sequence_number }
+    end
+
+    def add_aggregate_types(query, aggregate_types)
+      if aggregate_types.any?
+        query = query.where( :aggregate_type => aggregate_types )
+      end
+      query
+    end
+
+  end
+end

data/lib/sandthorn_driver_event_store/event_store.rb

@@ -0,0 +1,48 @@
+module SandthornDriverEventStore
+  class EventStore
+
+    attr_reader :driver
+
+    def initialize event_store_driver:
+      @driver = event_store_driver
+      driver.execute do |db|
+        @storage = db
+      end
+    end
+
+    def save_events events, aggregate_id, class_name
+      driver.execute do |db|
+        event_access = get_event_access(db)
+        events = events.map { |event| event[:aggregate_type] = class_name; event[:aggregate_id] = aggregate_id; event;}
+        event_access.store_events(events)
+      end
+    end
+
+    def find aggregate_id
+      driver.execute do |db|
+        event_access = get_event_access(db)
+        event_access.find_events_by_aggregate_id(aggregate_id)
+      end
+    end
+
+    def all aggregate_type
+      raise :NotImplemented
+    end
+
+    def get_events(*args)
+      raise :NotImplemented
+    end
+
+
+    private
+
+    def get_event_access(db)
+      EventAccess.new(storage(db))
+    end
+
+    def storage(db)
+      @storage
+    end
+
+  end
+end

data/lib/sandthorn_driver_event_store/event_store_driver.rb

@@ -0,0 +1,23 @@
+require 'http_eventstore'
+
+module SandthornDriverEventStore
+  class EventStoreDriver
+
+    def initialize host:, port:, page_size:
+
+      @connection = HttpEventstore::Connection.new do |config|
+         #default value is '127.0.0.1'
+         config.endpoint = host
+         #default value is 2113
+         config.port = port
+         #default value is 20 entries per page
+         config.page_size = page_size
+      end
+    end
+
+    def execute
+      yield @connection
+    end
+
+  end
+end

data/lib/sandthorn_driver_event_store/utilities/array.rb

@@ -0,0 +1,13 @@
+module SandthornDriverEventStore
+  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_event_store/utilities.rb

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

data/lib/sandthorn_driver_event_store/version.rb

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

data/lib/sandthorn_driver_event_store/wrappers/event_wrapper.rb

@@ -0,0 +1,12 @@
+require 'delegate'
+module SandthornDriverEventStore
+  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_event_store/wrappers.rb

@@ -0,0 +1 @@
+require "sandthorn_driver_event_store/wrappers/event_wrapper"

data/lib/sandthorn_driver_event_store.rb

@@ -0,0 +1,18 @@
+require "sandthorn_driver_event_store/version"
+require "sandthorn_driver_event_store/utilities"
+require "sandthorn_driver_event_store/wrappers"
+require "sandthorn_driver_event_store/event_query"
+require "sandthorn_driver_event_store/access"
+require 'sandthorn_driver_event_store/event_store'
+require 'sandthorn_driver_event_store/event_store_driver'
+require 'sandthorn_driver_event_store/errors'
+
+module SandthornDriverEventStore
+  class << self
+    def driver host:, port:, page_size: 20
+      driver = SandthornDriverEventStore::EventStoreDriver.new host: host, port: port, page_size: page_size
+      return SandthornDriverEventStore::EventStore.new event_store_driver: driver
+    end
+  end
+end
+

data/sandthorn_driver_event_store.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sandthorn_driver_event_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sandthorn_driver_event_store"
+  spec.version       = SandthornDriverEventStore::VERSION
+  spec.authors       = ["Morgan Hallgren"]
+  spec.email         = ["morgan.hallgren@gmail.com"]
+  spec.description   = %q{Event Store driver for Sandthorn}
+  spec.summary       = %q{Event Store driver for Sandthorn}
+  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 "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     "http_eventstore"
+end

data/spec/driver_interface_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module SandthornDriverEventStore
+	describe EventStore do
+		before(:each) { prepare_for_test }
+		context "interface structure" do
+			let(:subject) { event_store }
+      methods = [
+        :save_events,
+        :find,
+        :all,
+        :get_events,
+        :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,68 @@
+require 'spec_helper'
+
+module SandthornDriverEventStore
+  describe EventAccess do
+
+    before do
+      prepare_for_test
+    end
+
+    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) { return event_store_driver.execute { |db| return db; } }
+    let(:access) { EventAccess.new(storage) }
+
+    let(:events) do
+      [
+        {
+          aggregate_version: 1,
+          aggregate_id: aggregate_id,
+          aggregate_type: "Foo",
+          event_name: "new",
+          event_args: {test: "new_data"}
+        },{
+          aggregate_version: 2,
+          aggregate_id: aggregate_id,
+          aggregate_type: "Foo",
+          event_name: "foo",
+          event_args: {test: "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
+
+      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])}.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.size).to eq(events.size)
+          expect(stored_events).to all(respond_to(:merge))
+          stored_events.each { |event|
+            expect(event[:aggregate_id]).to eql aggregate_id
+          }
+        end
+      end
+    end
+
+  end
+end

data/spec/get_events_spec.rb

@@ -0,0 +1,129 @@
+# require 'spec_helper'
+# require 'securerandom'
+
+# module SandthornDriverEventStore
+# 	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) { SecureRandom.uuid }
+# 		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) { SecureRandom.uuid }
+# 		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) { SecureRandom.uuid }
+# 		before(:each) do
+# 			event_store.save_events test_events_a, aggregate_id_a, SandthornDriverEventStore::EventStore
+# 			event_store.save_events test_events_c, aggregate_id_c, String
+# 			event_store.save_events test_events_b, aggregate_id_b, SandthornDriverEventStore::EventStore
+# 			event_store.save_events test_events_c_2, aggregate_id_c, String
+# 		end
+
+# 		let(:event) { event_store.find(aggregate_id_c).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 stream_name: "test", after_sequence_number: nil, 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 SandthornDriverEventStore::EventStore, and String after 0" do
+# 				let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverEventStore::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 SandthornDriverEventStore::EventStore after 0" do
+# 				let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverEventStore::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 SandthornDriverEventStore::EventStore after 0" do
+# 				let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverEventStore::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, SandthornDriverEventStore::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, SandthornDriverEventStore::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/in_memory_es.rb

@@ -0,0 +1,95 @@
+#Copied from 'http_eventstore' spec
+
+require 'json'
+
+module HttpEventstore
+  class InMemoryEs
+
+    def initialize(endpoint, port, page_size)
+      @endpoint = Endpoint.new(endpoint, port)
+      @page_size = page_size
+      @event_store = {}
+    end
+    attr_reader :endpoint, :page_size, :event_store
+
+    def append_to_stream(stream_name, event_data, expected_version = nil)
+      unless event_store.key?(stream_name)
+        event_store[stream_name] = []
+      end
+
+      id = event_store[stream_name].length
+      event_store[stream_name].unshift({'eventId' => event_data.event_id, 'data' => event_data.data.to_json, 'eventType' => event_data.type, 'positionEventNumber' => id})
+
+    end
+
+    def append_events_to_stream(stream_name, events_data=[], expected_version = nil)
+      unless event_store.key?(stream_name)
+        event_store[stream_name] = []
+      end
+      events_data.each do |event_data|
+        id = event_store[stream_name].length
+        event_store[stream_name].unshift({'eventId' => event_data.event_id, 'data' => event_data.data.to_json, 'eventType' => event_data.type, 'positionEventNumber' => id})
+      end
+    end
+
+    def delete_stream(stream_name, hard_delete)
+      event_store.delete(stream_name)
+    end
+
+    def read_stream_page(uri)
+      params = uri.scan(/\/(\w+)\/(\d+)/)
+      stream_name = params[0][0]
+      last_index = params[0][1].to_i
+      direction = params[1][0]
+      count = params[1][1].to_i
+      if direction == 'next'
+        read_stream_backward(stream_name, last_index, count)
+      else
+        read_stream_forward(stream_name, last_index, count)
+      end
+    end
+
+    def read_stream_backward(stream_name, start, count)
+      if event_store.key?(stream_name)
+        start_index = start == :head ? event_store[stream_name].length - 1 : start
+        last_index = start_index - count
+        entries = event_store[stream_name].select do |event|
+          event['positionEventNumber'] > last_index && event['positionEventNumber'] <= start_index
+        end
+        { 'entries' => entries, 'links' => links(last_index, stream_name, 'next', entries, count)}
+      end
+    end
+
+    def read_stream_forward(stream_name, start_index, count, long_pool = 0)
+      if event_store.key?(stream_name)
+        last_index = start_index + count
+        entries = event_store[stream_name].reverse.select do |event|
+          event['positionEventNumber'] < last_index && event['positionEventNumber'] >= start_index
+        end
+        { 'entries' => entries.reverse!, 'links' => links(last_index, stream_name, 'previous', entries, count)}
+      end
+    end
+
+    def reset!
+      @event_store = {}
+    end
+
+    def endpoint
+      Endpoint.new('127.0.0.1', 2113)
+    end
+
+    private
+
+    def links(batch_size, stream_name, direction, entries, count)
+      if entries.empty? || batch_size < 0
+        []
+      else
+        [{
+             'uri' => "http://#{endpoint.url}/streams/#{stream_name}/#{batch_size}/#{direction}/#{count}",
+             'relation' => direction
+         }]
+      end
+    end
+
+  end
+end

data/spec/in_memory_event_store_driver.rb

@@ -0,0 +1,16 @@
+require 'http_eventstore'
+require 'in_memory_es'
+
+module SandthornDriverEventStore
+  class InMemoryEventStoreDriver
+
+    def initialize
+      @connection = HttpEventstore::Connection.new { |config| config.client = HttpEventstore::InMemoryEs.new("localhost", 2113, 20) }
+    end
+
+    def execute
+      yield @connection
+    end
+
+  end
+end

data/spec/saving_events_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'securerandom'
+
+module SandthornDriverEventStore
+	describe EventStore do
+		context "when saving a prefectly sane event stream" do
+			let(:test_events) do
+				e = []
+				e << {aggregate_version: 1, event_name: "new", event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"e147e4bb-e98d-4008-ae9a-0bccce314d7b"}]}}
+				e << {aggregate_version: 2, event_name: "foo", event_args: {:method_name=>"foo", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"e147e4bb-e98d-4008-ae9a-0bccce314d7b"}]}}
+				e << {aggregate_version: 3, event_name: "flubber", event_args: {:method_name=>"flubber", :method_args=>["bar"], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"e147e4bb-e98d-4008-ae9a-0bccce314d7b"}]}}
+			end
+
+      let(:aggregate_id) { SecureRandom.uuid }
+
+      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.find 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.find aggregate_id
+				event = events.first
+				expect(event[:event_args]).to eql(test_events.first[:event_args])
+        expect(event[:event_name]).to eql("new")
+        expect(event[:aggregate_id]).to eql aggregate_id
+        expect(event[:aggregate_version]).to eql 1
+			end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'sandthorn_driver_event_store'
+require 'ap'
+require 'uuidtools'
+require 'in_memory_event_store_driver'
+
+# 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.send(:clear_for_test)
+end
+
+def event_store_driver_memory
+	SandthornDriverEventStore::InMemoryEventStoreDriver.new
+end
+
+def event_store_driver
+	event_store.driver
+end
+
+def event_store
+  @event_store ||= SandthornDriverEventStore.driver host: "localhost", port: 2113, page_size: 20
+  return @event_store
+end

metadata

@@ -0,0 +1,265 @@
+--- !ruby/object:Gem::Specification
+name: sandthorn_driver_event_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Morgan Hallgren
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: autotest-standalone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-beautify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: snappy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Event Store driver for Sandthorn
+email:
+- morgan.hallgren@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".autotest"
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sandthorn_driver_event_store.rb
+- lib/sandthorn_driver_event_store/access.rb
+- lib/sandthorn_driver_event_store/access/event_access.rb
+- lib/sandthorn_driver_event_store/errors.rb
+- lib/sandthorn_driver_event_store/event_query.rb
+- lib/sandthorn_driver_event_store/event_store.rb
+- lib/sandthorn_driver_event_store/event_store_driver.rb
+- lib/sandthorn_driver_event_store/utilities.rb
+- lib/sandthorn_driver_event_store/utilities/array.rb
+- lib/sandthorn_driver_event_store/version.rb
+- lib/sandthorn_driver_event_store/wrappers.rb
+- lib/sandthorn_driver_event_store/wrappers/event_wrapper.rb
+- sandthorn_driver_event_store.gemspec
+- spec/driver_interface_spec.rb
+- spec/event_access_spec.rb
+- spec/get_events_spec.rb
+- spec/in_memory_es.rb
+- spec/in_memory_event_store_driver.rb
+- spec/saving_events_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Event Store driver for Sandthorn
+test_files:
+- spec/driver_interface_spec.rb
+- spec/event_access_spec.rb
+- spec/get_events_spec.rb
+- spec/in_memory_es.rb
+- spec/in_memory_event_store_driver.rb
+- spec/saving_events_spec.rb
+- spec/spec_helper.rb
+has_rdoc: