indy 0.3.4 → 0.4.0.pre

data/spec/indy_struct_spec.rb

@@ -0,0 +1,43 @@
+require "#{File.dirname(__FILE__)}/helper"
+
+describe 'Indy' do
+
+  context 'Struct::Entry' do
+
+    before(:each) do
+      log = [ "2000-09-07 14:06:41 INFO MyApp - Entering APPLICATION.",
+              "2000-09-07 14:07:42 DEBUG MyApp - Initializing APPLICATION.",
+              "2000-09-07 14:07:43 INFO MyApp - Exiting APPLICATION."].join("\n")
+      @entry_struct = Indy.search(log).all[1]
+    end
+
+    it "should be returned by #for search" do
+      @entry_struct.should be_kind_of Struct::Entry
+    end
+
+    it "should contain entire log entry as :raw_entry" do
+      @entry_struct.raw_entry.should == "2000-09-07 14:07:42 DEBUG MyApp - Initializing APPLICATION."
+    end
+
+    context 'using Indy::DEFAULT_LOG_FORMAT' do
+
+      it "should contain :time" do
+        @entry_struct.time.should == "2000-09-07 14:07:42"
+      end
+
+      it "should contain :severity" do
+        @entry_struct.severity.should == "DEBUG"
+      end
+
+      it "should contain :application" do
+        @entry_struct.application.should == "MyApp"
+      end
+
+      it "should contain :message" do
+        @entry_struct.message.should == "Initializing APPLICATION."
+      end
+
+    end
+
+  end
+end

data/spec/log_definition_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/indy/log_definition")
+
+describe 'Indy::LogDefinition' do
+
+  context '#new' do
+
+    context "with a valid hash" do
+
+      before(:each) do
+        @ld = Indy::LogDefinition.new(:entry_regexp => /foo/, :entry_fields => [:field_one], :time_format => '%M-%d-%Y')
+      end
+
+      it "should set entry_regexp" do
+        @ld.entry_regexp.should eq /foo/
+      end
+
+      it "should set entry_fields" do
+        @ld.entry_fields.should eq [:field_one]
+      end
+
+      it "should set time_format" do
+        @ld.time_format.should eq '%M-%d-%Y'
+      end
+
+    end
+
+    it "should raise ArgumentError when missing entry_fields" do
+      lambda{ Indy::LogDefinition.new(:entry_regexp => /foo/) }.should raise_error ArgumentError
+    end
+
+    it "should raise ArgumentError when missing entry_regexp" do
+      lambda{ Indy::LogDefinition.new(:entry_fields => [:field_one]) }.should raise_error ArgumentError
+    end
+
+  end
+
+  context 'private method' do
+
+    before(:each) do
+      @ld = Indy::LogDefinition.new(:entry_regexp => /^(\S+) (\S+) (.+)$/,
+                              :entry_fields => [:time, :severity, :message],
+                              :time_format => '%M-%d-%Y')
+      @field_captures = "2000-09-07 INFO The message!".match(@ld.entry_regexp).to_a
+    end
+
+    context "#parse_entry" do
+
+      it "should return a hash" do
+        @ld.send(:parse_entry, "2000-09-07 INFO The message!").class.should == Hash
+      end
+
+      it "should return correct key/value pairs" do
+        hash = @ld.send(:parse_entry, "2000-09-07 INFO The message!")
+        hash[:time].should == "2000-09-07"
+        hash[:message].should == "The message!"
+      end
+
+    end
+
+    context "#parse_entry_captures" do
+
+      it "should return a hash" do
+        @ld.send(:parse_entry_captures, @field_captures).class.should == Hash
+      end
+
+      it "should contain key/value pairs" do
+        hash = @ld.send(:parse_entry_captures, @field_captures)
+        hash[:time].should == "2000-09-07"
+        hash[:message].should == "The message!"
+      end
+
+    end
+
+  end
+end

data/spec/log_format_spec.rb

@@ -2,57 +2,69 @@ require "#{File.dirname(__FILE__)}/helper"
 
 describe Indy do
 
