request-log-analyzer 1.1.2 → 1.1.3

data/spec/{database_inserter_spec.rb → unit/aggregator/database_inserter_spec.rb}

@@ -1,45 +1,41 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'request_log_analyzer/aggregator/database'
-
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Aggregator::Database, "schema creation" do
 
-  TEST_DATABASE_FILE = File.dirname(__FILE__) + "/fixtures/requests.db"
-  include RequestLogAnalyzerSpecHelper
-  
+  include RequestLogAnalyzer::Spec::Helper
+
   before(:each) do
-    log_parser = RequestLogAnalyzer::Source::LogParser.new(spec_format)
-    @database_inserter = RequestLogAnalyzer::Aggregator::Database.new(log_parser, :database => TEST_DATABASE_FILE)
-  end
-  
-  after(:each) do
-    File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
+    log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)
+    @database_inserter = RequestLogAnalyzer::Aggregator::Database.new(log_parser, :database => ':memory:')
   end
+
   
   it "should create the correct tables" do
     ActiveRecord::Migration.should_receive(:create_table).with("warnings")    
     ActiveRecord::Migration.should_receive(:create_table).with("requests")        
     ActiveRecord::Migration.should_receive(:create_table).with("first_lines")
     ActiveRecord::Migration.should_receive(:create_table).with("test_lines")        
-    ActiveRecord::Migration.should_receive(:create_table).with("last_lines")    
+    ActiveRecord::Migration.should_receive(:create_table).with("eval_lines")    
+    ActiveRecord::Migration.should_receive(:create_table).with("last_lines")
 
+    ActiveRecord::Migration.should_receive(:add_index).with("eval_lines",  [:request_id])
     ActiveRecord::Migration.should_receive(:add_index).with("first_lines", [:request_id])    
-    ActiveRecord::Migration.should_receive(:add_index).with("test_lines", [:request_id])
-    ActiveRecord::Migration.should_receive(:add_index).with("last_lines", [:request_id])
+    ActiveRecord::Migration.should_receive(:add_index).with("test_lines",  [:request_id])
+    ActiveRecord::Migration.should_receive(:add_index).with("last_lines",  [:request_id])
 
     @database_inserter.prepare
   end
   
   it "should create a default Request class" do
     @database_inserter.prepare
-    SpecFormat::Database::Request.ancestors.should include(ActiveRecord::Base)
-    SpecFormat::Database::Request.column_names.should include('first_lineno')
-    SpecFormat::Database::Request.column_names.should include('last_lineno')    
+    TestingFormat::Database::Request.ancestors.should include(ActiveRecord::Base)
+    TestingFormat::Database::Request.column_names.should include('first_lineno')
+    TestingFormat::Database::Request.column_names.should include('last_lineno')    
   end
   
   it "should create associations for the default Request class" do
     @database_inserter.prepare
-    @request = SpecFormat::Database::Request.new
+    @request = TestingFormat::Database::Request.new
     @request.should respond_to(:test_lines)
     @request.test_lines.should
   end
@@ -47,7 +43,7 @@ describe RequestLogAnalyzer::Aggregator::Database, "schema creation" do
   it "should create the default table names" do
     @database_inserter.prepare
     @database_inserter.file_format.line_definitions.each do |name, definition|
-      klass = SpecFormat::Database.const_get("#{name}_line".camelize)
+      klass = TestingFormat::Database.const_get("#{name}_line".camelize)
       klass.column_names.should include('id')
       klass.column_names.should include('lineno')      
       klass.column_names.should include('request_id')      
@@ -57,46 +53,53 @@ describe RequestLogAnalyzer::Aggregator::Database, "schema creation" do
   it "should create the correct fields in the table" do
     @database_inserter.prepare
     
-    SpecFormat::Database::FirstLine.column_names.should include('request_no')
-    SpecFormat::Database::LastLine.column_names.should include('request_no')
-    SpecFormat::Database::TestLine.column_names.should include('test_capture')    
+    TestingFormat::Database::FirstLine.column_names.should include('request_no')
+    TestingFormat::Database::LastLine.column_names.should include('request_no')
+    TestingFormat::Database::TestLine.column_names.should include('test_capture')    
+  end
+  
+  it "should create fields for provides" do
+    @database_inserter.prepare
+    TestingFormat::Database::EvalLine.column_names.should include('evaluated')    
+    TestingFormat::Database::EvalLine.column_names.should include('greating')
+    TestingFormat::Database::EvalLine.column_names.should include('what')    
   end
   
 end
 
 describe RequestLogAnalyzer::Aggregator::Database, "record insertion" do
