event_system 0.1.0

data/spec/event_system/storage/file_store_spec.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe EventSystem::Storage::FileStore do
+  let(:temp_dir) { @temp_dir }
+  let(:store) { EventSystem::Storage::FileStore.new(temp_dir, 'test_session') }
+
+  describe '#initialize' do
+    it 'initializes with given directory and session ID' do
+      store = EventSystem::Storage::FileStore.new(temp_dir, 'custom_session')
+      expect(store.current_session).to eq('custom_session')
+      expect(store.storage_path).to eq(temp_dir)
+    end
+
+    it 'generates timestamp session ID when none provided' do
+      store = EventSystem::Storage::FileStore.new(temp_dir)
+      expect(store.current_session).to match(/\d{8}_\d{6}/)
+    end
+
+    it 'creates directory if it does not exist' do
+      new_dir = File.join(temp_dir, 'new_directory')
+      store = EventSystem::Storage::FileStore.new(new_dir)
+      expect(Dir.exist?(new_dir)).to be true
+    end
+  end
+
+  describe '#store' do
+    it 'stores an event to file' do
+      event = create_test_event(:test_type, 'TestSource', { key: 'value' })
+      store.store(event)
+      
+      # Read the file to verify event was stored
+      file_path = File.join(temp_dir, "events_#{store.current_session}.jsonl")
+      expect(File.exist?(file_path)).to be true
+      
+      content = File.read(file_path)
+      expect(content).to include(event.id)
+      expect(content).to include('test_type')
+    end
+
+    it 'flushes data immediately' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      # File should be immediately available
+      file_path = File.join(temp_dir, "events_#{store.current_session}.jsonl")
+      expect(File.exist?(file_path)).to be true
+    end
+  end
+
+  describe '#query' do
+    let(:event1) { create_test_event(:type1, 'Source1', { key: 'value1' }) }
+    let(:event2) { create_test_event(:type2, 'Source2', { key: 'value2' }) }
+    let(:event3) { create_test_event(:type1, 'Source1', { key: 'value3' }) }
+
+    before do
+      store.store(event1)
+      store.store(event2)
+      store.store(event3)
+    end
+
+    it 'returns all events by default' do
+      events = store.query
+      expect(events).to include(event1, event2, event3)
+    end
+
+    it 'filters by type' do
+      events = store.query(type: 'type1')
+      expect(events).to include(event1, event3)
+      expect(events).not_to include(event2)
+    end
+
+    it 'filters by session_id' do
+      store2 = EventSystem::Storage::FileStore.new(temp_dir, 'other_session')
+      other_event = create_test_event(:type1)
+      store2.store(other_event)
+
+      events = store.query(session_id: 'other_session')
+      expect(events).to include(other_event)
+      expect(events).not_to include(event1, event2, event3)
+    end
+
+    it 'filters by start_time' do
+      # Create a new store to avoid session conflicts
+      new_store = EventSystem::Storage::FileStore.new(@temp_dir, 'time_test_session')
+      
+      # Store events with different timestamps
+      past_event = EventSystem::Event.new(:past_type, 'Source', { key: 'past' }, nil, Time.now - 1)
+      future_event = EventSystem::Event.new(:future_type, 'Source', { key: 'future' }, nil, Time.now + 1)
+      
+      new_store.store(past_event)
+      new_store.store(future_event)
+      
+      # Query with start_time
+      start_time = Time.now
+      events = new_store.query(start_time: start_time)
+      expect(events).to include(future_event)
+      expect(events).not_to include(past_event)
+    end
+
+    it 'filters by end_time' do
+      # Create a new store to avoid session conflicts
+      new_store = EventSystem::Storage::FileStore.new(@temp_dir, 'time_test_session2')
+      
+      # Store events with different timestamps
+      past_event = EventSystem::Event.new(:past_type, 'Source', { key: 'past' }, nil, Time.now - 1)
+      future_event = EventSystem::Event.new(:future_type, 'Source', { key: 'future' }, nil, Time.now + 1)
+      
+      new_store.store(past_event)
+      new_store.store(future_event)
+      
+      # Query with end_time
+      end_time = Time.now
+      events = new_store.query(end_time: end_time)
+      expect(events).to include(past_event)
+      expect(events).not_to include(future_event)
+    end
+
+    it 'limits results' do
+      events = store.query(limit: 2)
+      expect(events.length).to eq(2)
+    end
+
+    it 'sorts by timestamp' do
+      events = store.query
+      timestamps = events.map(&:timestamp)
+      expect(timestamps).to eq(timestamps.sort)
+    end
+
+    it 'combines multiple filters' do
+      events = store.query(type: 'type1', limit: 1)
+      expect(events.length).to eq(1)
+      expect(events.first.type).to eq('type1')
+    end
+  end
+
+  describe '#load_session' do
+    it 'loads events from current session by default' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      events = store.load_session
+      expect(events).to include(event)
+    end
+
+    it 'loads events from specific session' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      events = store.load_session('test_session')
+      expect(events).to include(event)
+    end
+
+    it 'returns empty array for non-existent session' do
+      events = store.load_session('non_existent')
+      expect(events).to eq([])
+    end
+
+    it 'handles malformed JSON lines gracefully' do
+      file_path = File.join(temp_dir, "events_#{store.current_session}.jsonl")
+      File.write(file_path, "valid_json_line\nmalformed_json_line\n")
+      
+      events = store.load_session
+      expect(events).to be_empty
+    end
+
+    it 'skips empty lines' do
+      file_path = File.join(temp_dir, "events_#{store.current_session}.jsonl")
+      File.write(file_path, "\n\n")
+      
+      events = store.load_session
+      expect(events).to be_empty
+    end
+  end
+
+  describe '#list_sessions' do
+    it 'returns list of session files' do
+      # Store an event to create the session file
+      store.store(create_test_event(:test_type))
+      expect(store.list_sessions).to eq(['test_session'])
+    end
+
+    it 'includes sessions created after initialization' do
+      # Store an event to create the initial session file
+      store.store(create_test_event(:test_type))
+      store.create_session('new_session')
+      # Store an event in the new session to create its file
+      store.store(create_test_event(:test_type))
+      expect(store.list_sessions).to include('test_session', 'new_session')
+    end
+
+    it 'sorts sessions' do
+      store.create_session('a_session')
+      store.store(create_test_event(:test_type)) # Create file for a_session
+      store.create_session('z_session')
+      store.store(create_test_event(:test_type)) # Create file for z_session
+      
+      sessions = store.list_sessions
+      expect(sessions).to eq(sessions.sort)
+    end
+
+    it 'handles different filename patterns' do
+      # Create files with different patterns
+      File.write(File.join(temp_dir, 'events_session1.jsonl'), '')
+      File.write(File.join(temp_dir, 'session2.jsonl'), '')
+      
+      store = EventSystem::Storage::FileStore.new(temp_dir)
+      sessions = store.list_sessions
+      expect(sessions).to include('session1')
+      # session2.jsonl doesn't match the events_*.jsonl pattern
+    end
+  end
+
+  describe '#current_session' do
+    it 'returns current session ID' do
+      expect(store.current_session).to eq('test_session')
+    end
+  end
+
+  describe '#switch_session' do
+    it 'switches to different session' do
+      store.switch_session('new_session')
+      expect(store.current_session).to eq('new_session')
+    end
+
+    it 'closes current file when switching' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      store.switch_session('new_session')
+      
+      # Should be able to store to new session
+      new_event = create_test_event(:new_type)
+      expect { store.store(new_event) }.not_to raise_error
+    end
+  end
+
+  describe '#create_session' do
+    it 'creates session with given ID' do
+      session_id = store.create_session('custom_session')
+      expect(session_id).to eq('custom_session')
+      expect(store.current_session).to eq('custom_session')
+    end
+
+    it 'generates timestamp ID when none provided' do
+      session_id = store.create_session
+      expect(session_id).to match(/\d{8}_\d{6}/)
+      expect(store.current_session).to eq(session_id)
+    end
+  end
+
+  describe '#close' do
+    it 'closes file handle' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      store.close
+      
+      # Should be able to close multiple times
+      expect { store.close }.not_to raise_error
+    end
+  end
+
+  describe '#stats' do
+    it 'returns storage statistics' do
+      store.store(create_test_event(:type1))
+      store.create_session('other_session')
+      store.store(create_test_event(:type2)) # Create file for other_session
+      
+      stats = store.stats
+      expect(stats[:type]).to eq('EventSystem::Storage::FileStore')
+      expect(stats[:available]).to be true
+      expect(stats[:directory]).to eq(temp_dir)
+      expect(stats[:total_sessions]).to eq(2)
+    end
+  end
+
+  describe '#available?' do
+    it 'returns true' do
+      expect(store.available?).to be true
+    end
+  end
+
+  describe 'session isolation' do
+    it 'maintains separate files per session' do
+      event1 = create_test_event(:type1)
+      store.store(event1)
+      
+      store.create_session('session2')
+      event2 = create_test_event(:type2)
+      store.store(event2)
+      
+      session1_file = File.join(temp_dir, 'events_test_session.jsonl')
+      session2_file = File.join(temp_dir, 'events_session2.jsonl')
+      
+      expect(File.exist?(session1_file)).to be true
+      expect(File.exist?(session2_file)).to be true
+      
+      session1_content = File.read(session1_file)
+      session2_content = File.read(session2_file)
+      
+      expect(session1_content).to include('type1')
+      expect(session1_content).not_to include('type2')
+      expect(session2_content).to include('type2')
+      expect(session2_content).not_to include('type1')
+    end
+  end
+
+  describe 'file format' do
+    it 'stores events in JSONL format' do
+      event = create_test_event(:test_type, 'TestSource', { key: 'value' })
+      store.store(event)
+      
+      file_path = File.join(temp_dir, "events_#{store.current_session}.jsonl")
+      content = File.read(file_path)
+      
+      # Should be valid JSON
+      expect { JSON.parse(content) }.not_to raise_error
+      
+      # Should contain event data
+      parsed = JSON.parse(content, symbolize_names: true)
+      expect(parsed[:type]).to eq('test_type')
+      expect(parsed[:source]).to eq('TestSource')
+      expect(parsed[:data][:key]).to eq('value')
+    end
+  end
+
+  describe 'backward compatibility' do
+    it 'finds session files with different naming patterns' do
+      # Create file without events_ prefix
+      file_path = File.join(temp_dir, 'legacy_session.jsonl')
+      File.write(file_path, '{"type":"test","source":"test","timestamp":"2023-01-01T00:00:00.000Z","id":"test-id","data":{}}')
+      
+      store = EventSystem::Storage::FileStore.new(temp_dir)
+      events = store.load_session('legacy_session')
+      expect(events.length).to eq(1)
+      expect(events.first.type).to eq('test')
+    end
+  end
+end