-  context "common logging format" do
-
-    common_log_format = {
-      :name => 'common_log_format',
-      :source => ["127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb1.gif HTTP/1.0\" 200 2326",
-                  "127.0.0.1 - louie [10/Oct/2000:13:55:37 -0700] \"GET /apache_pb2.gif HTTP/1.0\" 200 2327",
-                  "127.0.0.1 - frank [10/Oct/2000:13:55:38 -0700] \"GET /apache_pb3.gif HTTP/1.0\" 404 300"].join("\n"),
-      :regexp => Indy::LogFormats::COMMON_REGEXP,
-      :fields => Indy::LogFormats::COMMON_FIELDS,
-      :test_field => :authuser
-    }
-
-    combined_log_format = {
-      :name => 'combined_log_format',
-      :source => ["127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb1.gif HTTP/1.0\" 200 2326 \"http://www.example.com/start.html\" \"Mozilla/4.08 [en] (Win98; I ;Nav)\"",
-                  "127.0.0.1 - louie [10/Oct/2000:13:55:37 -0700] \"GET /apache_pb2.gif HTTP/1.0\" 200 2327 \"http://www.example.com/start.html\" \"Mozilla/4.08 [en] (Win98; I ;Nav)\"",
-                  "127.0.0.1 - frank [10/Oct/2000:13:55:38 -0700] \"GET /apache_pb3.gif HTTP/1.0\" 404 300 \"http://www.example.com/start.html\" \"Mozilla/4.08 [en] (Win98; I ;Nav)\""].join("\n"),
-      :regexp => Indy::LogFormats::COMBINED_REGEXP,
-      :fields => Indy::LogFormats::COMBINED_FIELDS,
-      :test_field => :authuser
-    }
-
-    log4r_default_format = {
-      :name => 'log4r_default_format',
-      :source => ["DEBUG mylog: This is a message with level DEBUG",
-                  " INFO mylog: This is a message with level INFO",
-                  " WARN louie: This is a message with level WARN",
-                  "ERROR mylog: This is a message with level ERROR",
-                  "FATAL mylog: This is a message with level FATAL"].join("\n"),
-      :regexp => Indy::LogFormats::LOG4R_DEFAULT_REGEXP,
-      :fields => Indy::LogFormats::LOG4R_DEFAULT_FIELDS,
-      :test_field => :application
-    }
-    
-    [ common_log_format,
-      combined_log_format,
-      log4r_default_format ].each do |format|
-      
-      it "#{format[:name]} should work" do
-        indy = Indy.new(:source => format[:source], :log_format => [format[:regexp],format[:fields]].flatten)
-        result = indy.for(format[:test_field] => 'louie')
-        result.length.should == 1
-      end
-
-      it "#{format[:name]} @pattern can be set to the Indy::LogFormat const" do
-        indy = Indy.new(:source => format[:source], :log_format => eval('Indy::' + format[:name].upcase))
-        result = indy.for(format[:test_field] => 'louie')
-        result.length.should == 1
-
-      end
+  context "log format can be set to" do
+
+    it 'Indy::COMMON_LOG_FORMAT' do
+      source = ["127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb1.gif HTTP/1.0\" 200 2326",
+        "127.0.0.1 - frank [10/Oct/2000:13:55:37 -0700] \"GET /apache_pb1.gif HTTP/1.0\" 200 2326",
+        "127.0.0.1 - louie [10/Oct/2000:13:55:37 -0700] \"GET /apache_pb2.gif HTTP/1.0\" 200 2327",
+        "127.0.0.1 - frank [10/Oct/2000:13:55:38 -0700] \"GET /apache_pb3.gif HTTP/1.0\" 404 300"].join("\n")
+      indy = Indy.new(:source => source).with(Indy::COMMON_LOG_FORMAT)
+      result = indy.for(:authuser => 'louie')
+      result.length.should == 1
+    end
+
+    it 'Indy::COMBINED_LOG_FORMAT' do
+      source = ["127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb1.gif HTTP/1.0\" 200 2326 \"http://www.example.com/start.html\" \"Mozilla/4.08 [en] (Win98; I ;Nav)\"",
+        "127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] \"GET /apache_pb1.gif HTTP/1.0\" 200 2326 \"http://www.example.com/start.html\" \"Mozilla/4.08 [en] (Win98; I ;Nav)\"",
+        "127.0.0.1 - louie [10/Oct/2000:13:55:37 -0700] \"GET /apache_pb2.gif HTTP/1.0\" 200 2327 \"http://www.example.com/start.html\" \"Mozilla/4.08 [en] (Win98; I ;Nav)\"",
+        "127.0.0.1 - frank [10/Oct/2000:13:55:38 -0700] \"GET /apache_pb3.gif HTTP/1.0\" 404 300 \"http://www.example.com/start.html\" \"Mozilla/4.08 [en] (Win98; I ;Nav)\""].join("\n")
+      indy = Indy.new(:source => source).with(Indy::COMBINED_LOG_FORMAT)
+      result = indy.for(:authuser => 'louie')
+      result.length.should == 1
     end