-  include RequestLogAnalyzerSpecHelper  
+  include RequestLogAnalyzer::Spec::Helper  
   
   before(:each) do
-    log_parser = RequestLogAnalyzer::Source::LogParser.new(spec_format)    
-    @database_inserter = RequestLogAnalyzer::Aggregator::Database.new(log_parser, :database => TEST_DATABASE_FILE)
+    log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)    
+    @database_inserter = RequestLogAnalyzer::Aggregator::Database.new(log_parser, :database => ':memory:')
     @database_inserter.prepare
         
-    @incomplete_request = spec_format.create_request( {:line_type => :first, :request_no => 564})
-    @completed_request = spec_format.create_request( {:line_type => :first, :request_no  => 564}, {:line_type => :test, :test_capture => "awesome"},
-                          {:line_type => :test, :test_capture => "indeed"}, {:line_type => :last, :request_no   => 564})    
+    @incomplete_request = testing_format.request( {:line_type => :first, :request_no => 564})
+    @completed_request = testing_format.request( {:line_type => :first, :request_no  => 564}, 
+                          {:line_type => :test, :test_capture => "awesome"},
+                          {:line_type => :test, :test_capture => "indeed"}, 
+                          {:line_type => :eval, :evaluated => "{ 'greating' => 'howdy'}", :greating => 'howdy' }, 
+                          {:line_type => :last, :request_no   => 564})    
   end
   
-  after(:each) do
-    File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
-  end 
-  
   it "should insert a record in the request table" do
-    SpecFormat::Database::Request.count.should == 0
+    TestingFormat::Database::Request.count.should == 0
     @database_inserter.aggregate(@incomplete_request)
-    SpecFormat::Database::Request.count.should == 1
+    TestingFormat::Database::Request.count.should == 1
   end
   
   it "should insert records in all relevant line tables" do
     @database_inserter.aggregate(@completed_request)
-    request = SpecFormat::Database::Request.first
+    request = TestingFormat::Database::Request.first
     request.should have(2).test_lines
     request.should have(1).first_lines  
+    request.should have(1).eval_lines     
     request.should have(1).last_lines    
   end
   
   it "should log a warning in the warnings table" do
-    SpecFormat::Database::Warning.should_receive(:create!).with(hash_including(:warning_type => 'test_warning'))
+    TestingFormat::Database::Warning.should_receive(:create!).with(hash_including(:warning_type => 'test_warning'))
     @database_inserter.warning(:test_warning, "Testing the warning system", 12)
   end
   

data/spec/unit/aggregator/summarizer_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Aggregator::Summarizer do
+  
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @summarizer = RequestLogAnalyzer::Aggregator::Summarizer.new(mock_source, :output => mock_output)
+    @summarizer.prepare
+  end
+  
+  it "not raise exception when creating a report after aggregating multiple requests" do
+    @summarizer.aggregate(request(:data => 'bluh1'))
+    @summarizer.aggregate(request(:data => 'bluh2'))    
+    
+    lambda { @summarizer.report(mock_output) }.should_not raise_error
+  end
+
+  it "not raise exception when creating a report after aggregating a single request" do
+    @summarizer.aggregate(request(:data => 'bluh1'))
+    lambda { @summarizer.report(mock_output) }.should_not raise_error
+  end
+
+  it "not raise exception when creating a report after aggregating no requests" do
+    lambda { @summarizer.report(mock_output) }.should_not raise_error
+  end
+
+end

data/spec/unit/controller/controller_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Controller do
+
+  include RequestLogAnalyzer::Spec::Helper
+
+  it "should use a custom output generator correctly" do
+    
+    mock_output = mock('RequestLogAnalyzer::Output::Base')
+    mock_output.stub!(:io).and_return(mock_io)
+    mock_output.should_receive(:header)
+    mock_output.should_receive(:footer)
+
+    controller  = RequestLogAnalyzer::Controller.new(mock_source, :output => mock_output)
+
+    controller.run!
+  end
+
+  it "should call aggregators correctly when run" do
+    controller  = RequestLogAnalyzer::Controller.new(mock_source, :output => mock_output)
+    
+    mock_aggregator = mock('RequestLogAnalyzer::Aggregator::Base')
+    mock_aggregator.should_receive(:prepare).once.ordered
+    mock_aggregator.should_receive(:aggregate).with(an_instance_of(testing_format.request_class)).twice.ordered
+    mock_aggregator.should_receive(:finalize).once.ordered
+    mock_aggregator.should_receive(:report).once.ordered
+  
+    controller.aggregators << mock_aggregator
+    controller.run!
+  end
+  
+  it "should call filters when run" do
+    controller  = RequestLogAnalyzer::Controller.new(mock_source, :output => mock_output)
+    
+    mock_filter = mock('RequestLogAnalyzer::Filter::Base')
+    mock_filter.should_receive(:filter).twice.and_return(nil)
+    controller.should_receive(:aggregate_request).twice.and_return(nil)
+    
+    controller.filters << mock_filter
+    controller.run!
+  end
+  
+end

