sandthorn 0.0.1

data/lib/sandthorn/aggregate_root_dirty_hashy.rb

@@ -0,0 +1,30 @@
+require "dirty_hashy"
+require "sandthorn/aggregate_root_base"
+
+module Sandthorn
+  module AggregateRoot
+    module DirtyHashy
+      include Sandthorn::AggregateRoot::Base
+
+      def self.included(base)
+        base.extend(Sandthorn::AggregateRoot::Base::ClassMethods)
+      end
+
+      def aggregate_initialize
+        @hashy = ::DirtyHashy.new
+      end
+
+      def get_delta
+        extract_relevant_aggregate_instance_variables.each do |var|
+          @hashy[var.to_s.delete("@")] = self.instance_variable_get("#{var}")
+        end
+        aggregate_attribute_deltas = []
+        @hashy.changes.each do |attribute|
+          aggregate_attribute_deltas << { :attribute_name => attribute[0], :old_value => attribute[1][0], :new_value => attribute[1][1]}
+        end
+        aggregate_attribute_deltas
+      end
+
+    end
+  end
+end

data/lib/sandthorn/aggregate_root_snapshot.rb

@@ -0,0 +1,39 @@
+module Sandthorn
+  module AggregateRootSnapshot
+    attr_reader :aggregate_snapshot
+
+    def aggregate_snapshot!
+
+      if @aggregate_events.count > 0
+        raise "Can't take snapshot on object with unsaved events"
+      end
+
+      @aggregate_snapshot = {
+        :event_name => "aggregate_set_from_snapshot",
+        :event_args => [self],
+        :aggregate_version => @aggregate_current_event_version
+      }
+    end
+
+    def save_snapshot
+      raise "No snapshot has been created!" unless @aggregate_snapshot
+      @aggregate_snapshot[:event_data] = Sandthorn.serialize @aggregate_snapshot[:event_args]
+      @aggregate_snapshot[:event_args] = nil
+      Sandthorn.save_snapshot @aggregate_snapshot, @aggregate_id, self.class.name
+      @aggregate_snapshot = nil
+    end
+    private
+    def aggregate_create_event_when_extended
+      self.aggregate_snapshot!
+      vars = extract_relevant_aggregate_instance_variables
+      vars.each do |var_name|
+        value = instance_variable_get var_name
+        dump = Marshal.dump(value)
+        store_aggregate_instance_variable var_name, dump
+      end
+      #@aggregate_snapshot[:event_data] = Sandthorn.serialize @aggregate_snapshot[:event_args]
+      store_aggregate_event "instance_extended_as_aggregate", @aggregate_snapshot[:event_args]
+      @aggregate_snapshot = nil
+    end
+  end
+end

data/lib/sandthorn/errors.rb

@@ -0,0 +1,8 @@
+module Sandthorn
+  module Errors
+    class Error < StandardError; end
+    class AggregateNotFound < Error; end
+    class ConcurrencyError < Error; end
+    class ConfigurationError < Error; end
+  end
+end

data/lib/sandthorn/event_inspector.rb