+
+    it 'Indy::LOG4R_DEFAULT_FORMAT' do
+      # http://log4r.rubyforge.org/rdoc/Log4r/rdoc/patternformatter.html
+      source = ["DEBUG mylog: This is a message with level DEBUG",
+        " INFO mylog: This is a message with level INFO",
+        " WARN louie: This is a message with level WARN",
+        "ERROR mylog: This is a message with level ERROR",
+        "FATAL mylog: This is a message with level FATAL"].join("\n")
+      indy = Indy.new(:source => source)
+      indy.with(Indy::LOG4R_DEFAULT_FORMAT)
+      result = indy.for(:application => 'louie')
+      result.length.should == 1
+    end
+
+    it 'Indy::LOG4J_DEFAULT_FORMAT' do
+      # http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html
+      source = ["This is a message with level DEBUG",
+        "This is a message with level INFO",
+        "This is a message with level WARN",
+        "This is a message with level ERROR",
+        "This is a message with level FATAL"].join("\n")
+      indy = Indy.new(:source => source).with(Indy::LOG4J_DEFAULT_FORMAT)
+      indy.all.length.should == 5
+    end
+
+  end
+
+  # http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/TTCCLayout.html
+  # example:
+  # 176 [main] INFO  org.apache.log4j.examples.Sort - Populating an array of 2 elements in reverse order.
+  it "should accept a log4j TTCC layout regex without error" do
+    log_data =
+"343 [main] INFO  org.apache.log4j.examples.Sort - The next log statement should be an error message.
+346 [main] ERROR org.apache.log4j.examples.SortAlgo.DUMP - Tried to dump an uninitialized array.
+        at org.apache.log4j.examples.SortAlgo.dump(SortAlgo.java:58)
+        at org.apache.log4j.examples.Sort.main(Sort.java:64)
+467 [main] INFO  org.apache.log4j.examples.Sort - Exiting main method."
+
+    Indy.new( :source => log_data,
+              :entry_regexp => /^(\d{3})\s+\[(\S+)\]\s+(\S+)\s+(\S+)\s*([^-]*)\s*-\s+(.+?)(?=\n\d{3}|\Z)/m,
+              :entry_fields => [:time, :thread, :level, :category, :diagnostic, :message]
+            ).class.should == Indy
   end
 
 end

data/spec/search_spec.rb

@@ -3,7 +3,7 @@ require 'tempfile'
 
 describe Indy do
 
