ruby_cqrs 0.2.0

data/spec/feature/snapshot_spec.rb

@@ -0,0 +1,216 @@
+require_relative('../spec_helper.rb')
+
+describe 'Snapshotable module' do
+  let(:command_context) {}
+  let(:repository) { RubyCqrs::Domain::AggregateRepository.new\
+                     RubyCqrs::Data::InMemoryEventStore.new, command_context }
+  let(:aggregate_not_snapshot) { SomeDomain::AggregateRootNoSnapshot.new }
+  let(:aggregate_wrong_snapshot) { SomeDomain::AggregateRootWronglyImplementSnapshot.new }
+  let(:aggregate) { SomeDomain::AggregateRoot.new }
+  # an aggregate has a SNAPSHOT_THRESHOLD of 45
+  let(:aggregate_s_45) { SomeDomain::AggregateRoot45Snapshot.new }
+
+  context 'when an aggregate is not snapshotable' do
+    it 'specifies an aggregate is not snapshotable' do
+      expect(aggregate_not_snapshot.is_a? RubyCqrs::Domain::Snapshotable).to be_falsy
+    end
+
+    it "aggregate's #get_changes returns no snapshot field when default amount of events get fired" do
+      (1..30).each { |x| aggregate_not_snapshot.test_fire }
+      changes = aggregate_not_snapshot.send(:get_changes)
+      expect(changes[:snapshot]).to be_nil
+    end
+
+    it "saves and loads the correct aggregate back" do
+      (1..45).each { |x| aggregate_not_snapshot.test_fire }
+      repository.save aggregate_not_snapshot
+      loaded_aggregate = repository.find_by aggregate_not_snapshot.aggregate_id
+      expect(loaded_aggregate.state).to eq(45)
+    end
+  end
+
+  context "when an aggregate's snapshot feature is incorrectly implemented" do
+    it "raises NotADomainSnapshotError when enough events get fired" do
+      (1..30).each { |x| aggregate_wrong_snapshot.test_fire }
+      expect{ aggregate_wrong_snapshot.send(:get_changes) }.to\
+        raise_error(RubyCqrs::NotADomainSnapshotError)
+    end
+  end
+
+  context 'when an aggregate is snapshotable' do
+    it 'specifies an aggregate is snapshotable' do
+      expect(aggregate.is_a? RubyCqrs::Domain::Snapshotable).to be_truthy
+      expect(aggregate_s_45.is_a? RubyCqrs::Domain::Snapshotable).to be_truthy
+    end
+
+    it "aggregate's #get_changes returns an addtional snapshot field when enough events get fired" do
+      (1..30).each { |x| aggregate.test_fire }
+      changes = aggregate.send(:get_changes)
+      expect(changes[:snapshot]).to_not be_nil
+
+      (1..45).each { |x| aggregate_s_45.test_fire }
+      changes = aggregate_s_45.send(:get_changes)
+      expect(changes[:snapshot]).to_not be_nil
+    end
+
+    it "aggregate's #get_changes returns no snapshot field when not enough events get fired" do
+      (1..29).each { |x| aggregate.test_fire }
+      changes = aggregate.send(:get_changes)
+      expect(changes[:snapshot]).to be_nil
+
+      (1..44).each { |x| aggregate_s_45.test_fire }
+      changes = aggregate_s_45.send(:get_changes)
+      expect(changes[:snapshot]).to be_nil
+    end
+
+    it "saves and loads the correct aggregate back with no snapshots are taken" do
+      (1..29).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(29)
+
+      (1..44).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(44)
+    end
+
+    it "saves and loads the correct aggregate back with 1 snapshot's taken" do
+      (1..45).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(45)
+
+      (1..60).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(60)
+    end
+
+    it "saves and loads the correct aggregate back incrementally and eventually triggers a snapshot" do
+      (1..15).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(15)
+
+      (1..15).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(30)
+
+      (1..30).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(30)
+
+      (1..15).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(45)
+    end
+
+    it "saves aggregate incrementally and eventually triggers a snapshot, without reloading aggregate during the process" do
+      (1..15).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      expect(aggregate.state).to eq(15)
+
+      (1..15).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      expect(aggregate.state).to eq(30)
+
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(30)
+
+      (1..30).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      expect(aggregate_s_45.state).to eq(30)
+
+      (1..15).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      expect(aggregate_s_45.state).to eq(45)
+
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(45)
+    end
+
+    it "saves and loads the correct aggregate back with two snapshot taken" do
+      (1..30).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(30)
+
+      (1..30).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(60)
+
+      (1..45).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(45)
+
+      (1..45).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(90)
+    end
+
+    it "saves and loads the correct aggregate back incrementally and eventually triggers two snapshot" do
+      (1..30).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(30)
+
+      (1..15).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(45)
+
+      (1..15).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate.aggregate_id
+      expect(loaded_aggregate.state).to eq(60)
+
+      (1..45).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(45)
+
+      (1..30).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(75)
+
+      (1..15).each { |x| loaded_aggregate.test_fire }
+      repository.save loaded_aggregate
+      loaded_aggregate = repository.find_by aggregate_s_45.aggregate_id
+      expect(loaded_aggregate.state).to eq(90)
+    end
+
+    it "saves and loads the correct aggregate back incrementally and eventually triggers two snapshot, without reloading aggregate during the process" do
+      (1..30).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      expect(aggregate.state).to eq(30)
+
+      (1..15).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      expect(aggregate.state).to eq(45)
+
+      (1..15).each { |x| aggregate.test_fire }
+      repository.save aggregate
+      expect(aggregate.state).to eq(60)
+
+      (1..45).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      expect(aggregate_s_45.state).to eq(45)
+
+      (1..30).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      expect(aggregate_s_45.state).to eq(75)
+
+      (1..15).each { |x| aggregate_s_45.test_fire }
+      repository.save aggregate_s_45
+      expect(aggregate_s_45.state).to eq(90)
+    end
+  end
+end