@@ -0,0 +1,63 @@
+module Sandthorn
+  module EventInspector
+    def has_unsaved_event? event_name, options = {}
+      unsaved = events_with_trace_info
+      if self.aggregate_events.empty?
+        unsaved = []
+      else
+        unsaved.reject! { |e| e[:aggregate_version] < self.aggregate_events.first[:aggregate_version] } 
+      end
+      matching_events = unsaved.select { |e| e[:event_name] == event_name }
+      event_exists = matching_events.length > 0
+      trace = has_trace? matching_events, options.fetch(:trace, {})
+
+      return event_exists && trace
+    end
+    def has_saved_event? event_name, options = {}
+      saved = events_with_trace_info
+      saved.reject! { |e| e[:aggregate_version] >= self.aggregate_events.first[:aggregate_version] } unless self.aggregate_events.empty?
+      matching_events = saved.select { |e| e[:event_name] == event_name }
+      event_exists = matching_events.length > 0
+      trace = has_trace? matching_events, options.fetch(:trace, {})
+
+      return event_exists && trace
+    end
+    def has_event? event_name, options = {}
+      matching_events = events_with_trace_info.select { |e| e[:event_name] == event_name }
+      event_exists = matching_events.length > 0
+      trace = has_trace? matching_events, options.fetch(:trace, {})
+      return event_exists && trace
+    end
+    def events_with_trace_info
+      saved = Sandthorn.get_aggregate_events self.aggregate_id, self.class 
+      unsaved = self.aggregate_events
+      all = saved.concat(unsaved).sort { |a, b| a[:aggregate_version] <=> b[:aggregate_version] }
+      extracted = all.collect do |e| 
+        if e[:event_args].nil? && !e[:event_data].nil?
+          data = Sandthorn.deserialize e[:event_data]
+        else
+          data = e[:event_args]
+        end
+        trace = data[:trace] unless data.nil? || !data.is_a?(Hash)
+        {aggregate_version: e[:aggregate_version], event_name: e[:event_name].to_sym, trace: trace }  
+      end
+      return extracted
+    end
+    private
+    def get_unsaved_events event_name
+      self.aggregate_events.select { |e| e[:event_name] == event_name.to_s  }
+    end
+    def get_saved_events event_name
+      saved_events = Sandthorn.get_aggregate_events self.aggregate_id, self.class
+      saved_events.select { |e| e[:event_name] == event_name.to_s  }
+    end
+
+    def has_trace? events_to_check, trace_info
+      return true if trace_info.empty?
+      events_to_check.each do |event|
+        return false if event[:trace] != trace_info
+      end
+      true
+    end
+  end
+end

data/lib/sandthorn/version.rb

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

data/sandthorn.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sandthorn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sandthorn"
+  spec.version       = Sandthorn::VERSION
+  spec.authors       = ["Lars Krantz", "Morgan Hallgren"]
+  spec.email         = ["lars.krantz@alaz.se", "morgan.hallgren@gmail.com"]
+  spec.description   = %q{Event sourcing gem}
+  spec.summary       = %q{Event sourcing gem}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  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 "sqlite3"  
+  spec.add_development_dependency "sandthorn_driver_sequel"
+
+  spec.add_runtime_dependency "dirty_hashy"
+  spec.add_runtime_dependency "uuidtools"
+
+end

data/spec/aggregate_delta_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'uuidtools'
+require 'sandthorn/aggregate_root_dirty_hashy'
+
+
+
+class PersonTest
+    include Sandthorn::AggregateRoot::DirtyHashy
+    attr_reader :name
+    attr_reader :age
+    attr_reader :relationship_status
+    attr_reader :my_array
+    attr_reader :my_hash
+
+  def initialize name, age, relationship_status
+    @name = name
+    @age = age
+    @relationship_status = relationship_status
+    @my_array = []
+    @my_hash = {}
+  end
+
+    def change_name new_name
+      @name = new_name
+      record_event new_name
+    end
+
+    def change_relationship new_relationship
+      @relationship_status = new_relationship
+      record_event new_relationship
+    end
+
+    def add_to_array element
+      @my_array << element
+      record_event element
+    end
+
+    def add_to_hash name,value
+      @my_hash[name] = value
+      record_event name,value
+    end
+end
+
+describe 'Property Delta Event Sourcing' do
+  let(:person) { PersonTest.new "Lasse",40,:married}
+
+  it 'should be able to set name' do
+    person.change_name  "Klabbarparen"
+    person.name.should eql("Klabbarparen")
+    #puts person.aggregate_events
+  end
+
+  it 'should be able to build from events' do
+    person.change_name  "Klabbarparen"
+    builded = PersonTest.aggregate_build person.aggregate_events
+    builded.name.should eql(person.name)
+    builded.aggregate_id.should eql(person.aggregate_id)
+  end
+
+  it 'should not have any events when built up' do
+    person.change_name "Mattias"
+    builded = PersonTest.aggregate_build person.aggregate_events
+    builded.aggregate_events.should be_empty
+  end
+
+  it 'should detect change on array' do
+    person.add_to_array "Foo"
+    person.add_to_array "bar"
+
+    builded = PersonTest.aggregate_build person.aggregate_events
+    builded.my_array.should include "Foo"
+    builded.my_array.should include "bar"
+  end
+
+  it 'should detect change on hash' do
+    person.add_to_hash :foo, "bar"
+    person.add_to_hash :bar, "foo"
+
+    builded = PersonTest.aggregate_build person.aggregate_events
+    builded.my_hash[:foo].should eql("bar")
+    builded.my_hash[:bar].should eql("foo")
+
+    person.add_to_hash :foo, "BAR"
+
+    #events = person.aggregate_events
+    #events << builded.aggregate_events
+    #puts events
+
+    builded2 = PersonTest.aggregate_build person.aggregate_events
+    builded2.my_hash[:foo].should eql("BAR")
+  end
+end