data/spec/{log_processor_spec.rb → unit/controller/log_processor_spec.rb}

@@ -1,12 +1,13 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
+
 require 'request_log_analyzer/log_processor'
 
 describe RequestLogAnalyzer::LogProcessor, 'stripping log files' do
 
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @log_stripper = RequestLogAnalyzer::LogProcessor.new(spec_format, :strip, {})
+    @log_stripper = RequestLogAnalyzer::LogProcessor.new(testing_format, :strip, {})
   end
   
   it "should remove a junk line" do

data/spec/{file_format_spec.rb → unit/file_format/file_format_api_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::FileFormat, :format_definition do
   
@@ -63,7 +63,18 @@ end
 
 describe RequestLogAnalyzer::FileFormat, :load do
 
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
+
+  it "should return an instance of a FileFormat class" do
+    @file_format = RequestLogAnalyzer::FileFormat.load(TestingFormat)
+    @file_format.should be_kind_of(TestingFormat)
+  end
+
+
+  it "should return itself if it already is a FileFormat::Base instance" do
+    @file_format = RequestLogAnalyzer::FileFormat.load(testing_format)
+    @file_format.should be_kind_of(TestingFormat)
+  end
 
   it "should load a predefined file format from the /file_format dir" do
     @file_format = RequestLogAnalyzer::FileFormat.load(:rails)
@@ -71,8 +82,9 @@ describe RequestLogAnalyzer::FileFormat, :load do
   end
   
   it "should load a provided format file" do
-    @file_format = RequestLogAnalyzer::FileFormat.load(format_file(:spec_format))
-    @file_format.should be_kind_of(SpecFormat)
+    format_filename = File.dirname(__FILE__) + '/../../lib/testing_format.rb'
+    @file_format = RequestLogAnalyzer::FileFormat.load(format_filename)
+    @file_format.should be_kind_of(TestingFormat)
   end
   
 end

data/spec/{line_definition_spec.rb → unit/file_format/line_definition_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::LineDefinition, :parsing do
   
@@ -35,11 +35,11 @@ end
 
 describe RequestLogAnalyzer::LineDefinition, :converting do
 
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @file_format = spec_format
-    @request = @file_format.create_request
+    @file_format = testing_format
+    @request = @file_format.request
   end
   
   it "should convert captures to a hash of converted values" do
@@ -48,10 +48,17 @@ describe RequestLogAnalyzer::LineDefinition, :converting do
   end
 
   it "should convert captures to a hash" do
-    hash = @file_format.line_definitions[:test].convert_captured_values(["willem", nil], @request)
-    hash[:test_capture].should == 'Testing is willem'
+    hash = @file_format.line_definitions[:test].convert_captured_values(["great", nil], @request)
+    hash[:test_capture].should == 'Testing is great'
     hash[:duration].should be_nil
   end
+  
+  it "should merge a hash capture into the line hash" do
+    hash = @file_format.line_definitions[:eval].convert_captured_values(["{ 'greating' => 'hello', 'what' => 'world'}"], @request)
+    hash[:evaluated].should == "{ 'greating' => 'hello', 'what' => 'world'}"
+    hash[:greating].should == 'hello'
+    hash[:what].should == 'world'    
+  end  
 
   
 end

data/spec/{merb_format_spec.rb → unit/file_format/merb_format_spec.rb}

@@ -1,7 +1,7 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, :merb do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
     @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:merb))

data/spec/{rails_format_spec.rb → unit/file_format/rails_format_spec.rb}

@@ -1,10 +1,11 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, "Rails" do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:rails))
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(
+          RequestLogAnalyzer::FileFormat.load(:rails), :parse_strategy => 'cautious')
   end
   
   it "should have a valid language definitions" do
