ruby_event_store 2.16.0 → 2.17.0

data/lib/ruby_event_store/mappers/transformation/preserve_types.rb

@@ -43,7 +43,6 @@ module RubyEventStore
             @resolver = resolver
           end
 
-
           NULL_TYPE = NullType.new
           private_constant :NULL_TYPE
 
@@ -56,6 +55,7 @@ module RubyEventStore
           end
 
           private
+
           attr_reader :resolver, :types
         end
         private_constant :Registry
@@ -78,7 +78,7 @@ module RubyEventStore
             data: data,
             metadata: metadata,
             timestamp: record.timestamp,
-            valid_at: record.valid_at
+            valid_at: record.valid_at,
           )
         end
 
@@ -100,7 +100,7 @@ module RubyEventStore
             data: data,
             metadata: metadata,
             timestamp: record.timestamp,
-            valid_at: record.valid_at
+            valid_at: record.valid_at,
           )
         end
 
@@ -108,6 +108,7 @@ module RubyEventStore
         private_constant :DEFAULT_STORE_TYPE
 
         private
+
         attr_reader :registry
 
         def transform_hash(argument)
@@ -125,16 +126,12 @@ module RubyEventStore
           end
         end
 
-        def store_types(argument)
-          argument.each_with_object({}) do |(key, value), hash|
-            hash[transform(key)] = [store_type(key), store_type(value)]
-          end
-        end
-
         def store_type(argument)
           case argument
           when Hash
-            store_types(argument)
+            argument.reduce({}) do |hash, (key, value)|
+              hash.merge(transform(key) => [store_type(key), store_type(value)])
+            end
           when Array
             argument.map { |i| store_type(i) }
           else
@@ -142,18 +139,13 @@ module RubyEventStore
           end
         end
 
-        def restore_types(argument, types)
-          argument.each_with_object({}) do |(key, value), hash|
-            key_type, value_type = types.fetch(key.to_sym) { types.fetch(key.to_s) }
-            restored_key = restore_type(key, key_type)
-            hash[restored_key] = restore_type(value, value_type)
-          end
-        end
-
         def restore_type(argument, type)
           case type
           when Hash
-            restore_types(argument, type)
+            argument.reduce({}) do |hash, (key, value)|
+              key_type, value_type = type.fetch(key.to_sym) { type.fetch(key) }
+              hash.merge(restore_type(key, key_type) => restore_type(value, value_type))
+            end
           when Array
             argument.each_with_index.map { |a, idx| restore_type(a, type.fetch(idx)) }
           else

data/lib/ruby_event_store/mappers/transformation/stringify_metadata_keys.rb

@@ -21,7 +21,7 @@ module RubyEventStore
             data: record.data,
             metadata: TransformKeys.stringify(record.metadata),
             timestamp: record.timestamp,
-            valid_at: record.valid_at
+            valid_at: record.valid_at,
           )
         end
       end

data/lib/ruby_event_store/mappers/transformation/symbolize_metadata_keys.rb

@@ -21,7 +21,7 @@ module RubyEventStore
             data: record.data,
             metadata: TransformKeys.symbolize(record.metadata),
             timestamp: record.timestamp,
-            valid_at: record.valid_at
+            valid_at: record.valid_at,
           )
         end
       end

data/lib/ruby_event_store/record.rb

@@ -34,20 +34,19 @@ module RubyEventStore
         metadata: metadata,
         event_type: event_type,
         timestamp: timestamp,
-        valid_at: valid_at
+        valid_at: valid_at,
       }
     end
 
     def serialize(serializer)
-      @serialized_records[serializer] ||=
-        SerializedRecord.new(
-          event_id: event_id,
-          event_type: event_type,
-          data: serializer.dump(data),
-          metadata: serializer.dump(metadata),
-          timestamp: timestamp.iso8601(TIMESTAMP_PRECISION),
-          valid_at: valid_at.iso8601(TIMESTAMP_PRECISION)
-        )
+      @serialized_records[serializer] ||= SerializedRecord.new(
+        event_id: event_id,
+        event_type: event_type,
+        data: serializer.dump(data),
+        metadata: serializer.dump(metadata),
+        timestamp: timestamp.iso8601(TIMESTAMP_PRECISION),
+        valid_at: valid_at.iso8601(TIMESTAMP_PRECISION),
+      )
     end
 
     alias_method :eql?, :==

data/lib/ruby_event_store/serialized_record.rb

