event_system 0.1.0

data/spec/event_system/event_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe EventSystem::Event do
+  describe '#initialize' do
+    it 'creates an event with minimal parameters' do
+      event = EventSystem::Event.new(:test_type)
+      expect(event.type).to eq('test_type')
+      expect(event.source).to be_nil
+      expect(event.data).to eq({})
+      expect(event.id).to be_a(String)
+      expect(event.timestamp).to be_a(Time)
+    end
+
+    it 'creates an event with all parameters' do
+      source = 'TestSource'
+      data = { key: 'value' }
+      id = 'test-id-123'
+      timestamp = Time.now
+
+      event = EventSystem::Event.new(:test_type, source, data, id, timestamp)
+      expect(event.type).to eq('test_type')
+      expect(event.source).to eq(source)
+      expect(event.data).to eq(data)
+      expect(event.id).to eq(id)
+      expect(event.timestamp).to eq(timestamp.utc)
+    end
+
+    it 'generates UUID when no ID provided' do
+      event = EventSystem::Event.new(:test_type)
+      expect(event.id).to match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
+    end
+
+    it 'uses current time when no timestamp provided' do
+      before = Time.now
+      event = EventSystem::Event.new(:test_type)
+      after = Time.now
+      expect(event.timestamp).to be_between(before.utc, after.utc)
+    end
+
+    it 'converts type to string' do
+      event = EventSystem::Event.new(:symbol_type)
+      expect(event.type).to eq('symbol_type')
+    end
+
+    it 'parses string timestamp' do
+      timestamp_str = '2023-01-01T12:00:00Z'
+      event = EventSystem::Event.new(:test_type, nil, {}, nil, timestamp_str)
+      expect(event.timestamp).to eq(Time.parse(timestamp_str).utc)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns human-readable string representation' do
+      event = EventSystem::Event.new(:test_type, 'TestSource', { key: 'value' })
+      expect(event.to_s).to include('test_type')
+      expect(event.to_s).to include('key')
+      expect(event.to_s).to include('value')
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash representation' do
+      event = EventSystem::Event.new(:test_type, 'TestSource', { key: 'value' })
+      hash = event.to_h
+      
+      expect(hash[:id]).to eq(event.id)
+      expect(hash[:type]).to eq('test_type')
+      expect(hash[:source]).to eq('TestSource')
+      expect(hash[:data]).to eq({ key: 'value' })
+      expect(hash[:timestamp]).to eq(event.timestamp.iso8601(3))
+    end
+  end
+
+  describe '#to_json' do
+    it 'returns JSON representation' do
+      event = EventSystem::Event.new(:test_type, 'TestSource', { key: 'value' })
+      json = event.to_json
+      
+      expect { JSON.parse(json) }.not_to raise_error
+      parsed = JSON.parse(json, symbolize_names: true)
+      expect(parsed[:type]).to eq('test_type')
+      expect(parsed[:source]).to eq('TestSource')
+    end
+  end
+
+  describe '.from_json' do
+    it 'reconstructs event from JSON' do
+      original_event = EventSystem::Event.new(:test_type, 'TestSource', { key: 'value' })
+      json = original_event.to_json
+      reconstructed = EventSystem::Event.from_json(json)
+      
+      expect(reconstructed.id).to eq(original_event.id)
+      expect(reconstructed.type).to eq(original_event.type)
+      expect(reconstructed.source).to eq(original_event.source)
+      expect(reconstructed.data).to eq(original_event.data)
+      # Timestamps may have slight precision differences due to JSON serialization
+      expect(reconstructed.timestamp.to_f).to be_within(0.001).of(original_event.timestamp.to_f)
+    end
+
+    it 'handles JSON with missing optional fields' do
+      json = '{"type":"test_type","source":"TestSource","timestamp":"2023-01-01T12:00:00.000Z","id":"test-id"}'
+      event = EventSystem::Event.from_json(json)
+      
+      expect(event.type).to eq('test_type')
+      expect(event.source).to eq('TestSource')
+      expect(event.data).to eq({})
+      expect(event.id).to eq('test-id')
+    end
+  end
+
+  describe '#==' do
+    it 'compares events by ID' do
+      event1 = EventSystem::Event.new(:test_type, nil, {}, 'same-id')
+      event2 = EventSystem::Event.new(:different_type, 'different_source', { different: 'data' }, 'same-id')
+      
+      expect(event1).to eq(event2)
+    end
+
+    it 'returns false for different IDs' do
+      event1 = EventSystem::Event.new(:test_type, nil, {}, 'id1')
+      event2 = EventSystem::Event.new(:test_type, nil, {}, 'id2')
+      
+      expect(event1).not_to eq(event2)
+    end
+
+    it 'returns false for non-event objects' do
+      event = EventSystem::Event.new(:test_type)
+      expect(event).not_to eq('not an event')
+    end
+  end
+
+  describe '#hash' do
+    it 'returns hash based on ID' do
+      event1 = EventSystem::Event.new(:test_type, nil, {}, 'same-id')
+      event2 = EventSystem::Event.new(:different_type, nil, {}, 'same-id')
+      
+      expect(event1.hash).to eq(event2.hash)
+    end
+  end
+
+  describe '#type?' do
+    it 'checks if event matches type' do
+      event = EventSystem::Event.new(:test_type)
+      expect(event.type?('test_type')).to be true
+      expect(event.type?(:test_type)).to be true
+      expect(event.type?('different_type')).to be false
+    end
+  end
+
+  describe '#source_to_string' do
+    it 'converts nil source to string' do
+      event = EventSystem::Event.new(:test_type, nil)
+      expect(event.source_to_string).to eq('unknown')
+    end
+
+    it 'returns string source as-is' do
+      event = EventSystem::Event.new(:test_type, 'TestSource')
+      expect(event.source_to_string).to eq('TestSource')
+    end
+
+    it 'converts object source to string' do
+      source_obj = double('SourceObject', to_s: 'ObjectString')
+      event = EventSystem::Event.new(:test_type, source_obj)
+      expect(event.source_to_string).to eq('ObjectString')
+    end
+  end
+
+  describe 'serialization safety' do
+    it 'handles non-serializable objects in data' do
+      non_serializable = Object.new
+      event = EventSystem::Event.new(:test_type, nil, { obj: non_serializable })
+      
+      expect { event.to_json }.not_to raise_error
+      json = event.to_json
+      parsed = JSON.parse(json)
+      expect(parsed['data']['obj']).to include('Object')
+    end
+
+    it 'handles nested hashes and arrays' do
+      data = {
+        hash: { nested: 'value' },
+        array: [1, 2, { nested: 'value' }]
+      }
+      event = EventSystem::Event.new(:test_type, nil, data)
+      
+      expect { event.to_json }.not_to raise_error
+      reconstructed = EventSystem::Event.from_json(event.to_json)
+      expect(reconstructed.data).to eq(data)
+    end
+  end
+end