@@ -66,27 +67,34 @@ describe RequestLogAnalyzer::Source::LogParser, "Rails" do
   end
   
   it "should detect unordered requests in the logs" do
+    # No valid request should be found in cautious mode
     @log_parser.should_not_receive(:handle_request)
     # the first Processing-line will not give a warning, but the next one will
     @log_parser.should_receive(:warn).with(:unclosed_request, anything).once
-    # Both Completed ;ines will give a warning
+    # Both Completed lines will give a warning
     @log_parser.should_receive(:warn).with(:no_current_request, anything).twice
+    
     @log_parser.parse_file(log_fixture(:rails_unordered))
   end  
 end
 
-describe "RequestLogAnalyzer::FileFormat::RailsDevelopment - Rails with development details" do
-  include RequestLogAnalyzerSpecHelper
+describe RequestLogAnalyzer::FileFormat::RailsDevelopment, "Rails with development details" do
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
     @file_format = RequestLogAnalyzer::FileFormat.load(:rails_development)
-    @request = @file_format.create_request
+    @request = @file_format.request
   end
   
   it "should have a valid language definitions" do
     @file_format.should be_valid
   end
   
+  it "should have a different line definer than Rails" do
+    rails = RequestLogAnalyzer::FileFormat.load(:rails)
+    rails.class.line_definer.should_not == @file_format.class.line_definer
+  end
+  
   it "should parse a rendered line" do
     info = @file_format.line_definitions[:rendered].match_for("Rendered layouts/_footer (2.9ms)", @request)
     info[:render_file].should == 'layouts/_footer'
