event_system 0.1.0

data/spec/event_system/configuration_spec.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe EventSystem::Configuration do
+  let(:config) { EventSystem::Configuration.new }
+
+  describe '#initialize' do
+    it 'sets default values' do
+      expect(config.storage_type).to eq(:memory)
+      expect(config.storage_options).to eq({})
+      expect(config.logger).to be_a(Logger) # Logger is created on first access
+      expect(config.session_id).to be_a(String) # Session ID is generated on first access
+      expect(config.auto_flush).to be true
+    end
+  end
+
+  describe '#storage_class' do
+    it 'returns MemoryStore for memory type' do
+      config.storage_type = :memory
+      expect(config.storage_class).to eq(EventSystem::Storage::MemoryStore)
+    end
+
+    it 'returns FileStore for file type' do
+      config.storage_type = :file
+      expect(config.storage_class).to eq(EventSystem::Storage::FileStore)
+    end
+
+    it 'raises error for unknown storage type' do
+      config.storage_type = :unknown
+      expect { config.storage_class }.to raise_error(ArgumentError, /Unknown storage type/)
+    end
+  end
+
+  describe '#create_storage' do
+    it 'creates MemoryStore with session_id' do
+      config.storage_type = :memory
+      config.session_id = 'test_session'
+      
+      storage = config.create_storage
+      expect(storage).to be_a(EventSystem::Storage::MemoryStore)
+      expect(storage.current_session).to eq('test_session')
+    end
+
+    it 'creates FileStore with directory and session_id' do
+      config.storage_type = :file
+      config.storage_options = { directory: 'test_logs' }
+      config.session_id = 'test_session'
+      
+      storage = config.create_storage
+      expect(storage).to be_a(EventSystem::Storage::FileStore)
+      expect(storage.current_session).to eq('test_session')
+    end
+
+    it 'uses default directory for file storage' do
+      config.storage_type = :file
+      storage = config.create_storage
+      expect(storage).to be_a(EventSystem::Storage::FileStore)
+    end
+  end
+
+  describe '#logger' do
+    it 'creates default logger when none set' do
+      logger = config.logger
+      expect(logger).to be_a(Logger)
+      expect(logger.level).to eq(Logger::INFO)
+    end
+
+    it 'returns set logger' do
+      custom_logger = Logger.new(StringIO.new)
+      config.logger = custom_logger
+      expect(config.logger).to eq(custom_logger)
+    end
+  end
+
+  describe '#session_id' do
+    it 'generates timestamp-based session ID when none set' do
+      session_id = config.session_id
+      expect(session_id).to match(/\d{8}_\d{6}/)
+    end
+
+    it 'returns set session ID' do
+      config.session_id = 'custom_session'
+      expect(config.session_id).to eq('custom_session')
+    end
+  end
+
+  describe '#reset!' do
+    it 'resets to default values' do
+      config.storage_type = :file
+      config.storage_options = { directory: 'test' }
+      config.logger = Logger.new(StringIO.new)
+      config.session_id = 'test_session'
+      config.auto_flush = false
+
+      config.reset!
+
+      expect(config.storage_type).to eq(:memory)
+      expect(config.storage_options).to eq({})
+      expect(config.logger).to be_a(Logger) # Logger is recreated on first access
+      expect(config.session_id).to be_a(String) # Session ID is generated on first access
+      expect(config.auto_flush).to be true
+    end
+  end
+
+  describe '#valid?' do
+    it 'returns true for valid memory configuration' do
+      config.storage_type = :memory
+      expect(config.valid?).to be true
+    end
+
+    it 'returns true for valid file configuration with directory' do
+      config.storage_type = :file
+      config.storage_options = { directory: 'test_logs' }
+      expect(config.valid?).to be true
+    end
+
+    it 'returns false for file configuration without directory' do
+      config.storage_type = :file
+      config.storage_options = {}
+      expect(config.valid?).to be false
+    end
+
+    it 'returns false for file configuration with empty directory' do
+      config.storage_type = :file
+      config.storage_options = { directory: '' }
+      expect(config.valid?).to be false
+    end
+
+    it 'returns false for unknown storage type' do
+      config.storage_type = :unknown
+      expect(config.valid?).to be false
+    end
+
+    it 'returns false for nil storage options' do
+      config.storage_type = :memory
+      config.storage_options = nil
+      expect(config.valid?).to be false
+    end
+
+    it 'handles string keys in storage options' do
+      config.storage_type = :file
+      config.storage_options = { 'directory' => 'test_logs' }
+      expect(config.valid?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns configuration as hash' do
+      config.storage_type = :file
+      config.storage_options = { directory: 'test' }
+      config.session_id = 'test_session'
+      config.auto_flush = false
+
+      hash = config.to_h
+      expect(hash[:storage_type]).to eq(:file)
+      expect(hash[:storage_options]).to eq({ directory: 'test' })
+      expect(hash[:session_id]).to eq('test_session')
+      expect(hash[:auto_flush]).to be false
+    end
+  end
+
+  describe 'storage constructor args' do
+    it 'returns correct args for memory storage' do
+      config.storage_type = :memory
+      config.session_id = 'test_session'
+      
+      args = config.send(:storage_constructor_args)
+      expect(args).to eq(['test_session'])
+    end
+
+    it 'returns correct args for file storage' do
+      config.storage_type = :file
+      config.storage_options = { directory: 'test_logs' }
+      config.session_id = 'test_session'
+      
+      args = config.send(:storage_constructor_args)
+      expect(args).to eq(['test_logs', 'test_session'])
+    end
+
+    it 'uses default directory for file storage' do
+      config.storage_type = :file
+      config.storage_options = {}
+      
+      args = config.send(:storage_constructor_args)
+      expect(args).to eq(['event_logs', nil])
+    end
+
+    it 'handles string keys in storage options' do
+      config.storage_type = :file
+      config.storage_options = { 'directory' => 'test_logs' }
+      
+      args = config.send(:storage_constructor_args)
+      expect(args).to eq(['test_logs', nil])
+    end
+  end
+end

data/spec/event_system/event_manager_spec.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe EventSystem::EventManager do
+  let(:manager) { create_test_manager }
+
+  describe '#initialize' do
+    it 'initializes with default configuration' do
+      manager = EventSystem::EventManager.new
+      expect(manager.config).to be_a(EventSystem::Configuration)
+      expect(manager.config.storage_type).to eq(:memory)
+    end
+
+    it 'initializes with hash configuration' do
+      config = { storage_type: :file, storage_options: { directory: 'test' } }
+      manager = EventSystem::EventManager.new(config)
+      expect(manager.config.storage_type).to eq(:file)
+    end
+
+    it 'initializes with Configuration object' do
+      config = EventSystem::Configuration.new
+      config.storage_type = :file
+      manager = EventSystem::EventManager.new(config)
+      expect(manager.config).to eq(config)
+    end
+  end
+
+  describe '#subscribe' do
+    it 'subscribes a subscriber to a specific event type' do
+      subscriber = create_test_subscriber
+      manager.subscribe(:test_event, subscriber)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      expect(subscriber.events_received).to include(event)
+    end
+
+    it 'converts event type to string' do
+      subscriber = create_test_subscriber
+      manager.subscribe(:test_event, subscriber)
+      
+      event = create_test_event('test_event')
+      manager.publish(event)
+      
+      expect(subscriber.events_received).to include(event)
+    end
+
+    it 'allows multiple subscribers for same event type' do
+      subscriber1 = create_test_subscriber('Sub1')
+      subscriber2 = create_test_subscriber('Sub2')
+      
+      manager.subscribe(:test_event, subscriber1)
+      manager.subscribe(:test_event, subscriber2)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      expect(subscriber1.events_received).to include(event)
+      expect(subscriber2.events_received).to include(event)
+    end
+  end
+
+  describe '#unsubscribe' do
+    it 'unsubscribes a subscriber from an event type' do
+      subscriber = create_test_subscriber
+      manager.subscribe(:test_event, subscriber)
+      manager.unsubscribe(:test_event, subscriber)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      expect(subscriber.events_received).to be_empty
+    end
+
+    it 'handles unsubscribing non-existent subscriber gracefully' do
+      subscriber = create_test_subscriber
+      expect { manager.unsubscribe(:test_event, subscriber) }.not_to raise_error
+    end
+  end
+
+  describe '#subscribe_all' do
+    it 'subscribes a subscriber to all event types' do
+      subscriber = create_test_subscriber
+      manager.subscribe_all(subscriber)
+      
+      event1 = create_test_event(:event1)
+      event2 = create_test_event(:event2)
+      
+      manager.publish(event1)
+      manager.publish(event2)
+      
+      expect(subscriber.events_received).to include(event1, event2)
+    end
+  end
+
+  describe '#unsubscribe_all' do
+    it 'unsubscribes a subscriber from all events' do
+      subscriber = create_test_subscriber
+      manager.subscribe_all(subscriber)
+      manager.unsubscribe_all(subscriber)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      expect(subscriber.events_received).to be_empty
+    end
+  end
+
+  describe '#publish' do
+    it 'publishes an event to subscribers' do
+      subscriber = create_test_subscriber
+      manager.subscribe(:test_event, subscriber)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      expect(subscriber.events_received).to include(event)
+    end
+
+    it 'stores event in storage' do
+      manager = create_file_manager
+      event = create_test_event(:test_event)
+      
+      manager.publish(event)
+      
+      events = manager.query_events(type: 'test_event')
+      expect(events).to include(event)
+    end
+
+    it 'delivers to both type-specific and universal subscribers' do
+      type_subscriber = create_test_subscriber('TypeSub')
+      universal_subscriber = create_test_subscriber('UniversalSub')
+      
+      manager.subscribe(:test_event, type_subscriber)
+      manager.subscribe_all(universal_subscriber)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      expect(type_subscriber.events_received).to include(event)
+      expect(universal_subscriber.events_received).to include(event)
+    end
+
+    it 'handles subscriber errors gracefully' do
+      error_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+        def handle_event(event)
+          raise StandardError, 'Test error'
+        end
+      end.new
+
+      manager.subscribe(:test_event, error_subscriber)
+      
+      event = create_test_event(:test_event)
+      expect { manager.publish(event) }.not_to raise_error
+    end
+  end
+
+  describe '#publish_event' do
+    it 'creates and publishes an event' do
+      subscriber = create_test_subscriber
+      manager.subscribe(:test_event, subscriber)
+      
+      event = manager.publish_event(:test_event, 'TestSource', { key: 'value' })
+      
+      expect(event).to be_a(EventSystem::Event)
+      expect(event.type).to eq('test_event')
+      expect(event.source).to eq('TestSource')
+      expect(event.data).to eq({ key: 'value' })
+      expect(subscriber.events_received).to include(event)
+    end
+
+    it 'creates event with minimal parameters' do
+      event = manager.publish_event(:test_event)
+      expect(event.type).to eq('test_event')
+      expect(event.source).to be_nil
+      expect(event.data).to eq({})
+    end
+  end
+
+  describe '#query_events' do
+    it 'queries events from storage' do
+      manager = create_file_manager
+      event1 = create_test_event(:type1)
+      event2 = create_test_event(:type2)
+      
+      manager.publish(event1)
+      manager.publish(event2)
+      
+      events = manager.query_events(type: 'type1')
+      expect(events).to include(event1)
+      expect(events).not_to include(event2)
+    end
+
+    it 'returns empty array when no storage' do
+      manager = create_test_manager(:memory)
+      events = manager.query_events
+      expect(events).to eq([])
+    end
+  end
+
+  describe '#current_session' do
+    it 'returns current session from storage' do
+      manager = create_file_manager
+      expect(manager.current_session).to be_a(String)
+    end
+
+    it 'returns current session from memory storage' do
+      manager = create_test_manager(:memory)
+      expect(manager.current_session).to be_a(String)
+    end
+  end
+
+  describe '#switch_session' do
+    it 'switches to different session' do
+      manager = create_file_manager
+      original_session = manager.current_session
+      
+      manager.switch_session('new_session')
+      
+      expect(manager.current_session).to eq('new_session')
+      expect(manager.current_session).not_to eq(original_session)
+    end
+  end
+
+  describe '#create_session' do
+    it 'creates new session with given ID' do
+      manager = create_file_manager
+      session_id = manager.create_session('custom_session')
+      
+      expect(session_id).to eq('custom_session')
+      expect(manager.current_session).to eq('custom_session')
+    end
+
+    it 'creates new session with auto-generated ID' do
+      manager = create_file_manager
+      session_id = manager.create_session
+      
+      expect(session_id).to match(/\d{8}_\d{6}/)
+      expect(manager.current_session).to eq(session_id)
+    end
+  end
+
+  describe '#stats' do
+    it 'returns system statistics' do
+      stats = manager.stats
+      
+      expect(stats).to have_key(:subscribers)
+      expect(stats).to have_key(:storage)
+      expect(stats).to have_key(:config)
+    end
+
+    it 'includes subscriber counts' do
+      subscriber1 = create_test_subscriber
+      subscriber2 = create_test_subscriber
+      
+      manager.subscribe(:event1, subscriber1)
+      manager.subscribe(:event1, subscriber2)
+      manager.subscribe(:event2, subscriber1)
+      
+      stats = manager.stats
+      expect(stats[:subscribers]['event1']).to eq(2)
+      expect(stats[:subscribers]['event2']).to eq(1)
+    end
+  end
+
+  describe '#close' do
+    it 'closes the event manager' do
+      manager = create_file_manager
+      expect { manager.close }.not_to raise_error
+    end
+  end
+
+  describe '#ready?' do
+    it 'returns true when storage is available' do
+      manager = create_file_manager
+      expect(manager.ready?).to be true
+    end
+
+    it 'returns true when memory storage is available' do
+      manager = create_test_manager(:memory)
+      expect(manager.ready?).to be true
+    end
+  end
+
+  describe 'subscriber priority' do
+    it 'processes subscribers in priority order' do
+      high_priority = Class.new do
+        include EventSystem::EventSubscriber
+        attr_reader :events_received
+        def initialize; @events_received = []; end
+        def handle_event(event); @events_received << "high_#{event.type}"; end
+        def event_priority; 1; end
+      end.new
+
+      low_priority = Class.new do
+        include EventSystem::EventSubscriber
+        attr_reader :events_received
+        def initialize; @events_received = []; end
+        def handle_event(event); @events_received << "low_#{event.type}"; end
+        def event_priority; 10; end
+      end.new
+
+      manager.subscribe(:test_event, high_priority)
+      manager.subscribe(:test_event, low_priority)
+      
+      event = create_test_event(:test_event)
+      manager.publish(event)
+      
+      # High priority should be processed first (lower number = higher priority)
+      expect(high_priority.events_received).to include('high_test_event')
+      expect(low_priority.events_received).to include('low_test_event')
+    end
+  end
+
+  describe 'event type filtering' do
+    it 'respects subscriber event type filtering' do
+      filtered_subscriber = Class.new do
+        include EventSystem::EventSubscriber
+        attr_reader :events_received
+        def initialize; @events_received = []; end
+        def handle_event(event); @events_received << event; end
+        def handles_event_type?(event_type); event_type == 'allowed_event'; end
+      end.new
+
+      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_received).to include(allowed_event)
+      expect(filtered_subscriber.events_received).not_to include(blocked_event)
+    end
+  end
+end