systemd-journal 1.1.2 → 1.1.3

data/spec/spec_helper.rb

@@ -1,43 +1,32 @@
 require 'rspec'
+require 'json'
 require 'simplecov'
 
+module SpecHelper
+  def fixture_dir
+    @path ||= File.join(File.expand_path(__dir__), 'fixtures')
+  end
+
+  def journal_file
+    @file ||= File.join(fixture_dir, 'test.journal')
+  end
+
+  def journal_json
+    @json ||= JSON.parse(File.read(File.join(fixture_dir, 'test.json')))
+  end
+
+  def entry_field(index, name)
+    journal_json[index][name.to_s.upcase]
+  end
+end
+
 SimpleCov.start do
   add_filter '.bundle/'
 end
 require 'systemd/journal'
 
 RSpec.configure do |config|
-  config.before(:each) do
-
-    # Stub open and close calls
-    dummy_open = ->(ptr, flags, path = nil) do
-      ptr.write_pointer(nil)
-      0
-    end
-
-    ['', '_directory', '_files', '_container'].each do |suffix|
-      Systemd::Journal::Native.stub(:"sd_journal_open#{suffix}", &dummy_open)
-    end
-    Systemd::Journal::Native.stub(:sd_journal_close).and_return(0)
-
-    # Raise an exception if any native calls are actually called
-    native_calls = Systemd::Journal::Native.methods.select do |m|
-      m.to_s.start_with?('sd_')
-    end
 
-    native_calls -= [
-      :sd_journal_open, :sd_journal_open_directory, :sd_journal_close,
-      :sd_journal_open_files, :sd_journal_open_container
-    ]
-
-    build_err_proc = ->(method_name) do
-      return ->(*params) do
-        raise RuntimeError.new("#{method_name} called without being stubbed.")
-      end
-    end
-
-    native_calls.each do |meth|
-      Systemd::Journal::Native.stub(meth, &build_err_proc.call(meth))
-    end
-  end
+  config.disable_monkey_patching!
+  config.include SpecHelper
 end

data/spec/systemd/journal_spec.rb

@@ -1,556 +1,140 @@
 require 'spec_helper'
 
-describe Systemd::Journal do
-
-  describe '#initialize' do
-    it 'opens a directory if a path is passed' do
-      Systemd::Journal::Native.should_receive(:sd_journal_open_directory)
-      Systemd::Journal::Native.should_not_receive(:sd_journal_open)
-      Systemd::Journal.new(path: '/path/to/journal')
-    end
-
-    it 'accepts flags as an argument' do
-      Systemd::Journal::Native.should_receive(:sd_journal_open)
-        .with(anything, 1234)
-
-      Systemd::Journal.new(flags: 1234)
-    end
-
-    it 'accepts a files argument to open specific files' do
-      Systemd::Journal::Native.should_receive(:sd_journal_open_files)
-      Systemd::Journal.new(files: ['/path/to/journal/1', '/path/to/journal/2'])
-    end
-
-    it 'accepts a machine name to open a container' do
-      Systemd::Journal::Native.should_receive(:sd_journal_open_container)
-      Systemd::Journal.new(container: 'bobs-machine')
-    end
-
-    it 'raises a Journal Error if a native call fails' do
-      Systemd::Journal::Native.should_receive(:sd_journal_open).and_return(-1)
-      expect { Systemd::Journal.new }.to raise_error(Systemd::JournalError)
-    end
-
-    it 'raises an argument error if conflicting options are passed' do
-      expect do
-        Systemd::Journal.new(path: 'p', files: %w{a b})
-      end.to raise_error(ArgumentError)
-      expect do
-        Systemd::Journal.new(container: 'c', files: %w{a b})
-      end.to raise_error(ArgumentError)
+RSpec.describe Systemd::Journal do
+  subject(:j) do
+    Systemd::Journal.new(files: [journal_file]).tap do |j|
+      j.seek(:head)
+      j.move_next
     end
   end
 
