sandthorn_driver_sequel 2.1.1 → 3.0.0

data/sandthorn_driver_sequel.gemspec

@@ -32,8 +32,6 @@ Gem::Specification.new do |spec|
   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"

data/spec/asking_for_aggregates_to_snapshot_spec.rb

@@ -7,25 +7,27 @@ module SandthornDriverSequel
 
   describe EventStore do
     before(:each) { prepare_for_test }
+    let(:aggregate) { Struct::AggregateMock.new(aggregate_id, 11) }
+    let(:aggregate_id) { @id ||= UUIDTools::UUID.random_create.to_s }
     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}]}
+        [{id: "1", class_name: Foo}, {id: aggregate_id, class_name: Struct::AggregateMock},{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 }
+        let(:needs_snapshot) { event_store.obsolete_snapshots aggregate_types: [Struct::AggregateMock], max_event_distance: 5 }
         context "and no snapshots exist" do
-          it "should return that id 2 with class Bar need to be snapshotted" do
+          it "should return that id 2 with class Struct::AggregateMock 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"
+            expect(needs_snapshot.first[:aggregate_type]).to eql "Struct::AggregateMock"
           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])
+            event_store.save_snapshot(aggregate)
           end
           it "should return nil" do
             expect(needs_snapshot).to be_empty
@@ -54,7 +56,7 @@ module SandthornDriverSequel
         events = []
         i = 0
         while i < count do
-          events << { aggregate_version: i+start_at, event_data: nil, event_name: "event_foo_#{i}" }
+          events << { aggregate_version: i+start_at, event_args: nil, event_name: "event_foo_#{i}" }
           i += 1
         end
         events

data/spec/benchmark_spec.rb

@@ -10,20 +10,20 @@ module Sandthorn
       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"}
+        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=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
         19.times do |i| 
-           e << {aggregate_version: i+2, event_name: "foo", event_data: "A2"}
+           e << {aggregate_version: i+2, event_name: "foo", event_args: "A2"}
         end
         e
       end
       let(:test_events_one_event) do
         e = [] 
-        e << {aggregate_version: 1, event_name: "new", event_data: "B1" }
+        e << {aggregate_version: 1, event_name: "new", event_args: "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"}
+        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=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
+        e << {aggregate_version: 2, event_name: "foo", event_args: "A2"}
       end
       let(:aggregate_id) {"c0456e26-2345-4f67-92fa-130b3a31a39a"}
       let(:es) { event_store }