@@ -97,25 +105,25 @@ describe "RequestLogAnalyzer::FileFormat::RailsDevelopment - Rails with developm
     info = @file_format.line_definitions[:query_executed].match_for(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ", @request)
     info[:query_class].should == 'User'
     info[:query_duration].should == 0.0004
-    info[:query_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 18205844)'
+    info[:query_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'
   end  
   
   it "should parse a query executed line without colors" do
     info = @file_format.line_definitions[:query_executed].match_for(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ", @request)
     info[:query_class].should == 'User'
     info[:query_duration].should == 0.0004
-    info[:query_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 18205844)'    
+    info[:query_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'
   end  
   
   it "should parse a cached query line with colors" do
     info = @file_format.line_definitions[:query_cached].match_for(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ', @request)
     info[:cached_duration].should == 0.0
-    info[:cached_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 0)'   
+    info[:cached_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'   
   end
   
   it "should parse a cached query line without colors" do
     info = @file_format.line_definitions[:query_cached].match_for(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ', @request)
     info[:cached_duration].should == 0.0
-    info[:cached_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 0)'   
+    info[:cached_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'  
   end  
 end

data/spec/unit/filter/anonymize_filter_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Anonymize, 'anonymize request' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Anonymize.new(testing_format)
+  end
+  
+  it "should anonimize ip" do
+    @filter.filter(request(:ip => '123.123.123.123'))[:ip].should_not eql('123.123.123.123')
+  end
+
+  it "should anonimize url" do
+    @filter.filter(request(:url => 'https://test.mysite.com/employees'))[:url].should eql('http://example.com/employees')
+  end
+
+  it "should fuzz durations" do
+    @filter.filter(request(:duration => 100))[:duration].should_not eql(100)
+  end
+  
+end

data/spec/unit/filter/field_filter_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Field, 'string in accept mode' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :select)
+  end
+  
+  it "should reject a request if the field value does not match" do
+    @filter.filter(request(:test => 'not test')).should be_nil
+  end
+  
+  it "should reject a request if the field name does not match" do
+    @filter.filter(request(:testing => 'test')).should be_nil
+  end
+
+  it "should accept a request if the both name and value match" do
+    @filter.filter(request(:test => 'test')).should_not be_nil
+  end 
+    
+  it "should accept a request if the value is not the first value" do
+    @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should_not be_nil
+  end  
+end
+
+describe RequestLogAnalyzer::Filter::Field, 'string in reject mode' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :reject)
+  end
+  
+  it "should accept a request if the field value does not match" do
+    @filter.filter(request(:test => 'not test')).should_not be_nil
+  end
+  
+  it "should accept a request if the field name does not match" do
+    @filter.filter(request(:testing => 'test')).should_not be_nil
+  end
+
+  it "should reject a request if the both name and value match" do
+    @filter.filter(request(:test => 'test')).should be_nil
+  end 
+    
+  it "should reject a request if the value is not the first value" do
+    @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should be_nil
+  end  
+end
+
+describe RequestLogAnalyzer::Filter::Field, 'regexp in accept mode' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => '/test/', :mode => :select)
+  end
+  
+  it "should reject a request if the field value does not match" do
+    @filter.filter(request(:test => 'a working test')).should_not be_nil
+  end
+  
+  it "should reject a request if the field name does not match" do
+    @filter.filter(request(:testing => 'test')).should be_nil
+  end
+
+  it "should accept a request if the value is not the first value" do
+    @filter.filter(request([{:test => 'ignore'}, {:test => 'testing 123'}])).should_not be_nil
+  end  
+end

data/spec/unit/filter/timespan_filter_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Timespan, 'both before and after'  do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'), :before => DateTime.parse('2009-02-02'))
+  end
+  
+  it "should reject a request before the after date" do
+    @filter.filter(request(:timestamp => 20081212000000)).should be_nil
+  end
+  
+  it "should reject a request after the before date" do
+    @filter.filter(request(:timestamp => 20090303000000)).should be_nil
+  end
+  
+  it "should accept a request between the after and before dates" do
+    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  end
+end
+
+describe RequestLogAnalyzer::Filter::Timespan, 'only before'  do
+  include RequestLogAnalyzer::Spec::Helper
+  
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :before => DateTime.parse('2009-02-02'))    
+  end
+  
+  it "should accept a request before the after date" do
+    @filter.filter(request(:timestamp => 20081212000000)).should_not be_nil
+  end
+  
+  it "should reject a request after the before date" do
+    @filter.filter(request(:timestamp => 20090303000000)).should be_nil
+  end
+  
+  it "should accept a request between the after and before dates" do
+    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  end   
+end
+
+describe RequestLogAnalyzer::Filter::Timespan, 'only after'  do  
+  include RequestLogAnalyzer::Spec::Helper 
+  
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'))
+  end
+  
+  it "should reject a request before the after date" do
+    @filter.filter(request(:timestamp => 20081212000000)).should be_nil
+  end
+  
+  it "should accept a request after the before date" do
+    @filter.filter(request(:timestamp => 20090303000000)).should_not be_nil
+  end
+  
+  it "should accept a request between the after and before dates" do
+    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  end  
+end

data/spec/{log_parser_spec.rb → unit/source/log_parser_spec.rb}

@@ -1,10 +1,10 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, :requests do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(spec_format)
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)
   end
   
   it "should have multiple line definitions" do
@@ -16,13 +16,13 @@ describe RequestLogAnalyzer::Source::LogParser, :requests do
   end
   
   it "should parse more lines than requests" do
-    @log_parser.should_receive(:handle_request).with(an_instance_of(SpecFormat::Request)).twice
+    @log_parser.should_receive(:handle_request).with(an_instance_of(TestingFormat::Request)).twice
     @log_parser.parse_file(log_fixture(:test_language_combined))
     @log_parser.parsed_lines.should > 2    
   end
   
   it "should parse requests spanned over multiple files" do
-    @log_parser.should_receive(:handle_request).with(an_instance_of(SpecFormat::Request)).once
+    @log_parser.should_receive(:handle_request).with(an_instance_of(TestingFormat::Request)).once
     @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)])
   end
   
@@ -47,10 +47,10 @@ describe RequestLogAnalyzer::Source::LogParser, :requests do
 end
 
 describe RequestLogAnalyzer::Source::LogParser, :warnings do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(spec_format)
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format, :parse_strategy => 'cautious')
   end
     
   it "should warn about teaser matching problems" do

data/spec/{request_spec.rb → unit/source/request_spec.rb}

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Request, :incomplete_request do
   
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @incomplete_request = spec_format.create_request
+    @incomplete_request = testing_format.request
     @incomplete_request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
   end
   
@@ -34,10 +34,10 @@ end
 
 describe RequestLogAnalyzer::Request, :completed_request do
   
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @completed_request = spec_format.create_request
+    @completed_request = testing_format.request
     @completed_request << { :line_type => :first, :lineno =>  1, :name => 'first line!' }    
     @completed_request << { :line_type => :test,  :lineno =>  4, :test_capture => 'testing' }        
     @completed_request << { :line_type => :test,  :lineno =>  7, :test_capture => 'testing some more' }