sandthorn_sequel_projection 0.0.1

data/spec/integration/projection_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+module SandthornSequelProjection
+
+  class MyProjection < Projection
+
+    migration("20150303-1") do |db_con|
+      db_con.create_table?(table_name) do
+        primary_key :id
+        String :aggregate_id
+        TrueClass :on_sale, default: false
+      end
+    end
+
+    define_event_handlers do |handlers|
+      handlers.define product_added: {
+          aggregate_type: "SandthornProduct",
+          event_name: "new"
+      }
+      handlers.define on_sale: {
+          aggregate_type: "SandthornProduct",
+          event_name: "product_on_sale"
+      }
+      handlers.define removed_from_sale: {
+          aggregate_type: "SandthornProduct",
+          event_names: ["removed_from_sale", "destroyed"]
+      }
+    end
+
+    def on_sale(event)
+      aggregate_id = event[:aggregate_id]
+      add_aggregate(aggregate_id)
+      table.where(aggregate_id: aggregate_id).update(on_sale: true)
+    end
+
+    def add_aggregate(aggregate_id)
+      db_connection.transaction do
+        exists = table.where(aggregate_id: aggregate_id).any?
+        return exists || table.insert(aggregate_id: aggregate_id)
+      end
+    end
+
+    def product_added(event)
+      add_aggregate(event[:aggregate_id])
+    end
+
+    def removed_from_sale(event)
+      aggregate_id = event[:aggregate_id]
+      table.where(aggregate_id: aggregate_id).update(on_sale: false)
+    end
+
+    def table
+      db_connection[table_name]
+    end
+
+    def table_name
+      :products_on_sale
+    end
+
+    def aggregates_on_sale_ids
+      table.where(on_sale: true).select_map(:aggregate_id)
+    end
+
+    def aggregate_ids
+      table.select_map(:aggregate_id)
+    end
+  end
+
+  describe MyProjection do
+
+    def db_connection
+      SandthornSequelProjection.configuration.db_connection
+    end
+
+    def table
+      db_connection[projection.table_name]
+    end
+
+    let(:projection) { MyProjection.new }
+
+    before do
+      Sandthorn.default_event_store = MockEventStore.with_data
+    end
+
+    describe "#migrate!" do
+      it "creates the wanted table" do
+        projection.migrate!
+        expect(table.all).to eq([])
+      end
+    end
+
+    describe "#update" do
+      before do
+        projection.migrate!
+      end
+      methods = [:product_added, :removed_from_sale]
+      methods.each do |method|
+        it "calls #{method}" do
+          expect(projection).to receive(method).at_least(:once).and_call_original
+          projection.update!
+        end
+      end
+
+      describe "data" do
+        before { projection.update! }
+        it "sets the on_sale boolean correctly" do
+          expected = %w[
+          ac1be457-b6b9-4dad-900b-acb400f810df
+        ]
+          expect(projection.aggregates_on_sale_ids).to eq(expected)
+        end
+
+        it "sets the correct last processed sequence number" do
+          expect(projection.last_processed_sequence_number).to eq(128)
+        end
+
+        let(:json_events) { JSON.parse(File.read("./spec/test_data/event_data.json"), symbolize_names: true) }
+        let(:aggregate_ids) { json_events.map{|event| event[:aggregate_id] }.uniq }
+
+        it "records all aggregate ids" do
+          expect(projection.aggregate_ids).to contain_exactly(*aggregate_ids)
+        end
+      end
+    end
+  end
+end

data/spec/lock_spec.rb