data/spec/configuration_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module SandthornDriverSequel
+  describe "Configuration" do
+
+    context "default configuration" do
+
+      let(:driver) { SandthornDriverSequel.driver_from_connection connection: Sequel.sqlite }
+
+      it "should respond_to save_events method" do
+        expect(driver.respond_to?(:save_events)).to be_truthy
+      end
+
+      it "should have the default event_serializer" do
+        expect(driver.instance_variable_get "@event_serializer".to_sym).to be_a Proc
+      end
+
+      it "should have the default event_deserializer" do
+        expect(driver.instance_variable_get "@event_deserializer".to_sym).to be_a Proc
+      end
+
+      it "should have the default snapshot_serializer" do
+        expect(driver.instance_variable_get "@snapshot_serializer".to_sym).to be_a Proc
+      end
+
+      it "should have the default snapshot_deserializer" do
+        expect(driver.instance_variable_get "@snapshot_deserializer".to_sym).to be_a Proc
+      end
+
+      context "change global configuration" do
+        before do
+          SandthornDriverSequel.configure { |conf|
+            conf.event_serializer = :serializer_event_global
+            conf.event_deserializer = :deserializer_event_global
+            conf.snapshot_serializer = :serializer_snapshot_global
+            conf.snapshot_deserializer = :deserializer_snapshot_global
+          }
+        end
+
+        after do
+          #Set the default configuration after test
+          SandthornDriverSequel.configure { |conf|
+            conf.event_serializer = -> (data) { YAML.dump(data) }
+            conf.event_deserializer = -> (data) { YAML.load(data) }
+            conf.snapshot_serializer = -> (data) { YAML.dump(data) }
+            conf.snapshot_deserializer = -> (data) { YAML.load(data) }
+          }
+        end
+
+        it "should have the new event_serializer" do
+          expect(driver.instance_variable_get "@event_serializer".to_sym).to eql :serializer_event_global
+        end
+
+        it "should have the default event_deserializer" do
+          expect(driver.instance_variable_get "@event_deserializer".to_sym).to eql :deserializer_event_global
+        end
+
+        it "should have the new snapshot_serializer" do
+          expect(driver.instance_variable_get "@snapshot_serializer".to_sym).to eql :serializer_snapshot_global
+        end
+
+        it "should have the default snapshot_deserializer" do
+          expect(driver.instance_variable_get "@snapshot_deserializer".to_sym).to eql :deserializer_snapshot_global
+        end
+      end
+    end
+
+    context "session configuration" do
+      let(:driver) do
+        SandthornDriverSequel.driver_from_connection(connection: Sequel.sqlite) { |conf|
+          conf.event_serializer = :event_serializer
+          conf.event_deserializer = :event_deserializer
+          conf.snapshot_serializer = :snapshot_serializer
+          conf.snapshot_deserializer = :snapshot_deserializer
+        }
+      end
+
+      it "should respond_to save_events method" do
+        expect(driver.respond_to?(:save_events)).to be_truthy
+      end
+
+      it "should have a configuration event_serializer" do
+        expect(driver.instance_variable_get "@event_serializer".to_sym).to eql :event_serializer
+      end
+
+      it "should have a configuration event_deserializer" do
+        expect(driver.instance_variable_get "@event_deserializer".to_sym).to eql :event_deserializer
+      end
+
+      it "should have a configuration snapshot_serializer" do
+        expect(driver.instance_variable_get "@snapshot_serializer".to_sym).to eql :snapshot_serializer
+      end
+
+      it "should have a configuration snapshot_deserializer" do
+        expect(driver.instance_variable_get "@snapshot_deserializer".to_sym).to eql :snapshot_deserializer
+      end
+
+    end
+
+
+  end
+end

data/spec/driver_interface_spec.rb

@@ -15,7 +15,6 @@ module SandthornDriverSequel
         :get_all_types,
         :get_snapshot,
         :get_events,
-        :url,
         :context,
         :driver
       ]

data/spec/event_access_spec.rb

@@ -12,23 +12,28 @@ module SandthornDriverSequel
     let(:db) { Sequel.connect(event_store_url)}
     let(:aggregate_id) { SecureRandom.uuid }
     let(:aggregate) do
-      aggregate_access.register_aggregate(aggregate_id, "foo")
+      aggregate_access.register_aggregate(aggregate_id, "AggregateMock")
     end
     let(:storage) { Storage.new(db, :test) }
+    let(:event_serializer) { -> (data) { YAML.dump(data) } }
+    let(:event_deserializer) { -> (data) { YAML.load(data) } }
+    let(:snapshot_serializer) { -> (data) { YAML.dump(data) } }
+    let(:snapshot_deserializer) { -> (data) { YAML.load(data) } }
     let(:aggregate_access) { AggregateAccess.new(storage) }
-    let(:snapshot_access) { SnapshotAccess.new(storage)}
-    let(:access) { EventAccess.new(storage) }
+    let(:snapshot_access) { SnapshotAccess.new(storage, snapshot_serializer, snapshot_deserializer)}
+    let(:access) { EventAccess.new(storage, event_serializer, event_deserializer) }
+
 
     let(:events) do
       [
         {
           aggregate_version: 1,
           event_name: "new",
-          event_data: "new_data"
+          event_args: "new_data"
         },{
           aggregate_version: 2,
           event_name: "foo",
-          event_data: "foo_data"
+          event_args: "foo_data"
         }
       ]
     end
@@ -87,14 +92,16 @@ module SandthornDriverSequel
       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"})
+        aggregate_struct = Struct::AggregateMock.new aggregate_id, events.first[:aggregate_version]
+
+        snapshot_id = snapshot_access.record_snapshot(aggregate_struct)
         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")