data/spec/event_system/event_subscriber_spec.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe EventSystem::EventSubscriber do
+  let(:subscriber_class) do
+    Class.new do
+      include EventSystem::EventSubscriber
+      
+      attr_reader :events_handled
+      
+      def initialize
+        @events_handled = []
+      end
+      
+      def handle_event(event)
+        @events_handled << event
+      end
+    end
+  end
+
+  let(:subscriber) { subscriber_class.new }
+
+  describe '#handle_event' do
+    it 'raises NotImplementedError when not implemented' do
+      abstract_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+      end.new
+
+      event = create_test_event(:test_type)
+      expect { abstract_subscriber.handle_event(event) }.to raise_error(NotImplementedError)
+    end
+
+    it 'handles events when implemented' do
+      event = create_test_event(:test_type)
+      subscriber.handle_event(event)
+      
+      expect(subscriber.events_handled).to include(event)
+    end
+  end
+
+  describe '#handles_event_type?' do
+    it 'returns true by default for all event types' do
+      expect(subscriber.handles_event_type?('any_type')).to be true
+      expect(subscriber.handles_event_type?('another_type')).to be true
+    end
+
+    it 'can be overridden for filtering' do
+      filtered_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+        
+        def handle_event(event)
+          # Implementation not needed for this test
+        end
+        
+        def handles_event_type?(event_type)
+          event_type == 'allowed_type'
+        end
+      end.new
+
+      expect(filtered_subscriber.handles_event_type?('allowed_type')).to be true
+      expect(filtered_subscriber.handles_event_type?('blocked_type')).to be false
+    end
+  end
+
+  describe '#event_priority' do
+    it 'returns 0 by default' do
+      expect(subscriber.event_priority).to eq(0)
+    end
+
+    it 'can be overridden for custom priority' do
+      priority_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+        
+        def handle_event(event)
+          # Implementation not needed for this test
+        end
+        
+        def event_priority
+          5
+        end
+      end.new
+
+      expect(priority_subscriber.event_priority).to eq(5)
+    end
+  end
+
+  describe 'integration with EventManager' do
+    it 'works with EventManager subscription' do
+      manager = create_test_manager
+      manager.subscribe(:test_event, subscriber)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      expect(subscriber.events_handled).to include(event)
+    end
+
+    it 'respects event type filtering' do
+      filtered_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+        
+        attr_reader :events_handled
+        
+        def initialize
+          @events_handled = []
+        end
+        
+        def handle_event(event)
+          @events_handled << event
+        end
+        
+        def handles_event_type?(event_type)
+          event_type == 'allowed_event'
+        end
+      end.new
+
+      manager = create_test_manager
+      manager.subscribe(:allowed_event, filtered_subscriber)
+      manager.subscribe(:blocked_event, filtered_subscriber)
+      
+      allowed_event = create_test_event(:allowed_event)
+      blocked_event = create_test_event(:blocked_event)
+      
+      manager.publish(allowed_event)
+      manager.publish(blocked_event)
+      
+      expect(filtered_subscriber.events_handled).to include(allowed_event)
+      expect(filtered_subscriber.events_handled).not_to include(blocked_event)
+    end
+
+    it 'respects priority ordering' do
+      high_priority_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+        
+        attr_reader :events_handled
+        
+        def initialize
+          @events_handled = []
+        end
+        
+        def handle_event(event)
+          @events_handled << "high_#{event.type}"
+        end
+        
+        def event_priority
+          1
+        end
+      end.new
+
+      low_priority_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+        
+        attr_reader :events_handled
+        
+        def initialize
+          @events_handled = []
+        end
+        
+        def handle_event(event)
+          @events_handled << "low_#{event.type}"
+        end
+        
+        def event_priority
+          10
+        end
+      end.new
+
+      manager = create_test_manager
+      manager.subscribe(:test_event, high_priority_subscriber)
+      manager.subscribe(:test_event, low_priority_subscriber)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      # Both should receive the event (priority affects order, not filtering)
+      expect(high_priority_subscriber.events_handled).to include('high_test_event')
+      expect(low_priority_subscriber.events_handled).to include('low_test_event')
+    end
+  end
+
+  describe 'real-world examples' do
+    it 'demonstrates logging subscriber' do
+      class LoggingSubscriber
+        include EventSystem::EventSubscriber
+        
+        attr_reader :logged_events
+        
+        def initialize
+          @logged_events = []
+        end
+        
+        def handle_event(event)
+          @logged_events << "[#{event.timestamp}] #{event.type}: #{event.data}"
+        end
+        
+        def handles_event_type?(event_type)
+          # Log all events
+          true
+        end
+      end
+
+      logger = LoggingSubscriber.new
+      manager = create_test_manager
+      manager.subscribe_all(logger)
+      
+      manager.publish_event(:user_login, 'AuthService', { user_id: 123 })
+      manager.publish_event(:order_created, 'OrderService', { order_id: 456 })
+      
+      expect(logger.logged_events.length).to eq(2)
+      expect(logger.logged_events.first).to include('user_login')
+      expect(logger.logged_events.last).to include('order_created')
+    end
+
+    it 'demonstrates metrics subscriber' do
+      class MetricsSubscriber
+        include EventSystem::EventSubscriber
+        
+        attr_reader :metrics
+        
+        def initialize
+          @metrics = Hash.new(0)
+        end
+        
+        def handle_event(event)
+          @metrics[event.type] += 1
+        end
+        
+        def handles_event_type?(event_type)
+          # Track all events
+          true
+        end
+      end
+
+      metrics = MetricsSubscriber.new
+      manager = create_test_manager
+      manager.subscribe_all(metrics)
+      
+      manager.publish_event(:user_login, 'AuthService', {})
+      manager.publish_event(:user_login, 'AuthService', {})
+      manager.publish_event(:order_created, 'OrderService', {})
+      
+      expect(metrics.metrics['user_login']).to eq(2)
+      expect(metrics.metrics['order_created']).to eq(1)
+    end
+
+    it 'demonstrates notification subscriber' do
+      class NotificationSubscriber
+        include EventSystem::EventSubscriber
+        
+        attr_reader :notifications_sent
+        
+        def initialize
+          @notifications_sent = []
+        end
+        
+        def handle_event(event)
+          case event.type
+          when 'user_registered'
+            send_welcome_email(event.data[:user_id])
+          when 'order_shipped'
+            send_shipping_notification(event.data[:order_id])
+          end
+        end
+        
+        def handles_event_type?(event_type)
+          ['user_registered', 'order_shipped'].include?(event_type)
+        end
+        
+        private
+        
+        def send_welcome_email(user_id)
+          @notifications_sent << "Welcome email sent to user #{user_id}"
+        end
+        
+        def send_shipping_notification(order_id)
+          @notifications_sent << "Shipping notification sent for order #{order_id}"
+        end
+      end
+
+      notifier = NotificationSubscriber.new
+      manager = create_test_manager
+      manager.subscribe(:user_registered, notifier)
+      manager.subscribe(:order_shipped, notifier)
+      
+      manager.publish_event(:user_registered, 'UserService', { user_id: 123 })
+      manager.publish_event(:order_shipped, 'OrderService', { order_id: 456 })
+      manager.publish_event(:user_login, 'AuthService', {}) # Should be ignored
+      
+      expect(notifier.notifications_sent.length).to eq(2)
+      expect(notifier.notifications_sent).to include('Welcome email sent to user 123')
+      expect(notifier.notifications_sent).to include('Shipping notification sent for order 456')
+    end
+  end
+end