@@ -0,0 +1,141 @@
+module SandthornSequelProjection
+
+  describe Lock do
+    let(:db_connection) { Sequel.sqlite }
+    let(:table_name) { ProcessedEventsTracker::DEFAULT_TABLE_NAME }
+    let(:lock) { SandthornSequelProjection::Lock.new("foo", db_connection) }
+
+    before(:each) do
+      db_connection.create_table?(table_name) do
+        String    :identifier
+        DateTime  :locked_at, null: true
+      end
+      db_connection[table_name].insert(identifier: lock.identifier)
+    end
+
+    def null_lock
+      db_connection[table_name].where(identifier: lock.identifier).update(locked_at: nil)
+    end
+
+    def set_lock(time = Time.now)
+      db_connection[table_name].where(identifier: lock.identifier).update(locked_at: time)
+    end
+
+    def lock_row
+      db_connection[table_name].where(identifier: lock.identifier).first
+    end
+
+    def lock_column
+      lock_row[:locked_at]
+    end
+
+    describe "#locked?" do
+      context "when the lock column is nulled" do
+        it "should return false" do
+          null_lock
+          expect(lock.locked?).to be_falsey
+        end
+      end
+
+      context "when the lock is locked" do
+        it "should return true" do
+          set_lock
+          expect(lock.locked?).to be_truthy
+        end
+      end
+    end
+
+    describe "#unlocked" do
+      context "when the lock column is nulled" do
+        it "should return true" do
+          expect(lock.unlocked?).to be_truthy
+        end
+      end
+    end
+
+    describe "#attempt_lock" do
+      context "when there is no previous lock" do
+        it "creates the lock" do
+          null_lock
+          expect(lock.attempt_lock).to be_truthy
+          expect(lock.locked?).to be_truthy
+        end
+      end
+
+      context "when there is a previous lock" do
+        context "and it has not expired" do
+          it "returns false and doesn't set the lock" do
+            set_lock
+            locked_at = lock_column
+            expect(lock.attempt_lock).to be_falsey
+            locked_at_after = lock_column
+            expect(locked_at_after).to eq(locked_at)
+          end
+        end
+
+        context "and it has expired" do
+          it "returns true at sets a new lock" do
+            set_lock(Time.now - lock.timeout)
+            locked_at = lock_column
+            expect(lock.attempt_lock).to be_truthy
+            locked_at_after = lock_column
+            expect(locked_at_after).to_not eq(locked_at)
+
+          end
+        end
+      end
+    end
+
+    describe "#release" do
+      it "releases the lock" do
+        set_lock
+        expect(lock.release).to be_truthy
+        expect(lock_column).to be_nil
+      end
+    end
+
+    describe "#aqcuire" do
+      context "when the lock is unlocked" do
+        it "executes the block" do
+          null_lock
+          expect { |b| lock.acquire(&b) }.to yield_control
+        end
+
+        it "has the lock during execution, and releases the lock afterwards" do
+          null_lock
+          lock.acquire do
+            expect(lock.locked?).to be_truthy
+          end
+          expect(lock_column).to be_nil
+        end
+      end
+
+      context "when the lock is locked" do
+        it "doesn't yield" do
+          set_lock
+          expect { |b| lock.acquire(&b) }.to_not yield_control
+        end
+      end
+
+      context "when an exception is raised" do
+        MyMegaException = Class.new(StandardError)
+
+        it "releases the lock" do
+          begin
+            lock.acquire do
+              expect(lock.locked?).to be_truthy
+              raise MyMegaException
+            end
+          rescue
+          ensure
+            expect(lock.locked?).to be_falsey
+          end
+        end
+
+        it "reraises the exception" do
+          expect { lock.acquire { raise MyMegaException } }.to raise_exception(MyMegaException)
+        end
+      end
+    end
+  end
+end

data/spec/processed_events_tracker_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+module SandthornSequelProjection
+  describe ProcessedEventsTracker do
+
+    describe "migrated specs" do
+      let(:event_store) { Sandthorn.default_event_store }
+      let(:db_connection) { SandthornSequelProjection.configuration.db_connection }
+      let(:tracker) { ProcessedEventsTracker.new(identifier: :foo, event_store: event_store) }
+      describe "::initialize" do
+        it "ensures that the tracker row is present" do
+          tracker_row = db_connection[tracker.table_name].where(identifier: tracker.identifier).first
+          expect(tracker_row).to_not be_nil
+          expect(tracker_row[:identifier]).to eq(tracker.identifier)
+          expect(tracker_row[:last_processed_sequence_number]).to eq(0)
+        end
+      end
+
+      describe '#last_processed_sequence_number' do
+        it "returns the integer in the db" do
+          db_connection[tracker.table_name].
+            where(identifier: tracker.identifier).
+            update(last_processed_sequence_number: 12)
+          expect(tracker.last_processed_sequence_number).to eq(12)
+        end
+      end
+
+      describe "#process_events" do
+        let(:events) { [{sequence_number: 1}, {sequence_number: 2}] }
+        around do |example|
+          old_batch_size = SandthornSequelProjection.batch_size
+          SandthornSequelProjection.configuration.batch_size = 1
+          example.run
+          SandthornSequelProjection.configuration.batch_size = old_batch_size
+        end
+
+        before do
+          tracker.reset
+          Sandthorn.default_event_store.reset
+          events.each { |e| event_store.add(e) }
+        end
+
+        it "yields events" do
+          expect { |b| tracker.process_events(&b) }.to yield_successive_args([events.first], [events.last])
+        end
+
+        it "sets the last processed number" do
+          tracker.process_events { |*| }
+          expect(tracker.last_processed_sequence_number).to eq(2)
+        end
+
+        it "has the lock during the yield" do
+          tracker.process_events do |*|
+            expect(tracker.lock.locked?).to be_truthy
+          end
+        end
+
+        it "has released the lock afterwards" do
+          tracker.process_events { |*| }
+          expect(tracker.lock.locked?).to be_falsey
+        end
+
+      end
+    end
+
+    describe "non-migrated specs" do
+      let(:db_connection) { Sequel.sqlite }
+      describe "::migrate!" do
+        it "creates the requisite database table" do
+          expect { ProcessedEventsTracker.migrate!(db_connection) }.to_not raise_error
+          expect(db_connection.table_exists?(ProcessedEventsTracker.table_name)).to be_truthy
+          expected_columns = :identifier, :last_processed_sequence_number, :locked_at
+          expect(db_connection[ProcessedEventsTracker.table_name].columns).to include(*expected_columns)
+        end
+      end
+    end
+
+  end
+end

