ruby_event_store 0.30.0 → 1.3.1

data/lib/ruby_event_store/metadata.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'time'
 require 'forwardable'
@@ -43,9 +45,9 @@ module RubyEventStore
     private
 
     def allowed_types
-      [String, Integer, Float, Date, Time, TrueClass, FalseClass, nil]
+      [String, Integer, Float, Date, Time, TrueClass, FalseClass, nil, Hash, Array]
     end
 
     private_constant :SAFE_HASH_METHODS
   end
-end
+end

data/lib/ruby_event_store/projection.rb

@@ -1,9 +1,22 @@
+# frozen_string_literal: true
 
 module RubyEventStore
   class Projection
     private_class_method :new
 
     def self.from_stream(*streams)
+      first_of_streams = streams.first
+      if first_of_streams.respond_to?(:flatten)
+        warn <<~EOW
+          Passing array to .from_stream is not supported. This method expects undefined number 
+          of positional arguments (splat) rather than an array.
+  
+          Expected: .from_stream(#{first_of_streams.map(&:inspect).join(", ")})
+          Received: .from_stream(#{first_of_streams})
+        EOW
+        streams = first_of_streams
+      end
+
       raise(ArgumentError, "At least one stream must be given") if streams.empty?
       new(streams: streams)
     end
@@ -14,8 +27,8 @@ module RubyEventStore
 
     def initialize(streams: [])
       @streams  = streams
-      @handlers = Hash.new { ->(_, _) {} }
-      @init     = -> { Hash.new }
+      @handlers = {}
+      @init     = -> { {} }
     end
 
     attr_reader :streams, :handlers
@@ -27,7 +40,7 @@ module RubyEventStore
 
     def when(events, handler)
       Array(events).each do |event|
-        @handlers[event] = handler
+        handlers[event.to_s] = handler
       end
 
       self
@@ -42,14 +55,15 @@ module RubyEventStore
     end
 
     def call(event)
-      handlers.fetch(event.class).(current_state, event)
+      handlers.fetch(event.event_type).(current_state, event)
     end
 
     def handled_events
       handlers.keys
     end
 
-    def run(event_store, start: :head, count: PAGE_SIZE)
+    def run(event_store, start: nil, count: PAGE_SIZE)
+      return initial_state if handled_events.empty?
       if streams.any?
         reduce_from_streams(event_store, start, count)
       else
@@ -60,7 +74,7 @@ module RubyEventStore
     private
 
     def valid_starting_point?(start)
-      return true if start === :head
+      return true unless start
       if streams.any?
         (start.instance_of?(Array) && start.size === streams.size)
       else
@@ -69,23 +83,31 @@ module RubyEventStore
     end
 
     def reduce_from_streams(event_store, start, count)
-      raise ArgumentError.new('Start must be an array with event ids or :head') unless valid_starting_point?(start)
+      raise ArgumentError.new('Start must be an array with event ids') unless valid_starting_point?(start)
       streams.zip(start_events(start)).reduce(initial_state) do |state, (stream_name, start_event_id)|
-        event_store.read.in_batches(count).stream(stream_name).from(start_event_id).each.reduce(state, &method(:transition))
+        read_scope(event_store, stream_name, count, start_event_id).reduce(state, &method(:transition))
       end
     end
 
     def reduce_from_all_streams(event_store, start, count)
-      raise ArgumentError.new('Start must be valid event id or :head') unless valid_starting_point?(start)
-      event_store.read.in_batches(count).from(start).each.reduce(initial_state, &method(:transition))
+      raise ArgumentError.new('Start must be valid event id') unless valid_starting_point?(start)
+      read_scope(event_store, nil, count, start).reduce(initial_state, &method(:transition))
+    end
+
+    def read_scope(event_store, stream, count, start)
+      scope = event_store.read.in_batches(count)
+      scope = scope.of_type(handled_events)
+      scope = scope.stream(stream) if stream
+      scope = scope.from(start) if start
+      scope
     end
 
     def start_events(start)
-      start === :head ? Array.new(streams.size) { :head } : start
+      start ? start : Array.new
     end
 
     def transition(state, event)
-      handlers[event.class].(state, event)
+      handlers.fetch(event.event_type).call(state, event)
       state
     end
   end

data/lib/ruby_event_store/serialized_record.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module RubyEventStore
   class SerializedRecord
     StringsRequired = Class.new(StandardError)
     def initialize(event_id:, data:, metadata:, event_type:)
-      raise StringsRequired unless [event_id, data, metadata, event_type].all? { |v| v.instance_of?(String) }
+      raise StringsRequired unless [event_id, event_type].all? { |v| v.instance_of?(String) }
       @event_id   = event_id
       @data       = data
       @metadata   = metadata

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -0,0 +1,92 @@
+RSpec.shared_examples :broker do |broker_klass|
+  let(:event) { instance_double(::RubyEventStore::Event, event_type: 'EventType') }
+  let(:serialized_event) { instance_double(::RubyEventStore::SerializedRecord)  }
+  let(:handler) { HandlerClass.new }
+  let(:subscriptions) { ::RubyEventStore::Subscriptions.new }
+  let(:dispatcher) { ::RubyEventStore::Dispatcher.new }
+  let(:broker) { broker_klass.new(subscriptions: subscriptions, dispatcher: dispatcher) }
+
+  specify "no dispatch when no subscriptions" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([])
+    expect(dispatcher).not_to receive(:call)
+    broker.call(event, serialized_event)
+  end
+
+  specify "calls subscription" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler])
+    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
+    broker.call(event, serialized_event)
+  end
+
+  specify "calls subscribed class" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([HandlerClass])
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
+    broker.call(event, serialized_event)
+  end
+
+  specify "calls all subscriptions" do
+    expect(subscriptions).to receive(:all_for).with('EventType').and_return([handler, HandlerClass])
+    expect(dispatcher).to receive(:call).with(handler, event, serialized_event)
+    expect(dispatcher).to receive(:call).with(HandlerClass, event, serialized_event)
+    broker.call(event, serialized_event)
+  end
+
+  specify 'raise error when no subscriber' do
+    expect { broker.add_subscription(nil, [])}.to raise_error(RubyEventStore::SubscriberNotExist, "subscriber must be first argument or block")
+    expect { broker.add_global_subscription(nil)}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
+    expect { broker.add_thread_subscription(nil, []).call}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
+    expect { broker.add_thread_global_subscription(nil).call}.to raise_error(RubyEventStore::SubscriberNotExist), "subscriber must be first argument or block"
+  end
+
+  specify 'raise error when wrong subscriber' do
+    allow(dispatcher).to receive(:verify).and_return(false)
+    expect do
+      broker.add_subscription(HandlerClass, [])
+    end.to raise_error(RubyEventStore::InvalidHandler, /Handler HandlerClass is invalid for dispatcher .*Dispatcher/)
+    expect do
+      broker.add_global_subscription(HandlerClass)
+    end.to raise_error(RubyEventStore::InvalidHandler, /is invalid for dispatcher/)
+    expect do
+      broker.add_thread_subscription(HandlerClass, [])
+    end.to raise_error(RubyEventStore::InvalidHandler, /is invalid for dispatcher/)
+    expect do
+      broker.add_thread_global_subscription(HandlerClass)
+    end.to raise_error(RubyEventStore::InvalidHandler, /is invalid for dispatcher/)
+  end
+
+  specify "verify and add - local subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler).and_return(true)
+    expect(subscriptions).to receive(:add_subscription).with(handler, ['EventType'])
+    broker.add_subscription(handler, ['EventType'])
+  end
+
+  specify "verify and add - global subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler).and_return(true)
+    expect(subscriptions).to receive(:add_global_subscription).with(handler)
+    broker.add_global_subscription(handler)
+  end
+
+  specify "verify and add - thread local subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler).and_return(true)
+    expect(subscriptions).to receive(:add_thread_subscription).with(handler, ['EventType'])
+    broker.add_thread_subscription(handler, ['EventType'])
+  end
+
+  specify "verify and add - thread global subscriptions" do
+    expect(dispatcher).to receive(:verify).with(handler).and_return(true)
+    expect(subscriptions).to receive(:add_thread_global_subscription).with(handler)
+    broker.add_thread_global_subscription(handler)
+  end
+
+  private
+
+  class HandlerClass
+    @@received = nil
+    def self.received
+      @@received
+    end
+    def call(event)
+      @@received = event
+    end
+  end
+end