data/spec/event_system/storage/memory_store_spec.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe EventSystem::Storage::MemoryStore do
+  let(:store) { EventSystem::Storage::MemoryStore.new('test_session') }
+
+  describe '#initialize' do
+    it 'initializes with given session ID' do
+      store = EventSystem::Storage::MemoryStore.new('custom_session')
+      expect(store.current_session).to eq('custom_session')
+    end
+
+    it 'generates timestamp session ID when none provided' do
+      store = EventSystem::Storage::MemoryStore.new
+      expect(store.current_session).to match(/\d{8}_\d{6}/)
+    end
+
+    it 'initializes empty events and sessions' do
+      expect(store.size).to eq(0)
+      expect(store.list_sessions).to eq(['test_session'])
+    end
+  end
+
+  describe '#store' do
+    it 'stores an event' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      expect(store.size).to eq(1)
+      expect(store.load_session).to include(event)
+    end
+
+    it 'stores event in current session' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      events = store.load_session('test_session')
+      expect(events).to include(event)
+    end
+  end
+
+  describe '#query' do
+    let(:event1) { create_test_event(:type1, 'Source1', { key: 'value1' }) }
+    let(:event2) { create_test_event(:type2, 'Source2', { key: 'value2' }) }
+    let(:event3) { create_test_event(:type1, 'Source1', { key: 'value3' }) }
+
+    before do
+      store.store(event1)
+      store.store(event2)
+      store.store(event3)
+    end
+
+    it 'returns all events by default' do
+      events = store.query
+      expect(events).to include(event1, event2, event3)
+    end
+
+    it 'filters by type' do
+      events = store.query(type: 'type1')
+      expect(events).to include(event1, event3)
+      expect(events).not_to include(event2)
+    end
+
+    it 'filters by session_id' do
+      store2 = EventSystem::Storage::MemoryStore.new('other_session')
+      other_event = create_test_event(:type1)
+      store2.store(other_event)
+
+      events = store2.query(session_id: 'other_session')
+      expect(events).to include(other_event)
+      expect(events).not_to include(event1, event2, event3)
+    end
+
+    it 'filters by start_time' do
+      start_time = event2.timestamp
+      events = store.query(start_time: start_time)
+      expect(events).to include(event2, event3)
+      expect(events).not_to include(event1)
+    end
+
+    it 'filters by end_time' do
+      end_time = event1.timestamp
+      events = store.query(end_time: end_time)
+      expect(events).to include(event1)
+      expect(events).not_to include(event2, event3)
+    end
+
+    it 'limits results' do
+      events = store.query(limit: 2)
+      expect(events.length).to eq(2)
+    end
+
+    it 'sorts by timestamp' do
+      events = store.query
+      timestamps = events.map(&:timestamp)
+      expect(timestamps).to eq(timestamps.sort)
+    end
+
+    it 'combines multiple filters' do
+      events = store.query(type: 'type1', limit: 1)
+      expect(events.length).to eq(1)
+      expect(events.first.type).to eq('type1')
+    end
+  end
+
+  describe '#load_session' do
+    it 'loads events from current session by default' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      events = store.load_session
+      expect(events).to include(event)
+    end
+
+    it 'loads events from specific session' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      
+      events = store.load_session('test_session')
+      expect(events).to include(event)
+    end
+
+    it 'returns empty array for non-existent session' do
+      events = store.load_session('non_existent')
+      expect(events).to eq([])
+    end
+  end
+
+  describe '#list_sessions' do
+    it 'returns list of session IDs' do
+      expect(store.list_sessions).to eq(['test_session'])
+    end
+
+    it 'includes sessions created after initialization' do
+      store.create_session('new_session')
+      expect(store.list_sessions).to include('test_session', 'new_session')
+    end
+
+    it 'sorts sessions' do
+      store.create_session('a_session')
+      store.create_session('z_session')
+      
+      sessions = store.list_sessions
+      expect(sessions).to eq(sessions.sort)
+    end
+  end
+
+  describe '#current_session' do
+    it 'returns current session ID' do
+      expect(store.current_session).to eq('test_session')
+    end
+  end
+
+  describe '#switch_session' do
+    it 'switches to different session' do
+      store.switch_session('new_session')
+      expect(store.current_session).to eq('new_session')
+    end
+
+    it 'creates session if it does not exist' do
+      store.switch_session('new_session')
+      expect(store.list_sessions).to include('new_session')
+    end
+  end
+
+  describe '#create_session' do
+    it 'creates session with given ID' do
+      session_id = store.create_session('custom_session')
+      expect(session_id).to eq('custom_session')
+      expect(store.current_session).to eq('custom_session')
+    end
+
+    it 'generates timestamp ID when none provided' do
+      session_id = store.create_session
+      expect(session_id).to match(/\d{8}_\d{6}/)
+      expect(store.current_session).to eq(session_id)
+    end
+  end
+
+  describe '#clear!' do
+    it 'clears all events and sessions' do
+      event = create_test_event(:test_type)
+      store.store(event)
+      store.create_session('other_session')
+      
+      store.clear!
+      
+      expect(store.size).to eq(0)
+      expect(store.list_sessions.length).to eq(1)
+      expect(store.current_session).to match(/\d{8}_\d{6}/)
+    end
+  end
+
+  describe '#size' do
+    it 'returns total number of events' do
+      expect(store.size).to eq(0)
+      
+      store.store(create_test_event(:type1))
+      store.store(create_test_event(:type2))
+      
+      expect(store.size).to eq(2)
+    end
+  end
+
+  describe '#stats' do
+    it 'returns storage statistics' do
+      store.store(create_test_event(:type1))
+      store.create_session('other_session')
+      store.store(create_test_event(:type2)) # Store event in new session
+      
+      stats = store.stats
+      expect(stats[:type]).to eq('EventSystem::Storage::MemoryStore')
+      expect(stats[:available]).to be true
+      expect(stats[:total_events]).to eq(2)
+      expect(stats[:sessions]).to eq(2)
+      expect(stats[:current_session_events]).to eq(1)
+    end
+  end
+
+  describe '#available?' do
+    it 'returns true' do
+      expect(store.available?).to be true
+    end
+  end
+
+  describe 'session isolation' do
+    it 'maintains separate events per session' do
+      # Use separate store instances to test isolation
+      store1 = EventSystem::Storage::MemoryStore.new('session1')
+      store2 = EventSystem::Storage::MemoryStore.new('session2')
+      
+      event1 = create_test_event(:type1)
+      event2 = create_test_event(:type2)
+      
+      store1.store(event1)
+      store2.store(event2)
+      
+      session1_events = store1.load_session('session1')
+      session2_events = store2.load_session('session2')
+      
+      expect(session1_events).to include(event1)
+      expect(session1_events).not_to include(event2)
+      expect(session2_events).to include(event2)
+      expect(session2_events).not_to include(event1)
+    end
+  end
+end