-  context "search with string" do
+  context "#search with string param" do
 
     before(:each) do
       log_string = ["2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.",
@@ -12,8 +12,8 @@ describe Indy do
       @indy = Indy.search(log_string)
     end
 
-    it "should return 2 records" do
-      @indy.for(:application => 'MyApp').length.should == 2
+    it "should return all entries" do
+      @indy.all.length.should == 3
     end
 
     it "should search entire string on each successive search" do
@@ -24,9 +24,9 @@ describe Indy do
 
   end
 
-  context "search file" do
+  context "#search with :file param" do
 
-    before(:all) do
+    before(:each) do
       @file = Tempfile.new('file_search_spec')
       @file.write([ "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.",
                     "2000-09-07 14:08:41 INFO  MyOtherApp - Exiting APPLICATION.",
@@ -48,54 +48,44 @@ describe Indy do
     end
 
     it "should search reopened file on each successive search" do
+      @indy.for(:application => 'MyApp').length.should == 2
       @file.write("\n2000-09-07 14:10:55 INFO  MyApp - really really Exiting APPLICATION.\n")
       @file.flush
       @indy.for(:application => 'MyApp').length.should == 3
-      @indy.for(:severity => 'INFO').length.should == 4
-      @indy.for(:application => 'MyApp').length.should == 3
     end
 
   end
 
-  context "search using cmd" do
+  context "#search with :cmd param" do
 
-    before(:all) do
+    before(:each) do
       @file = Tempfile.new('file_search_spec')
-      @file_path = @file.path
+      file_name = File.basename(@file.path)
+      Dir.chdir(File.dirname(@file.path))
       @file.write([ "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.",
                     "2000-09-07 14:08:41 INFO  MyOtherApp - Exiting APPLICATION.",
                     "2000-09-07 14:10:55 INFO  MyApp - Exiting APPLICATION."
                   ].join("\n"))
       @file.flush
-
-      cmd = "ruby -e 'puts File.open(\"#{@file_path}\").read'"
-
+      cmd = is_windows? ?
+        "type #{file_name}" :
+        "cat #{file_name}"
       @indy = Indy.search(:cmd => cmd)
     end
 
     it "should return 2 records" do
-      @indy.for(:application => 'MyApp').length.should == 2
       results = @indy.for(:application => 'MyApp')
-      results.last.time.should == '2000-09-07 14:10:55'
-      results.last.severity.should == 'INFO'
-      results.last.application.should == 'MyApp'
-      results.last.message.should == 'Exiting APPLICATION.'
-      results.last._time.class.should_not be_nil
-
+      results.length.should == 2
     end
 
     it "should execute cmd on each successive search" do
       @indy.for(:application => 'MyApp').length.should == 2
       @indy.for(:severity => 'INFO').length.should == 3
-
       @file.write("\n2000-09-07 14:10:55 DEBUG MyApp - really really Exiting APPLICATION.\n")
       @file.flush
-
       @indy.for(:application => 'MyApp').length.should == 3
       @indy.for(:severity => 'INFO').length.should == 3
     end
 
-
   end
-
-end
+end

data/spec/source_spec.rb

@@ -4,42 +4,51 @@ class Indy
 
   describe Source do
 
-    it "should raise without parameter" do
-      lambda{ Source.new }.should raise_error( ArgumentError )
-    end
+    context "#new" do
 
-    it "should raise with nil parameter" do
-      lambda{ Source.new(nil) }.should raise_error( Indy::Source::Invalid )
-    end
+      it "should raise without parameter" do
+        lambda{ Source.new }.should raise_error( ArgumentError )
+      end
 
-    it "should raise with bad parameter" do
-      class NotString;end
-      lambda{ Source.new(NotString.new) }.should raise_error( Indy::Source::Invalid )
-    end
+      it "should raise with nil parameter" do
+        lambda{ Source.new(nil) }.should raise_error( Indy::Source::Invalid )
+      end
 
-    it "should return Indy::Source object" do
-      Source.new('logdata').class.should == Indy::Source
-    end
+      it "should raise with bad parameter" do
+        class NotString;end
+        lambda{ Source.new(NotString.new) }.should raise_error( Indy::Source::Invalid )
+      end
 
-    it "should respond to :open" do
-      Source.new('logdata').should respond_to(:open)
-    end
+      it "should raise if #execute_command returns empty string" do
+        IO.stub!(:popen).and_return('')
+        lambda{ Source.new(:cmd => 'a faux command').open }.should raise_error(Indy::Source::Invalid)
+      end
 
-    it "should respond to :num_lines" do
-      Source.new('logdata').should respond_to(:num_lines)
-    end
+      it "should return Indy::Source object" do
+        Source.new('logdata').class.should == Indy::Source
+      end
 
-    it "should respond to :lines" do
-      Source.new('logdata').should respond_to(:num_lines)
-    end
+      it "should respond to :open" do
+        Source.new('logdata').should respond_to(:open)
+      end
+
+      it "should respond to :num_entries" do
+        Source.new('logdata').should respond_to(:num_entries)
+      end
+
+      it "should respond to :entries" do
+        Source.new('logdata').should respond_to(:entries)
+      end
+
+      it "should handle Files" do
+        require 'tempfile'
+        Source.new(Tempfile.new('x')).class.should == Indy::Source
+      end
 
-    it "should handle Files" do
-      require 'tempfile'
-      Source.new(Tempfile.new('x')).class.should == Indy::Source
     end
 
     context "instance" do
-      
+
       before(:each) do
         log = [ "2000-09-07 14:07:41 INFO MyApp - Entering APPLICATION.",
                 "2000-09-07 14:07:42 DEBUG MyApp - Initializing APPLICATION.",
@@ -47,18 +56,18 @@ class Indy
               ].join("\n")
         @source = Source.new(log)
       end
-      
+
       it "should return StringIO from :open" do
-        @source.open.class.should == StringIO
+        @source.open.class.should == Array
       end
 
-      it "should return lines array from :lines" do
-        @source.lines.class.should == Array
-        @source.lines.length.should == 3
+      it "should return entries array from :entries" do
+        @source.entries.class.should == Array
+        @source.entries.length.should == 3
       end
 
-      it "should return 3 from :num_lines" do
-        @source.num_lines.should == 3
+      it "should return 3 from :num_entries" do
+        @source.num_entries.should == 3
       end
 
     end
@@ -81,5 +90,4 @@ class Indy
     end
 
   end
-
-end
+end

data/spec/time_scope_spec.rb

@@ -0,0 +1,162 @@
+require "#{File.dirname(__FILE__)}/helper"
+
+describe Indy do
+
+  context "search time scope" do
+
+    before(:each) do
+      @indy = Indy.search(
+        [ "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.",
+          "2000-09-07 14:07:42 INFO  MyApp - Initializing APPLICATION.",
+          "2000-09-07 14:07:43 INFO  MyApp - Configuring APPLICATION.",
+          "2000-09-07 14:07:44 INFO  MyApp - Running APPLICATION.",
+          "2000-09-07 14:07:45 INFO  MyApp - Exiting APPLICATION."
+        ].join("\n") )
+    end
+
+    context "after method" do
+
+      it "should find the correct entries" do
+        @indy.after(:time => '2000-09-07 14:07:42').all.length.should == 3
+      end
+
+      it "should find 0 entries with a time that is past the log" do
+        @indy.after(:time => '2000-09-07 14:07:46').all.length.should == 0
+      end
+
+      it "should find all entries with a time that is before the log" do
+        @indy.after(:time => '2000-09-07 14:07:40').all.length.should == 5
+      end
+
+      it "should find entries using inclusive" do
+        @indy.after(:time => '2000-09-07 14:07:42', :inclusive => true).all.length.should == 4
+      end
+
+    end
+
+    context "before method" do
+
+      it "should find the correct entries" do
+        @indy.before(:time => '2000-09-07 14:07:44').all.length.should == 3
+      end
+
+      it "should find 0 entries with a time that is before the log" do
+        @indy.before(:time => '2000-09-07 14:07:40').all.length.should == 0
+      end
+
+      it "should find all entries with a time that is after the log" do
+        @indy.before(:time => '2000-09-07 14:07:47').all.length.should == 5
+      end
+
+      it "should find entries using inclusive" do
+        @indy.before(:time => '2000-09-07 14:07:44', :inclusive => true).all.length.should == 4
+      end
+
+    end
+
+    context "within method" do
+
+      it "should find the correct entries" do
+        @indy.within(:start_time => '2000-09-07 14:07:41', :end_time => '2000-09-07 14:07:43').all.length.should == 1
+      end
+
+      it "should find the correct entries using inclusive" do
+        @indy.within(:start_time => '2000-09-07 14:07:41', :end_time => '2000-09-07 14:07:43', :inclusive => true).all.length.should == 3
+      end
+
+    end
+
+  end
+
+  context "search time scopes with span" do
+
+    before(:each) do
+      @indy = Indy.search(
+        [ "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.",
+          "2000-09-07 14:08:41 INFO  MyApp - Initializing APPLICATION.",
+          "2000-09-07 14:09:41 INFO  MyApp - Configuring APPLICATION.",
+          "2000-09-07 14:10:50 INFO  MyApp - Running APPLICATION.",
+          "2000-09-07 14:11:42 INFO  MyApp - Exiting APPLICATION.",
+          "2000-09-07 14:12:15 INFO  MyApp - Exiting APPLICATION."
+        ].join("\n") )
+    end
+
+    it "using after should find the correct entries" do
+      @indy.after(:time => '2000-09-07 14:07:42', :span => 1).all.length.should == 1
+    end
+
+    it "using before should find the correct entries" do
+      @indy.before(:time => '2000-09-07 14:12:00', :span => 4).all.length.should == 4
+    end
+
+    it "using around should find the correct entries" do
+      @indy.around(:time => '2000-09-07 14:11:00', :span => 2).all.length.should == 2
+    end
+
+    it "using after and inclusive should find the correct entries" do
+      @indy.after(:time => '2000-09-07 14:07:41', :span => 2, :inclusive => true).all.length.should == 3
+    end
+
+  end
+
+  context "multiple time scope methods on the same instance" do
+
+    before(:each) do
+      @indy = Indy.search(
+        [ "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.",
+          "2000-09-07 14:07:42 INFO  MyApp - Initializing APPLICATION.",
+          "2000-09-07 14:07:43 INFO  MyApp - Configuring APPLICATION.",
+          "2000-09-07 14:07:44 INFO  MyApp - Running APPLICATION.",
+          "2000-09-07 14:07:45 INFO  MyApp - Exiting APPLICATION."
+        ].join("\n") )
+    end
+
+    # Issue #3 (by design) assumed that the time scope.
+    it "should each add scope criteria to the instance" do
+      @indy.after(:time => '2000-09-07 14:07:42').all.length.should == 3
+      @indy.before(:time => '2000-09-07 14:07:45').all.length.should == 2
+    end
+
+    it "should specify the entire scope if #reset_scope was called" do
+      @indy.after(:time => '2000-09-07 14:07:42').all.length.should == 3
+      @indy.reset_scope
+      @indy.before(:time => '2000-09-07 14:07:45').all.length.should == 4
+    end
+
+  end
+
+  context "explicit time format" do
+
+    before(:each) do
+      pattern = "^([^\s]+) (.*)$"
+      @indy = Indy.new(:time_format => '%m-%d-%Y', 
+        :source => "1-13-2002 message\n1-14-2002 another message\n1-15-2002 another message",
+        :log_format => [pattern, :time, :message])
+    end
+
+    it "should search within time scope using a different format than explicitly set" do
+      pending 'Flexible time date time formatting is not implemented'
+      @indy.after(:time => 'Jan 13 2002').all.length.should == 2
+      @indy.after(:time => 'Jan 14 2002').all.last._time.mday.should == 15
+    end
+
+  end
+
+  it "should parse dates when log includes non-conforming data" do
+    logdata = [ "12-03-2000 message1",
+      "13-03-2000 message2",
+      "14-03-2000 ",
+      " message4",
+      "a14-03-2000 message5",
+      "14-03-2000 message6\n\n\n\n",
+      "15-03-2000 message7",
+      "16-03-2000 message8\r\n",
+      "17-03-2000 message9"].join("\n")
+    @indy = Indy.new(
+      :source => logdata,
+      :log_format => [/^(\d[^\s]+\d) (.+)$/, :time, :message])
+    @indy.after(:time => '13-03-2000')
+    @indy.all.length.should == 4
+  end
+
+end