data/lib/ruby_event_store/spec/dispatcher_lint.rb

@@ -1,41 +1,9 @@
 RSpec.shared_examples :dispatcher do |dispatcher|
-  specify "calls subscribed instance" do
-    handler = HandlerClass.new
-    event   = instance_double(::RubyEventStore::Event)
-
-    expect(handler).to receive(:call).with(event)
-    dispatcher.(handler, event)
-  end
-
-  specify "calls subscribed class" do
-    event   = instance_double(::RubyEventStore::Event)
-
-    expect(HandlerClass).to receive(:new).and_return( h = HandlerClass.new )
-    expect(h).to receive(:call).with(event)
-    dispatcher.(HandlerClass, event)
+  specify "#call" do
+    expect(dispatcher).to respond_to(:call).with(3).arguments
   end
 
-  specify "allows callable classes and instances" do
-    expect do
-      dispatcher.verify(HandlerClass)
-    end.not_to raise_error
-    expect do
-      dispatcher.verify(HandlerClass.new)
-    end.not_to raise_error
-    expect do
-      dispatcher.verify(Proc.new{ "yo" })
-    end.not_to raise_error
-  end
-
-  private
-
-  class HandlerClass
-    @@received = nil
-    def self.received
-      @@received
-    end
-    def call(event)
-      @@received = event
-    end
+  specify "#verify" do
+    expect(dispatcher).to respond_to(:verify).with(1).argument
   end
 end