data/spec/projection_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module SandthornSequelProjection
+
+  module MyModule
+    class TestProjection < Projection
+
+      def foo
+
+      end
+
+      def bar
+
+      end
+
+    end
+
+    class WithHandlers < TestProjection
+
+      define_event_handlers do |handlers|
+        handlers.define(:foo)
+        handlers.define(:bar)
+      end
+
+    end
+  end
+
+  describe Projection do
+    let(:projection) { MyModule::WithHandlers.new }
+
+    describe "::initialize" do
+      it "sets the handlers on the instance" do
+        handlers = projection.event_handlers
+        expect(handlers.length).to eq(2)
+      end
+    end
+
+    describe '::identifier' do
+      it "snake cases the class identifier" do
+        expect(MyModule::TestProjection.identifier).to eq("sandthorn_sequel_projection_my_module_test_projection")
+      end
+    end
+
+    describe "#update!" do
+
+      before do
+        event_store = Sandthorn.default_event_store
+        event_store.reset
+        event_store.add_event({sequence_number: 1})
+        event_store.add_event({sequence_number: 2})
+      end
+
+      it "fetches events and passes them on to the handlers" do
+        projection = MyModule::WithHandlers.new
+        handlers = projection.event_handlers
+        handlers.each do |handler|
+          expect(handler).to receive(:handle).twice
+        end
+        projection.update!
+      end
+    end
+
+    describe "::event_store" do
+      let(:klass) { Class.new(Projection) }
+      context "when given an event store name" do
+        it "sets the event store" do
+          klass.event_store(:foo)
+          expect(klass.event_store_name).to eq(:foo)
+        end
+      end
+
+      context "when given no argument" do
+        context "when an event store has been configured" do
+          before do
+            klass.event_store(:foo)
+          end
+          it "fetches the event store" do
+            expect(SandthornSequelProjection).to receive(:find_event_store).with(:foo)
+            klass.event_store
+          end 
+        end
+      end
+    end
+
+    describe "::define_event_handlers" do
+      it "yields an EventHandlerCollection" do
+        expect { |b| MyModule::TestProjection.define_event_handlers(&b) }.to yield_with_args(EventHandlerCollection)
+      end
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,32 @@
+module SandthornSequelProjection
+  describe Runner do
+
+    module FakeProjection
+      def initialize(*); end
+      def migrate!; end
+      def update!; end
+    end
+
+    class Projection1; include FakeProjection; end
+    class Projection2; include FakeProjection; end
+
+    let(:manifest) { Manifest.new(Projection1, Projection2) }
+
+    let(:runner) { SandthornSequelProjection::Runner.new(manifest) }
+
+    describe "#run" do
+      it "migrates all projections" do
+        expect_any_instance_of(Projection1).to receive(:migrate!).once
+        expect_any_instance_of(Projection2).to receive(:migrate!).once
+        runner.run(false)
+      end
+
+      it "updates all projections" do
+        expect_any_instance_of(Projection1).to receive(:update!).once
+        expect_any_instance_of(Projection2).to receive(:update!).once
+        runner.run(false)
+      end
+    end
+
+  end
+end