-  describe '#move' do
-    it 'calls move_next_skip if the value is positive' do
-      j = Systemd::Journal.new
-      j.should_receive(:move_next_skip).with(5)
-      j.move(5)
-    end
-
-    it 'calls move_next_previous otherwise' do
-      j = Systemd::Journal.new
-      j.should_receive(:move_previous_skip).with(5)
-      j.move(-5)
-    end
-  end
-
-  %w{next previous}.each do |direction|
-    describe "#move_#{direction}" do
-      it 'returns true on a successful move' do
-        j = Systemd::Journal.new
-        Systemd::Journal::Native
-          .should_receive(:"sd_journal_#{direction}")
-          .and_return(1)
-
-        j.send(:"move_#{direction}").should eq(true)
-      end
+  describe 'initialize' do
+    subject(:j) { Systemd::Journal }
 
-      it 'returns false on EOF' do
-        j = Systemd::Journal.new
-        Systemd::Journal::Native
-          .should_receive(:"sd_journal_#{direction}")
-          .and_return(0)
-
-        j.send(:"move_#{direction}").should eq(false)
-      end
-
-      it 'raises an exception on failure' do
-        j = Systemd::Journal.new
-        Systemd::Journal::Native
-          .should_receive(:"sd_journal_#{direction}")
-          .and_return(-1)
-
-        expect do
-          j.send(:"move_#{direction}")
-        end.to raise_error(Systemd::JournalError)
-      end
-    end
-
-    describe "#move_#{direction}_skip" do
-      it 'returns the number of records moved by' do
-        Systemd::Journal::Native
-          .should_receive(:"sd_journal_#{direction}_skip")
-          .with(anything, 10)
-          .and_return(10)
-
-        Systemd::Journal.new.send(:"move_#{direction}_skip", 10).should eq(10)
-      end
-
-      it 'raises an exception on failure' do
-        Systemd::Journal::Native
-          .should_receive(:"sd_journal_#{direction}_skip")
-          .with(anything, 10)
-          .and_return(-1)
-
-        j = Systemd::Journal.new
-
-        expect do
-          j.send(:"move_#{direction}_skip", 10)
-        end.to raise_error(Systemd::JournalError)
-      end
+    it 'detects invalid argument combinations' do
+      expect { j.new(path: '/',     files: []) }.to raise_error(ArgumentError)
+      expect { j.new(container: '', files: []) }.to raise_error(ArgumentError)
+      expect { j.new(container: '', path: '/') }.to raise_error(ArgumentError)
     end
   end
 