data/spec/aggregate_root_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'sandthorn/aggregate_root_dirty_hashy'
+
+module Sandthorn
+  module AggregateRoot
+    class DirtyClass
+      include Sandthorn::AggregateRoot::DirtyHashy
+      attr_reader :name, :age
+      attr :sex
+      attr_writer :writer
+      
+      def initialize args = {}
+        @name = args.fetch(:name, nil)
+        @sex = args.fetch(:sex, nil)
+        @writer = args.fetch(:writer, nil)
+      end
+
+      def change_name value
+        unless name == value
+          @name = value
+          commit
+        end
+      end
+
+      def change_sex value
+        unless sex == value
+          @sex = value
+        end
+      end
+
+      def change_writer value
+        unless writer == value
+          @writer = value
+        end
+      end
+
+      
+    end
+
+
+    describe "when making a change on a aggregate" do
+      let(:dirty_obejct) { 
+        o = DirtyClass.new
+        o
+      }
+
+      context "new with args" do
+
+        let(:subject) { DirtyClass.new(name: "Mogge", sex: "hen", writer: true) }
+        it "should set the values" do
+          expect(subject.name).to eql "Mogge"
+          expect(subject.sex).to eql "hen"
+          expect{subject.writer}.to raise_error
+        end
+      end
+
+      context "when changing name (attr_reader)" do
+        
+        it "should get new_name" do
+          dirty_obejct.change_name "new_name"
+          dirty_obejct.name.should eql "new_name"
+        end
+
+        it "should generate one event on new" do
+          expect(dirty_obejct.aggregate_events.length).to eql 1
+        end
+
+        it "should generate 2 events new and change_name" do
+          dirty_obejct.change_name "new_name"
+          expect(dirty_obejct.aggregate_events.length).to eql 2
+        end
+      end
+
+      context "when changing sex (attr)" do
+        it "should get new_sex" do
+          dirty_obejct.change_sex "new_sex"
+          dirty_obejct.sex.should eql "new_sex"
+        end
+      end
+
+      context "when changing writer (attr_writer)" do
+        it "should raise error" do
+          expect{dirty_obejct.change_writer "new_writer"}.to raise_error
+        end
+      end
+
+      context "save" do
+        it "should not have events on aggregete after save" do
+          expect(dirty_obejct.save.aggregate_events.length).to eql 0
+        end
+
+        it "should have aggregate_originating_version == 0 pre save" do
+          expect(dirty_obejct.aggregate_originating_version).to eql 0
+        end
+
+        it "should have aggregate_originating_version == 1 post save" do
+          expect(dirty_obejct.save.aggregate_originating_version).to eql 1
+        end
+      end
+
+      context "find" do
+        before(:each) { dirty_obejct.save }
+        it "should find by id" do
+          expect(DirtyClass.find(dirty_obejct.id).id).to eql dirty_obejct.id
+        end
+
+        it "should hold changed name" do
+          dirty_obejct.change_name("morgan").save
+          expect(DirtyClass.find(dirty_obejct.id).name).to eql "morgan"
+        end
+
+        it "should raise error if trying to find id that not exist" do
+          expect{DirtyClass.find("666")}.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/aggregate_snapshot_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+require 'uuidtools'
+require 'sandthorn/aggregate_root_dirty_hashy'
+require 'sandthorn/aggregate_root_snapshot'
+require 'date'
+
+
+module BankAccountInterestCommands
+  def calculate_interest! until_date = DateTime.now
+    # skipping all safety-checks..
+    # and this is of course horribly wrong financially speaking.. whatever
+    pay_out_unpaid_interest!
+    interest_calculation_time = until_date - @last_interest_calculation
+    days_with_interest = interest_calculation_time.to_i
+    unpaid_interest = @balance * @current_interest_info[:interest_rate] * days_with_interest / 365.2425
+    added_unpaid_interest_event unpaid_interest,until_date
+  end
+
+  def pay_out_unpaid_interest!
+    paid_out_unpaid_interest_balance_event @unpaid_interest_balance
+  end
+
+  def change_interest! new_interest_rate, interest_valid_from
+    calculate_interest!
+    changed_interest_rate_event new_interest_rate,interest_valid_from
+  end
+end
+module BankAccountWithdrawalCommands
+  def withdraw_from_atm! amount, atm_id
+    withdrew_amount_from_atm_event amount, atm_id
+  end
+
+  def withdraw_from_cashier! amount, cashier_id
+    withdrew_amount_from_cashier_event amount, cashier_id
+    charged_cashier_withdrawal_fee_event 50
+  end
+end
+
+module BankAccountVisaCardPurchasesCommands
+  def charge_card! amount, merchant_id
+    visa = VisaCardTransactionGateway.new
+    transaction_id = visa.charge_card "3030-3333-4252-2535", merchant_id, amount
+    paid_with_visa_card_event amount, transaction_id
+  end
+
+end
+
+class VisaCardTransactionGateway
+  def initialize
+    @visa_connector = "foo_bar"
+  end
+  def charge_card visa_card_number, merchant_id, amount
+    transaction_id = UUIDTools::UUID.random_create.to_s
+  end
+end
+
+module BankAccountDepositCommmands
+  def deposit_at_bank_office! amount, cashier_id
+    deposited_to_cashier_event amount, cashier_id
+  end
+
+  def transfer_money_from_another_account! amount, from_account_number
+    incoming_transfer_event amount,from_account_number
+  end
+end
+
+class BankAccount
+  include Sandthorn::AggregateRoot::DirtyHashy
+
+  attr_reader :balance
+  attr_reader :account_number
+  attr_reader :current_interest_info
+  attr_reader :account_creation_date
+  attr_reader :unpaid_interest_balance
+  attr_reader :last_interest_calculation
+
+  def initialize *args
+    account_number = args[0]
+    interest_rate = args[1]
+    creation_date = args[2]
+
+    @current_interest_info = {}
+    @current_interest_info[:interest_rate] = interest_rate
+    @current_interest_info[:interest_valid_from] = creation_date
+    @balance = 0
+    @unpaid_interest_balance = 0
+    @account_creation_date = creation_date
+    @last_interest_calculation = creation_date
+  end
+
+  def changed_interest_rate_event new_interest_rate, interest_valid_from
+    @current_interest_info[:interest_rate] = new_interest_rate
+    @current_interest_info[:interest_valid_from] = interest_valid_from
+    record_event new_interest_rate,interest_valid_from
+  end
+
+  def added_unpaid_interest_event interest_amount, calculated_until
+    @unpaid_interest_balance += interest_amount
+    @last_interest_calculation = calculated_until
+    record_event interest_amount, calculated_until
+  end
+
+  def paid_out_unpaid_interest_balance_event interest_amount
+    @unpaid_interest_balance -= interest_amount
+    @balance += interest_amount
+    record_event interest_amount
+  end
+
+  def withdrew_amount_from_atm_event amount, atm_id
+    @balance -= amount
+    record_event amount,atm_id
+  end
+
+  def withdrew_amount_from_cashier_event amount, cashier_id
+    @balance -= amount
+    record_event amount, cashier_id
+  end
+
+  def paid_with_visa_card_event amount, visa_card_transaction_id
+    @balance -= amount
+    record_event amount,visa_card_transaction_id
+  end
+
+  def charged_cashier_withdrawal_fee_event amount
+    @balance -= amount
+    record_event amount
+  end
+
+  def deposited_to_cashier_event amount, cashier_id
+    @balance = self.balance + amount
+    record_event amount,cashier_id
+  end
+
+  def incoming_transfer_event amount, from_account_number
+    current_balance = self.balance
+    @balance = amount + current_balance
+    record_event amount, from_account_number
+  end
+
+end
+
+def a_test_account
+  a = BankAccount.new "91503010111",0.031415, Date.new(2011,10,12)
+  a.extend BankAccountDepositCommmands
+  a.transfer_money_from_another_account! 90000, "FOOBAR"
+  a.deposit_at_bank_office! 10000, "Lars Idorn"
+
+  a.extend BankAccountVisaCardPurchasesCommands
+  a.charge_card! 1000, "Starbucks Coffee"
+
+  a.extend BankAccountInterestCommands
+  a.calculate_interest!
+  return a
+end
+
+#Tests part
+describe "when doing aggregate_find on an aggregate with a snapshot" do
+  let(:aggregate) do
+    a = a_test_account
+    a.save
+    a.extend Sandthorn::AggregateRootSnapshot
+    a.aggregate_snapshot!
+    a.save_snapshot
+    a.charge_card! 9000, "Apple"
+    a.save
+    a
+  end
+  it "should be loaded with correct version" do
+    org = aggregate
+    loaded = BankAccount.find org.aggregate_id
+    expect(loaded.balance).to eql org.balance
+  end
+end
+
+describe 'when generating state on an aggregate root' do
+
+  before(:each) do
+    @original_account = a_test_account
+    events = @original_account.aggregate_events
+    @account = BankAccount.aggregate_build events
+    @account.extend Sandthorn::AggregateRootSnapshot
+    @account.aggregate_snapshot!
+  end
+
+  it 'account should have properties set' do
+    @account.balance.should eql 99000
+    @account.unpaid_interest_balance.should be > 1000
+  end
+
+  it 'should store snapshot data in aggregate_snapshot' do
+    @account.aggregate_snapshot.should be_a(Hash)
+  end
+
+  it 'should store aggregate_version in aggregate_snapshot' do
+    @account.aggregate_snapshot[:aggregate_version].should eql(@original_account.aggregate_current_event_version)
+  end
+
+  it 'should be able to load up from snapshot' do
+
+    events = [@account.aggregate_snapshot]
+    loaded = BankAccount.aggregate_build events
+
+    loaded.balance.should eql(@original_account.balance)
+    loaded.account_number.should eql(@original_account.account_number)
+    loaded.current_interest_info.should eql(@original_account.current_interest_info)
+    loaded.account_creation_date.should eql(@original_account.account_creation_date)
+    loaded.unpaid_interest_balance.should eql(@original_account.unpaid_interest_balance)
+    loaded.last_interest_calculation.should eql(@original_account.last_interest_calculation)
+    loaded.aggregate_id.should eql(@original_account.aggregate_id)
+    loaded.aggregate_originating_version.should eql(@account.aggregate_originating_version)
+
+  end
+
+end
+
+describe 'when saving to repository' do
+  let(:account) {a_test_account.extend Sandthorn::AggregateRootSnapshot}
+  it 'should raise an error if trying to save before creating a snapshot' do
+    lambda {account.save_snapshot}.should raise_error (RuntimeError)
+  end
+  it 'should not raise an error if snapshot was created' do
+    account.save
+    account.aggregate_snapshot!
+    lambda {account.save_snapshot}.should_not raise_error
+  end
+  it 'should set aggregate_snapshot to nil' do
+    account.save
+    account.aggregate_snapshot!
+    account.save_snapshot
+    account.aggregate_snapshot.should eql(nil)
+  end
+
+  it 'should raise error if trying to create snapshot before events are saved on object' do
+    lambda {account.aggregate_snapshot!}.should raise_error
+  end
+
+  it 'should not raise an error if trying to create snapshot on object when events are saved' do
+    account.save
+    lambda {account.aggregate_snapshot!}.should_not raise_error
+  end
+
+  it 'should get snapshot on account find when a snapshot is saved' do
+
+    account.save
+    account.aggregate_snapshot!
+    account.save_snapshot
+
+    loaded = BankAccount.find account.aggregate_id
+
+    loaded.balance.should eql(account.balance)
+    loaded.account_number.should eql(account.account_number)
+    loaded.current_interest_info.should eql(account.current_interest_info)
+    loaded.account_creation_date.should eql(account.account_creation_date)
+    loaded.unpaid_interest_balance.should eql(account.unpaid_interest_balance)
+    loaded.last_interest_calculation.should eql(account.last_interest_calculation)
+    loaded.aggregate_id.should eql(account.aggregate_id)
+    loaded.aggregate_originating_version.should eql(account.aggregate_originating_version)
+
+  end
+end