indy 0.4.0.pre → 0.5.0

data/spec/indy_struct_spec.rb

@@ -12,29 +12,29 @@ describe 'Indy' do
     end
 
     it "should be returned by #for search" do
-      @entry_struct.should be_kind_of Struct::Entry
+      expect(@entry_struct).to 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."
+      expect(@entry_struct.raw_entry).to eq("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"
+        expect(@entry_struct.time).to eq("2000-09-07 14:07:42")
       end
 
       it "should contain :severity" do
-        @entry_struct.severity.should == "DEBUG"
+        expect(@entry_struct.severity).to eq("DEBUG")
       end
 
       it "should contain :application" do
-        @entry_struct.application.should == "MyApp"
+        expect(@entry_struct.application).to eq("MyApp")
       end
 
       it "should contain :message" do
-        @entry_struct.message.should == "Initializing APPLICATION."
+        expect(@entry_struct.message).to eq("Initializing APPLICATION.")
       end
 
     end

data/spec/log_definition_spec.rb

@@ -11,25 +11,25 @@ describe 'Indy::LogDefinition' do
       end
 
       it "should set entry_regexp" do
-        @ld.entry_regexp.should eq /foo/
+        expect(@ld.entry_regexp).to eq /foo/
       end
 
       it "should set entry_fields" do
-        @ld.entry_fields.should eq [:field_one]
+        expect(@ld.entry_fields).to eq [:field_one]
       end
 
       it "should set time_format" do
-        @ld.time_format.should eq '%M-%d-%Y'
+        expect(@ld.time_format).to 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
+      expect{ Indy::LogDefinition.new(:entry_regexp => /foo/) }.to 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
+      expect{ Indy::LogDefinition.new(:entry_fields => [:field_one]) }.to raise_error ArgumentError
     end
 
   end
@@ -46,13 +46,13 @@ describe 'Indy::LogDefinition' do
     context "#parse_entry" do
 
       it "should return a hash" do
-        @ld.send(:parse_entry, "2000-09-07 INFO The message!").class.should == Hash
+        expect(@ld.send(:parse_entry, "2000-09-07 INFO The message!").class).to eq(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!"
+        expect(hash[:time]).to eq("2000-09-07")
+        expect(hash[:message]).to eq("The message!")
       end
 
     end
@@ -60,13 +60,13 @@ describe 'Indy::LogDefinition' do
     context "#parse_entry_captures" do
 
       it "should return a hash" do
-        @ld.send(:parse_entry_captures, @field_captures).class.should == Hash
+        expect(@ld.send(:parse_entry_captures, @field_captures).class).to eq(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!"
+        expect(hash[:time]).to eq("2000-09-07")
+        expect(hash[:message]).to eq("The message!")
       end
 
     end

data/spec/log_format_spec.rb

@@ -2,26 +2,36 @@ require "#{File.dirname(__FILE__)}/helper"
 
 describe Indy do
 
-  context "log format can be set to" do
+  context "log format" do
 
-    it 'Indy::COMMON_LOG_FORMAT' do
+    it 'can be set to 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")
+                "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
+      expect(result.length).to eq(1)
+    end
+
+    it 'configuration can be set using: Indy.search(string).with(FORMAT_CLASS)' 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.search(source).with(Indy::COMMON_LOG_FORMAT)
+      result = indy.for(:authuser => 'louie')
+      expect(result.length).to eq(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")
+        "127.0.0.2 - 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.3 - 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
+      expect(result.length).to eq(1)
     end
 
     it 'Indy::LOG4R_DEFAULT_FORMAT' do
@@ -34,7 +44,7 @@ describe Indy do
       indy = Indy.new(:source => source)
       indy.with(Indy::LOG4R_DEFAULT_FORMAT)
       result = indy.for(:application => 'louie')
-      result.length.should == 1
+      expect(result.length).to eq(1)
     end
 
     it 'Indy::LOG4J_DEFAULT_FORMAT' do
@@ -45,7 +55,7 @@ describe Indy do
         "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
+      expect(indy.all.length).to eq(5)
     end
 
   end
@@ -61,10 +71,12 @@ describe Indy do
         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,
+    result = 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
+            )
+    expect(result.class).to eq(Indy)
+    expect(result.all.first.level).to eq('INFO')
   end
 
 end

data/spec/search_spec.rb

@@ -13,13 +13,13 @@ describe Indy do
     end
 
     it "should return all entries" do
-      @indy.all.length.should == 3
+      expect(@indy.all.length).to eq(3)
     end
 
     it "should search entire string on each successive search" do
-      @indy.for(:application => 'MyApp').length.should == 2
-      @indy.for(:severity => 'INFO').length.should == 3
-      @indy.for(:application => 'MyApp').length.should == 2
+      expect(@indy.for(:application => 'MyApp').length).to eq(2)
+      expect(@indy.for(:severity => 'INFO').length).to eq(3)
+      expect(@indy.for(:application => 'MyApp').length).to eq(2)
     end
 
   end
@@ -38,20 +38,20 @@ describe Indy do
     end
 
     it "should return 2 records" do
-      @indy.for(:application => 'MyApp').length.should == 2
+      expect(@indy.for(:application => 'MyApp').length).to eq(2)
     end
 
     it "should search entire file on each successive search" do
-      @indy.for(:application => 'MyApp').length.should == 2
-      @indy.for(:severity => 'INFO').length.should == 3
-      @indy.for(:application => 'MyApp').length.should == 2
+      expect(@indy.for(:application => 'MyApp').length).to eq(2)
+      expect(@indy.for(:severity => 'INFO').length).to eq(3)
+      expect(@indy.for(:application => 'MyApp').length).to eq(2)
     end
 
     it "should search reopened file on each successive search" do
-      @indy.for(:application => 'MyApp').length.should == 2
+      expect(@indy.for(:application => 'MyApp').length).to eq(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
+      expect(@indy.for(:application => 'MyApp').length).to eq(3)
     end
 
   end
@@ -75,16 +75,16 @@ describe Indy do
 
     it "should return 2 records" do
       results = @indy.for(:application => 'MyApp')
-      results.length.should == 2
+      expect(results.length).to eq(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
+      expect(@indy.for(:application => 'MyApp').length).to eq(2)
+      expect(@indy.for(:severity => 'INFO').length).to eq(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
+      expect(@indy.for(:application => 'MyApp').length).to eq(3)
+      expect(@indy.for(:severity => 'INFO').length).to eq(3)
     end
 
   end

data/spec/source_spec.rb

@@ -7,42 +7,42 @@ class Indy
     context "#new" do
 
       it "should raise without parameter" do
-        lambda{ Source.new }.should raise_error( ArgumentError )
+        expect{ Source.new }.to raise_error( ArgumentError )
       end
 
       it "should raise with nil parameter" do
-        lambda{ Source.new(nil) }.should raise_error( Indy::Source::Invalid )
+        expect{ Source.new(nil) }.to raise_error( Indy::Source::Invalid )
       end
 
       it "should raise with bad parameter" do
         class NotString;end
-        lambda{ Source.new(NotString.new) }.should raise_error( Indy::Source::Invalid )
+        expect{ Source.new(NotString.new) }.to raise_error( Indy::Source::Invalid )
       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)
+        allow(IO).to receive(:popen).and_return('')
+        expect{ Source.new(:cmd => 'a faux command').open }.to raise_error(Indy::Source::Invalid)
       end
 
       it "should return Indy::Source object" do
-        Source.new('logdata').class.should == Indy::Source
+        expect(Source.new('logdata').class).to eq(Indy::Source)
       end
 
       it "should respond to :open" do
-        Source.new('logdata').should respond_to(:open)
+        expect(Source.new('logdata')).to respond_to(:open)
       end
 
       it "should respond to :num_entries" do
-        Source.new('logdata').should respond_to(:num_entries)
+        expect(Source.new('logdata')).to respond_to(:num_entries)
       end
 
       it "should respond to :entries" do
-        Source.new('logdata').should respond_to(:entries)
+        expect(Source.new('logdata')).to respond_to(:entries)
       end
 
       it "should handle Files" do
         require 'tempfile'
-        Source.new(Tempfile.new('x')).class.should == Indy::Source
+        expect(Source.new(Tempfile.new('x')).class).to eq(Indy::Source)
       end
 
     end
@@ -58,16 +58,16 @@ class Indy
       end
 
       it "should return StringIO from :open" do
-        @source.open.class.should == Array
+        expect(@source.open.class).to eq(Array)
       end
 
       it "should return entries array from :entries" do
-        @source.entries.class.should == Array
-        @source.entries.length.should == 3
+        expect(@source.entries.class).to eq(Array)
+        expect(@source.entries.length).to eq(3)
       end
 
       it "should return 3 from :num_entries" do
-        @source.num_entries.should == 3
+        expect(@source.num_entries).to eq(3)
       end
 
     end
@@ -75,18 +75,18 @@ class Indy
     it "should handle a :file hash key with File object value" do
       require 'tempfile'
       file = Tempfile.new('x')
-      Source.new(:file => file).class.should == Indy::Source
+      expect(Source.new(:file => file).class).to eq(Indy::Source)
     end
 
     it "should handle a bare File object" do
       require 'tempfile'
       file = Tempfile.new('y')
-      Source.new(file).class.should == Indy::Source
+      expect(Source.new(file).class).to eq(Indy::Source)
     end
 
     it "should handle a real file" do
       log_file = "#{File.dirname(__FILE__)}/data.log"
-      Indy.search(:file => File.open(log_file, 'r')).for(:application => 'MyApp').length.should == 2
+      expect(Indy.search(:file => File.open(log_file, 'r')).for(:application => 'MyApp').length).to eq(2)
     end
 
   end

data/spec/time_scope_spec.rb

@@ -17,19 +17,19 @@ describe Indy do
     context "after method" do
 
       it "should find the correct entries" do
-        @indy.after(:time => '2000-09-07 14:07:42').all.length.should == 3
+        expect(@indy.after(:time => '2000-09-07 14:07:42').all.length).to eq(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
+        expect(@indy.after(:time => '2000-09-07 14:07:46').all.length).to eq(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
+        expect(@indy.after(:time => '2000-09-07 14:07:40').all.length).to eq(5)
       end
 
       it "should find entries using inclusive" do
-        @indy.after(:time => '2000-09-07 14:07:42', :inclusive => true).all.length.should == 4
+        expect(@indy.after(:time => '2000-09-07 14:07:42', :inclusive => true).all.length).to eq(4)
       end
 
     end
@@ -37,19 +37,19 @@ describe Indy do
     context "before method" do
 
       it "should find the correct entries" do
-        @indy.before(:time => '2000-09-07 14:07:44').all.length.should == 3
+        expect(@indy.before(:time => '2000-09-07 14:07:44').all.length).to eq(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
+        expect(@indy.before(:time => '2000-09-07 14:07:40').all.length).to eq(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
+        expect(@indy.before(:time => '2000-09-07 14:07:47').all.length).to eq(5)
       end
 
       it "should find entries using inclusive" do
-        @indy.before(:time => '2000-09-07 14:07:44', :inclusive => true).all.length.should == 4
+        expect(@indy.before(:time => '2000-09-07 14:07:44', :inclusive => true).all.length).to eq(4)
       end
 
     end
@@ -57,11 +57,11 @@ describe Indy do
     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
+        expect(@indy.within(:start_time => '2000-09-07 14:07:41', :end_time => '2000-09-07 14:07:43').all.length).to eq(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
+        expect(@indy.within(:start_time => '2000-09-07 14:07:41', :end_time => '2000-09-07 14:07:43', :inclusive => true).all.length).to eq(3)
       end
 
     end
@@ -82,19 +82,19 @@ describe Indy do
     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
+      expect(@indy.after(:time => '2000-09-07 14:07:42', :span => 1).all.length).to eq(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
+      expect(@indy.before(:time => '2000-09-07 14:12:00', :span => 4).all.length).to eq(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
+      expect(@indy.around(:time => '2000-09-07 14:11:00', :span => 2).all.length).to eq(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
+      expect(@indy.after(:time => '2000-09-07 14:07:41', :span => 2, :inclusive => true).all.length).to eq(3)
     end
 
   end
@@ -113,14 +113,14 @@ describe Indy do
 
     # 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
+      expect(@indy.after(:time => '2000-09-07 14:07:42').all.length).to eq(3)
+      expect(@indy.before(:time => '2000-09-07 14:07:45').all.length).to eq(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
+      expect(@indy.after(:time => '2000-09-07 14:07:42').all.length).to eq(3)
       @indy.reset_scope
-      @indy.before(:time => '2000-09-07 14:07:45').all.length.should == 4
+      expect(@indy.before(:time => '2000-09-07 14:07:45').all.length).to eq(4)
     end
 
   end
@@ -128,35 +128,40 @@ describe Indy do
   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])
+      @indy = Indy.new(
+          :time_format => '[%m %d %Y]',
+          :source => "[1 13 2002] message\n[1 14 2002] another message\n[1 15 2002] another message",
+          :entry_regexp => "^(\\[.+\\]) (.*)$",
+          :entry_fields => [: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
+    it "using before finds correct number of entries" do
+      expect(@indy.before(:time => '[1 14 2002]').all.length).to eq(1)
+    end
+
+    it "using default (not explicit) time format finds correct number of entries" do
+      expect(@indy.after(:time => '2002-01-13').all.length).to eq(2)
     end
 
   end
 
-  it "should parse dates when log includes non-conforming data" do
+  it "should raise ParseException 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")
+      "16-03-2000 message6\n\n\n\n",
+      "a17-03-2000 message5",
+      "18-03-2000 message7",
+      "19-03-2000 message8\r\n",
+      "20-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
+    @indy.after(:time => '16-03-2000')
+    expect{
+      @indy.all
+    }.to raise_exception( Indy::Time::ParseException )
   end
 
 end