-  describe '#each' do
-    it 'should reposition to the head of the journal' do
-      j = Systemd::Journal.new
-      j.should_receive(:seek).with(:head).and_return(0)
-      j.stub(:move_next).and_return(nil)
-      j.each { |e| nil }
-    end
-
-    it 'should return an enumerator if no block is given' do
-      j = Systemd::Journal.new
-      j.each.class.should eq(Enumerator)
-    end
-
-    it 'should return each entry in the journal' do
-      entries = [{ '_PID' => 1 }, { '_PID' => 2 }]
-      entry   = nil
-
-      j = Systemd::Journal.new
-      j.stub(:seek).and_return(0)
-      j.stub(:current_entry) { entry }
-      j.stub(:move_next)     { entry = entries.shift }
-
-      j.map { |e| e['_PID'] }.should eq([1, 2])
-    end
-
-  end
-
-  describe '#seek' do
-    it 'moves to the first entry of the file' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_seek_head)
-        .and_return(0)
-
-      j.seek(:head).should eq(true)
-    end
-
-    it 'moves to the last entry of the file' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_seek_tail)
-        .and_return(0)
-
-      j.seek(:tail).should eq(true)
-    end
-
-    it 'seeks based on time when a time is provided' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_seek_realtime_usec)
-        .and_return(0)
-
-      j.seek(Time.now).should eq(true)
-    end
-
-    it 'seeks based on a cursor when a string is provided' do
-      j = Systemd::Journal.new
-
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_seek_cursor)
-        .with(anything, '123')
-        .and_return(0)
-
-      j.seek('123')
-    end
-
-    it 'throws an exception if it doesnt understand the type' do
-      j = Systemd::Journal.new
-      expect { j.seek(Object.new) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#read_field' do
-    it 'raises an exception if the call fails' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_data)
-        .and_return(-1)
-
-      expect { j.read_field(:message) }.to raise_error(Systemd::JournalError)
-    end
-
-    it 'parses the returned value correctly.' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_data) do |ptr, field, out_ptr, len_ptr|
-          dummy = 'MESSAGE=hello world'
-          out_ptr.write_pointer(FFI::MemoryPointer.from_string(dummy))
-          len_ptr.write_size_t(dummy.size)
-          0
-        end
-
-      j.read_field(:message).should eq('hello world')
-    end
-  end
-
-  describe '#current_entry' do
-    before(:each) do
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_restart_data)
-        .and_return(nil)
-    end
-
-    it 'raises an exception if the call fails' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_enumerate_data)
-        .and_return(-1)
-
-      expect { j.current_entry }.to raise_error(Systemd::JournalError)
-    end
-
-    it 'returns the correct data' do
-      j = Systemd::Journal.new
-      results = ['_PID=100', 'MESSAGE=hello world']
-
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_enumerate_data)
-        .exactly(3).times do |ptr, out_ptr, len_ptr|
-          if results.any?
-            x = results.shift
-            out_ptr.write_pointer(FFI::MemoryPointer.from_string(x))
-            len_ptr.write_size_t(x.length)
-            1
-          else
-            0
-          end
-        end
-
-      entry = j.current_entry
-
-      entry._pid.should     eq('100')
-      entry.message.should eq('hello world')
-    end
-  end
-
-  describe '#query_unique' do
-    before(:each) do
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_restart_unique)
-        .and_return(nil)
-    end
-
-    it 'raises an exception if the call fails' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_query_unique)
-        .and_return(-1)
-
-      expect { j.query_unique(:_pid) }.to raise_error(Systemd::JournalError)
-    end
-
-    it 'raises an exception if the call fails (2)' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_query_unique)
-        .and_return(0)
-
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_enumerate_unique)
+  describe 'query_unique' do
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native).to receive(:sd_journal_enumerate_unique)
         .and_return(-1)
 
       expect { j.query_unique(:_pid) }.to raise_error(Systemd::JournalError)
     end
 
-    it 'returns the correct data' do
-      j = Systemd::Journal.new
-      results = ['_PID=100', '_PID=200', '_PID=300']
-
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_query_unique)
-        .and_return(0)
+    it 'lists all the unique values for the given field' do
+      values     = j.query_unique(:_transport)
+      transports = %w(syslog journal stdout kernel driver)
 
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_enumerate_unique)
-        .exactly(4).times do |ptr, out_ptr, len_ptr|
-          if results.any?
-            x = results.shift
-            out_ptr.write_pointer(FFI::MemoryPointer.from_string(x))
-            len_ptr.write_size_t(x.length)
-            1
-          else
-            0
-          end
-        end
-
-      j.query_unique(:_pid).should eq(%w{100 200 300})
+      expect(values.length).to eq(5)
+      expect(values).to        include(*transports)
     end
-
   end
 
-  describe '#wait' do
-    it 'raises an exception if the call fails' do
-      Systemd::Journal::Native.should_receive(:sd_journal_wait).and_return(-1)
-
-      j = Systemd::Journal.new
-      expect { j.wait(100) }.to raise_error(Systemd::JournalError)
-    end
-
-    it 'returns the reason we were woken up' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_wait)
-        .and_return(:append)
-
-      j.wait(100).should eq(:append)
-    end
-
-    it 'returns nil if we reached the timeout.' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_wait)
-        .and_return(:nop)
-
-      j.wait(100).should eq(nil)
-    end
-  end
-
-  describe '#add_filter' do
-    it 'raises an exception if the call fails' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_add_match)
+  describe 'disk_usage' do
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native).to receive(:sd_journal_get_usage)
         .and_return(-1)
 