@@ -33,7 +33,7 @@ module RubyEventStore
         metadata: metadata,
         event_type: event_type,
         timestamp: timestamp,
-        valid_at: valid_at
+        valid_at: valid_at,
       }
     end
 
@@ -44,7 +44,7 @@ module RubyEventStore
         data: serializer.load(data),
         metadata: serializer.load(metadata),
         timestamp: Time.iso8601(timestamp),
-        valid_at: Time.iso8601(valid_at)
+        valid_at: Time.iso8601(valid_at),
       )
     end
 

data/lib/ruby_event_store/spec/broker_lint.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.shared_examples :broker do |broker_klass|
+RSpec.shared_examples "broker" do |broker_klass|
   let(:event) { instance_double(::RubyEventStore::Event, event_type: "EventType") }
   let(:record) { instance_double(::RubyEventStore::Record) }
   let(:handler) { HandlerClass.new }
@@ -11,32 +11,38 @@ RSpec.shared_examples :broker do |broker_klass|
   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, record)
+    broker.call(event.event_type, event, record)
+  end
+
+  specify "calls subscription using topic" do
+    expect(subscriptions).to receive(:all_for).with("topic").and_return([handler])
+    expect(dispatcher).to receive(:call).with(handler, event, record)
+    broker.call("topic", event, record)
   end
 
   specify "calls subscription" do
     expect(subscriptions).to receive(:all_for).with("EventType").and_return([handler])
     expect(dispatcher).to receive(:call).with(handler, event, record)
-    broker.call(event, record)
+    broker.call(event.event_type, event, record)
   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, record)
-    broker.call(event, record)
+    broker.call(event.event_type, event, record)
   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, record)
     expect(dispatcher).to receive(:call).with(HandlerClass, event, record)
-    broker.call(event, record)
+    broker.call(event.event_type, event, record)
   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"
+      "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"
@@ -50,19 +56,19 @@ RSpec.shared_examples :broker do |broker_klass|
     allow(dispatcher).to receive(:verify).and_return(false)
     expect { broker.add_subscription(HandlerClass, []) }.to raise_error(
       RubyEventStore::InvalidHandler,
-      /Handler HandlerClass is invalid for dispatcher .*Dispatcher/
+      /Handler HandlerClass is invalid for dispatcher .*Dispatcher/,
     )
     expect { broker.add_global_subscription(HandlerClass) }.to raise_error(
       RubyEventStore::InvalidHandler,
-      /is invalid for dispatcher/
+      /is invalid for dispatcher/,
     )
     expect { broker.add_thread_subscription(HandlerClass, []) }.to raise_error(
       RubyEventStore::InvalidHandler,
-      /is invalid for dispatcher/
+      /is invalid for dispatcher/,
     )
     expect { broker.add_thread_global_subscription(HandlerClass) }.to raise_error(
       RubyEventStore::InvalidHandler,
-      /is invalid for dispatcher/
+      /is invalid for dispatcher/,
     )
   end
 
@@ -90,6 +96,17 @@ RSpec.shared_examples :broker do |broker_klass|
     broker.add_thread_global_subscription(handler)
   end
 
+  specify "all_subscriptions_for" do
+    handler = Subscribers::ValidHandler.new
+    broker.add_subscription(handler, ["ProductAdded"])
+    block = Proc.new { "Event published!" }
+    broker.add_subscription(block, ["OrderCreated"])
+
+    expect(broker.all_subscriptions_for("ProductAdded")).to eq [handler]
+    expect(broker.all_subscriptions_for("OrderCreated")).to eq [block]
+    expect(broker.all_subscriptions_for("NotExistingOne")).to eq []
+  end
+
   private
 
   class HandlerClass

data/lib/ruby_event_store/spec/dispatcher_lint.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.shared_examples :dispatcher do |dispatcher|
+RSpec.shared_examples "dispatcher" do |dispatcher|
   specify "#call" do
     expect(dispatcher).to respond_to(:call).with(3).arguments
   end

data/lib/ruby_event_store/spec/event_lint.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.shared_examples :event do |event_class, data, metadata|
+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 || {})
@@ -11,7 +11,7 @@ RSpec.shared_examples :event do |event_class, data, metadata|
     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
+    expect(event.event_id).not_to be_nil
   end
 
   it "provides message_id as string" do
@@ -33,7 +33,7 @@ RSpec.shared_examples :event do |event_class, data, metadata|
     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
+    expect(event.event_type).not_to be_nil
   end
 
   it "provides data" do