+        expect(events.first[:event_args]).to eq("foo_data")
       end
     end
 

data/spec/event_store_with_context_spec.rb

@@ -3,14 +3,14 @@ module SandthornDriverSequel
   describe EventStore do
     let(:context) { :event_store_spec }
     before(:each) { prepare_for_test context: context; prepare_for_test context: nil; }
-    let(:event_store_with_context) { EventStore.new url: event_store_url, context: context }  
-    let(:event_store_without_context) { EventStore.new url: event_store_url }
+    let(:event_store_with_context) { SandthornDriverSequel.driver_from_url url: event_store_url, context: context  }  
+    let(:event_store_without_context) { SandthornDriverSequel.driver_from_url 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"}
+        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=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
+        e << {aggregate_version: 2, event_name: "foo",  event_args: "noop"}
+        e << {aggregate_version: 3, event_name: "flubber",  event_args: "noop"}
       end
       let(:aggregate_id) {"c0456e26-e29a-4f67-92fa-130b3a31a39b"}
       it "should not find them" do

data/spec/get_events_spec.rb

@@ -5,25 +5,25 @@ module SandthornDriverSequel
     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"}
+      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=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
+      e << {aggregate_version: 2, event_name: "foo", event_args: "A2"}
+      e << {aggregate_version: 3, event_name: "bard", event_args: "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"}
+      e << {aggregate_version: 1, event_name: "new", event_args: "B1" }
+      e << {aggregate_version: 2, event_name: "foo", event_args: "B2"}
+      e << {aggregate_version: 3, event_name: "bar", event_args: "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" }
+      e << {aggregate_version: 1, event_name: "new", event_args: "C1" }
     end
     let(:test_events_c_2) do
       e = []
-      e << {aggregate_version: 2, event_name: "flubber", event_data: "C2" }
+      e << {aggregate_version: 2, event_name: "flubber", event_args: "C2" }
     end
     let(:aggregate_id_c) {"c0456e26-2345-4f67-92fa-130b3a31a39a"}
     before(:each) do

data/spec/saving_events_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'msgpack'
 
 module SandthornDriverSequel
   describe EventStore do
@@ -7,9 +6,9 @@ module SandthornDriverSequel
     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"}
+        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=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
+        e << {aggregate_version: 2, event_name: "foo", event_args: "noop"}
+        e << {aggregate_version: 3, event_name: "flubber", event_args: "noop"}
       end
 
       let(:aggregate_id) { "c0456e26-e29a-4f67-92fa-130b3a31a39a" }
@@ -24,7 +23,7 @@ module SandthornDriverSequel
         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_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
@@ -36,13 +35,13 @@ module SandthornDriverSequel
     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"}
+        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=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
+        e << {aggregate_version: 2, event_name: "foo", event_args: "noop"}
+        e << {aggregate_version: 3, event_name: "flubber", event_args: "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"}
+        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=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
       end
       let(:aggregate_id_1) {"c0456e26-e29a-4f67-92fa-130b3a31a39a"}
       let(:aggregate_id_2) {"c0456e26-e92b-4f67-92fa-130b3a31b93b"}
@@ -69,29 +68,12 @@ module SandthornDriverSequel
       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
-
     context "when saving events that have no aggregate_version" do
       let(:test_events) do
         e = []
-        e << {aggregate_version: nil, event_name: "new", event_args: nil, event_data: "---\n:method_name: new\n:method_args: []\n:attribute_deltas:\n- :attribute_name: :@aggregate_id\n  :old_value: \n  :new_value: 0a74e545-be84-4506-8b0a-73e947856327\n"}
-        e << {aggregate_version: nil, event_name: "foo", event_args: ["bar"], event_data: "noop"}
-        e << {aggregate_version: nil, event_name: "flubber", event_args: ["bar"] , event_data: "noop"}
+        e << {aggregate_version: nil, event_name: "new", event_args: {:method_name=>"new", :method_args=>[], :attribute_deltas=>[{:attribute_name=>"aggregate_id", :old_value=>nil, :new_value=>"0a74e545-be84-4506-8b0a-73e947856327"}]}}
+        e << {aggregate_version: nil, event_name: "foo", event_args: "noop"}
+        e << {aggregate_version: nil, event_name: "flubber", event_args: "noop"}
       end
 
       let(:aggregate_id) { "c0456e26-e29a-4f67-92fa-130b3a31a39a" }
@@ -106,7 +88,8 @@ module SandthornDriverSequel
         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_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

data/spec/saving_snapshot_spec.rb

@@ -5,12 +5,12 @@ module SandthornDriverSequel
   describe EventStore do
     before(:each) { prepare_for_test }
     let(:aggregate_id) { @id ||= UUIDTools::UUID.random_create.to_s }
-    let(:test_events) { [{aggregate_version: 1, event_data: nil, event_name: "new"},{aggregate_version: 2, event_data: nil, event_name: "foo"}] } 
-    let(:additional_events) { [{aggregate_version: 3, event_data: nil, event_name: "klopp"},{aggregate_version: 4, event_data: nil, event_name: "flipp"}] } 
-    let(:snapshot_data) { { event_data: YAML.dump(Object.new), aggregate_version: 2 } }    
-    let(:save_snapshot) { event_store.save_snapshot snapshot_data, aggregate_id }
-    let(:save_events) { event_store.save_events test_events, aggregate_id, SandthornDriverSequel::EventStore }
-    let(:save_additional_events) { event_store.save_events additional_events, aggregate_id, SandthornDriverSequel::EventStore }
+    let(:test_events) { [{aggregate_version: 1, event_args: nil, event_name: "new"},{aggregate_version: 2, event_args: nil, event_name: "foo"}] } 
+    let(:additional_events) { [{aggregate_version: 3, event_args: nil, event_name: "klopp"},{aggregate_version: 4, event_args: nil, event_name: "flipp"}] } 
+    let(:aggregate) { Struct::AggregateMock.new aggregate_id, 2 }
+    let(:save_snapshot) { event_store.save_snapshot aggregate }
+    let(:save_events) { event_store.save_events test_events, aggregate_id, Struct::AggregateMock }
+    let(:save_additional_events) { event_store.save_events additional_events, aggregate_id, Struct::AggregateMock }
     context "when loading an aggregate using get_aggregate" do
       context "and it has a snapshot" do
         before(:each) do
@@ -18,9 +18,9 @@ module SandthornDriverSequel
           save_snapshot
           save_additional_events
         end
-        let(:events) { event_store.get_aggregate aggregate_id, SandthornDriverSequel::EventStore }
+        let(:events) { event_store.get_aggregate aggregate_id, Struct::AggregateMock }
         it "should have the first event as :aggregate_set_from_snapshot" do
-          expect(events.first[:event_name]).to eql "aggregate_set_from_snapshot"
+          expect(events.first[:aggregate]).to eql aggregate
         end
         it "should have additional events after first snapshot-event" do
           expect(events.length).to eql 1+additional_events.length
@@ -40,7 +40,7 @@ module SandthornDriverSequel
         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
+          expect(snap).to eql aggregate
         end
       end
       context "when trying to save a snapshot on a non-existing aggregate" do
@@ -48,14 +48,7 @@ module SandthornDriverSequel
           expect { save_snapshot }.to raise_error SandthornDriverSequel::Errors::NoAggregateError
         end
       end
-      context "when trying to save a snapshot with a non-existing aggregate_version" do
-        before(:each) { save_events }
-        it "should raise a WrongAggregateVersion error" do
-          data = snapshot_data
-          data[:aggregate_version] = 100
-          expect { event_store.save_snapshot data, aggregate_id }.to raise_error SandthornDriverSequel::Errors::WrongSnapshotVersionError
-        end
-      end
+
       context "when saving a snapshot twice" do
         before(:each) { save_events; save_snapshot }
         it "should not raise error" do
@@ -65,9 +58,8 @@ module SandthornDriverSequel
       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)
+          data = Struct::AggregateMock.new aggregate_id, 1
+          event_store.save_snapshot(data)
           snap = event_store.get_snapshot(aggregate_id)
           expect(snap).to eql data
         end