data/spec/fixture/typical_domain.rb

@@ -0,0 +1,182 @@
+require 'beefcake'
+
+module SomeDomain
+  class AggregateRoot
+    include RubyCqrs::Domain::Aggregate
+    include RubyCqrs::Domain::Snapshotable
+
+    attr_reader :state
+
+    def initialize
+      @state = 0
+      super
+    end
+
+    def fire_weird_stuff
+      raise_event Object.new
+    end
+
+    def test_fire
+      raise_event THIRD_EVENT_INSTANCE
+    end
+
+    def test_fire_ag
+      raise_event FORTH_EVENT_INSTANCE
+    end
+
+  private
+    def on_first_event event; @state += 1; end
+    def on_second_event event; @state += 1; end
+    def on_third_event event; @state += 1; end
+    def on_forth_event event; @state += 1; end
+
+    def take_a_snapshot
+      SomeSnapshot.new(:state => @state)
+    end
+
+    def apply_snapshot snapshot_object
+      @state = snapshot_object.state
+    end
+  end
+
+  class AggregateRoot45Snapshot
+    include RubyCqrs::Domain::Aggregate
+    include RubyCqrs::Domain::Snapshotable
+
+    SNAPSHOT_THRESHOLD = 45
+
+    attr_reader :state
+
+    def initialize
+      @state = 0
+      super
+    end
+
+    def test_fire
+      raise_event THIRD_EVENT_INSTANCE
+    end
+
+  private
+    def on_third_event event; @state += 1; end
+
+    def take_a_snapshot
+      SomeSnapshot.new(:state => @state)
+    end
+
+    def apply_snapshot snapshot_object
+      @state = snapshot_object.state
+    end
+  end
+
+  class AggregateRootWronglyImplementSnapshot
+    include RubyCqrs::Domain::Aggregate
+    include RubyCqrs::Domain::Snapshotable
+
+    attr_reader :state
+
+    def initialize
+      @state = 0
+      super
+    end
+
+    def test_fire
+      raise_event THIRD_EVENT_INSTANCE
+    end
+
+  private
+    def on_third_event event; @state += 1; end
+
+    def take_a_snapshot
+      WrongSnapshot.new(:state => @state)
+    end
+
+    def apply_snapshot snapshot_object
+      @state = snapshot_object.state
+    end
+  end
+
+  class AggregateRootNoSnapshot
+    include RubyCqrs::Domain::Aggregate
+
+    attr_reader :state
+
+    def initialize
+      @state = 0
+      super
+    end
+
+    def test_fire
+      raise_event THIRD_EVENT_INSTANCE
+    end
+
+  private
+    def on_third_event event; @state += 1; end
+  end
+
+  class SomeSnapshot
+    include Beefcake::Message
+    include RubyCqrs::Domain::Snapshot
+
+    required :state,      :int32, 1
+  end
+
+  class WrongSnapshot
+    include Beefcake::Message
+
+    required :state,      :int32, 1
+  end
+
+  AGGREGATE_ID = 'cbb688cc-d49a-11e4-9f39-3c15c2d13d4e'
+
+  class FirstEvent
+    include RubyCqrs::Domain::Event
+    include Beefcake::Message
+
+    def initialize
+      @aggregate_id = AGGREGATE_ID
+      @version = 1
+    end
+  end
+
+  class SecondEvent
+    include RubyCqrs::Domain::Event
+    include Beefcake::Message
+
+    def initialize
+      @aggregate_id = AGGREGATE_ID
+      @version = 2
+    end
+  end
+
+  class ThirdEvent
+    include RubyCqrs::Domain::Event
+    include Beefcake::Message
+
+    required :id,         :int32,   1
+    required :name,       :string,  2
+    required :phone,      :string,  3
+
+    optional :note,       :string,  4
+  end
+
+  class ForthEvent
+    include RubyCqrs::Domain::Event
+    include Beefcake::Message
+
+    required :order_id,   :int32,   1
+    required :price,      :int32,   2
+    required :customer_id,:int32,   3
+
+    optional :note,       :string,  4
+  end
+
+  class FifthEvent
+    include RubyCqrs::Domain::Event
+  end
+
+  THIRD_EVENT_INSTANCE = ThirdEvent.new(:id => 1, :name => 'some dude',\
+                                        :phone => '13322244444', :note => 'good luck')
+
+  FORTH_EVENT_INSTANCE = ForthEvent.new(:order_id => 100, :price => 2000,\
+                                        :customer_id => 1, :note => 'sold!')
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'bundler'
+Bundler.setup(:default, :test)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require('ruby_cqrs')
+
+require('fixture/typical_domain')
+require('support/matchers')

data/spec/support/matchers.rb

@@ -0,0 +1,8 @@
+require 'rspec/expectations'
+require_relative '../spec_helper.rb'
+
+RSpec::Matchers.define :be_a_valid_uuid do
+  match do |uuid_string|
+    RubyCqrs::Guid.validate? uuid_string
+  end
+end