-      expect do
-        j.add_filter(:message, 'test')
-      end.to raise_error(Systemd::JournalError)
-    end
-
-    it 'formats the arguments appropriately' do
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_add_match)
-        .with(anything, 'MESSAGE=test', 'MESSAGE=test'.length)
-        .and_return(0)
-
-      Systemd::Journal.new.add_filter(:message, 'test')
-    end
-  end
-
-  describe '#add_filters' do
-    it 'calls add_filter for each parameter' do
-      j = Systemd::Journal.new
-      j.should_receive(:add_filter).with(:priority, 1)
-      j.should_receive(:add_filter).with(:_exe, '/usr/bin/sshd')
-
-      j.add_filters(priority: 1, _exe: '/usr/bin/sshd')
+      expect { j.disk_usage }.to raise_error(Systemd::JournalError)
     end
 
-    it 'expands array arguments to multiple add_filter calls' do
-      j = Systemd::Journal.new
-      j.should_receive(:add_filter).with(:priority, 1)
-      j.should_receive(:add_filter).with(:priority, 2)
-      j.should_receive(:add_filter).with(:priority, 3)
-
-      j.add_filters(priority: [1, 2, 3])
+    it 'returns the disk usage of the example journal file' do
+      expect(j.disk_usage).to eq(4005888)
     end
   end
 
-  describe '#filter' do
-    it 'clears the existing filters' do
-      j = Systemd::Journal.new
-      j.should_receive(:clear_filters)
+  describe 'data_threshold' do
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native).to receive(:sd_journal_get_data_threshold)
+        .and_return(-1)
 
-      j.filter({})
+      expect { j.data_threshold }.to raise_error(Systemd::JournalError)
     end
 
-    it 'adds disjunctions between terms' do
-      j = Systemd::Journal.new
-      j.stub(:clear_filters).and_return(nil)
-
-      j.should_receive(:add_filter).with(:priority, 1).ordered
-      j.should_receive(:add_disjunction).ordered
-      j.should_receive(:add_filter).with(:message, 'hello').ordered
-
-      j.filter({ priority: 1 }, { message: 'hello' })
-
+    it 'returns the default 64K' do
+      expect(j.data_threshold).to eq(0x0010000)
     end
   end
 
-  describe '#add_conjunction' do
-    it 'raises an exception if the call fails' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_add_conjunction)
+  describe 'data_threshold=' do
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native).to receive(:sd_journal_set_data_threshold)
         .and_return(-1)
 
-      expect { j.add_conjunction }.to raise_error(Systemd::JournalError)
+      expect { j.data_threshold = 10 }.to raise_error(Systemd::JournalError)
     end
   end
 
-  describe '#add_disjunction' do
-    it 'raises an exception if the call fails' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_add_disjunction)
+  describe 'read_field' do
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native).to receive(:sd_journal_get_data)
         .and_return(-1)
 
-      expect { j.add_disjunction }.to raise_error(Systemd::JournalError)
+      expect { j.read_field(:message) }.to raise_error(Systemd::JournalError)
     end
-  end
 
-  describe '#clear_filters' do
-    it 'flushes the matches' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_flush_matches)
-        .and_return(nil)
-
-      j.clear_filters
+    it 'returns the correct value' do
+      expect(j.read_field(:_hostname)).to eq('arch')
     end
   end
 
-  describe '#disk_usage' do
-    it 'returns the size used on disk' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_usage) do |ptr, size_ptr|
-          size_ptr.write_size_t(12)
-          0
-        end
-
-      j.disk_usage.should eq(12)
-    end
-
-    it 'raises an error if the call fails' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_usage)
+  describe 'current_entry' do
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native).to receive(:sd_journal_enumerate_data)
         .and_return(-1)
 