data/lib/ruby_event_store/spec/event_lint.rb

@@ -0,0 +1,71 @@
+RSpec.shared_examples :event do |event_class, data, metadata|
+  it 'allows initialization' do
+    expect {
+      event_class.new(event_id: Object.new, data: data || Object.new, metadata: metadata || {})
+    }.not_to raise_error
+  end
+
+  it 'provides event_id as string' do
+    event = event_class.new
+    expect(event.event_id).to be_an_instance_of(String)
+    expect(event.event_id).not_to eq ''
+    expect(event.event_id).not_to eq nil
+  end
+
+  it 'provides message_id as string' do
+    event = event_class.new
+    expect(event.message_id).to be_an_instance_of(String)
+  end
+
+  it 'message_id is the same as event_id' do
+    event = event_class.new
+    expect(event.event_id).to eq event.message_id
+  end
+
+  it 'exposes given event_id to string' do
+    event = event_class.new(event_id: 1234567890)
+    expect(event.event_id).to eq '1234567890'
+  end
+
+  it 'provides event type as string' do
+    event = event_class.new
+    expect(event.event_type).to be_an_instance_of(String)
+    expect(event.event_type).not_to eq ''
+    expect(event.event_type).not_to eq nil
+  end
+
+  it "provides data" do
+    event = event_class.new
+    expect(event).to respond_to(:data).with(0).arguments
+  end
+
+  it "metadata allows to read keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:[]).with(1).arguments
+  end
+
+  it "metadata allows to set keys value" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:[]=).with(2).argument
+  end
+
+  it "metadata allows to fetch keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:fetch).with(1).argument
+  end
+
+  it "metadata allows to check existence of keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:has_key?).with(1).argument
+  end
+
+  it "metadata allows to iterate through keys" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:each_with_object).with(1).argument
+  end
+
+  it "metadata must convert to hash" do
+    event = event_class.new
+    expect(event.metadata).to respond_to(:to_h).with(0).argument
+  end
+end