-      expect { j.disk_usage }.to raise_error(Systemd::JournalError)
-    end
-  end
-
-  describe '#data_threshold=' do
-    it 'sets the data threshold' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_set_data_threshold)
-        .with(anything, 0x1234)
-        .and_return(0)
-
-      j.data_threshold = 0x1234
-    end
-
-    it 'raises a JournalError on failure' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_set_data_threshold)
-        .with(anything, 0x1234)
-        .and_return(-1)
-
-      expect do
-        j.data_threshold = 0x1234
-      end.to raise_error(Systemd::JournalError)
-    end
-  end
-
-  describe '#data_threshold' do
-    it 'gets the data threshold' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_data_threshold) do |ptr, size_ptr|
-          size_ptr.write_size_t(0x1234)
-          0
-        end
-
-      j.data_threshold.should eq(0x1234)
+      expect { j.current_entry }.to raise_error(Systemd::JournalError)
     end
 
-    it 'raises a JournalError on failure' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_data_threshold)
-        .and_return(-3)
-
-      expect { j.data_threshold }.to raise_error(Systemd::JournalError)
+    it 'returns a JournalEntry with the correct values' do
+      entry = j.current_entry
+      expect(entry._hostname).to eq('arch')
+      expect(entry.message).to   start_with('Allowing runtime journal')
     end
-
   end
 
-  describe '#cursor?' do
-    it 'returns true if the current cursor is the provided value' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_test_cursor)
-        .with(anything, '1234').and_return(1)
-
-      j.cursor?('1234').should eq(true)
+  describe 'each' do
+    it 'returns an enumerator' do
+      expect(j.each.class).to be Enumerator
     end
 
-    it 'returns false otherwise' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_test_cursor)
-        .with(anything, '1234')
-        .and_return(0)
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native).to receive(:sd_journal_seek_head)
+        .and_return(-1)
 
-      j.cursor?('1234').should eq(false)
+      expect { j.each }.to raise_error(Systemd::JournalError)
     end
 
-    it 'raises a JournalError on failure' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_test_cursor)
-        .and_return(-3)
+    it 'properly enumerates all the entries' do
+      entries = j.each.map(&:message)
 
-      expect { j.cursor?('123') }.to raise_error(Systemd::JournalError)
+      expect(entries.first).to start_with('Allowing runtime journal')
+      expect(entries.last).to  start_with('ROOT LOGIN ON tty1')
     end
-
   end
 
-  describe '#cursor' do
-    it 'returns the current cursor' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_cursor) do |ptr, out_ptr|
-          # this memory will be manually freed. not setting autorelease to
-          # false would cause a double free.
-          str = FFI::MemoryPointer.from_string('5678')
-          str.autorelease = false
+  describe 'catalog_for' do
+    subject(:j)        { Systemd::Journal }
+    let(:message_id)   { 'f77379a8490b408bbe5f6940505a777b' }
+    let(:message_text) { 'Subject: The Journal has been started' }
 
-          out_ptr.write_pointer(str)
-          0
-        end
+    it 'throws a JournalError on invalid return code' do
+      expect(Systemd::Journal::Native)
+        .to receive(:sd_journal_get_catalog_for_message_id)
+        .and_return(-1)
 
-      j.cursor.should eq('5678')
+      expect { j.catalog_for(message_id) }.to raise_error(Systemd::JournalError)
     end
 
-    it 'raises a JournalError on failure' do
-      j = Systemd::Journal.new
-      Systemd::Journal::Native
-        .should_receive(:sd_journal_get_cursor)
-        .and_return(-3)
-
-      expect { j.cursor }.to raise_error(Systemd::JournalError)
+    it 'returns the correct catalog entry' do
+      cat = Systemd::Journal.catalog_for(message_id)
+      expect(cat).to start_with(message_text)
     end
-
   end
 
 end