request-log-analyzer 1.2.1 → 1.2.6

data/spec/unit/aggregator/database_spec.rb

@@ -0,0 +1,234 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Aggregator::Database do
+
+  before(:all) do
+    log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)
+    @database_inserter = RequestLogAnalyzer::Aggregator::Database.new(log_parser, :database => ':memory:')
+    
+    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, { :regexp   => /Testing (\w+), tries\: (\d+)/,
+                          :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer },
+                            { :name => :evaluated, :type => :hash, :provides => {:evaluated_field => :duration} }]})                               
+  end
+  
+  # The prepare method is called before the parsing starts. It should establish a connection
+  # to a database that is suitable for inserting requests later on.
+  describe '#prepare' do
+
+    before(:each) do
+      @database_inserter.stub!(:initialize_orm_module!)
+      @database_inserter.stub!(:establish_database_connection!)
+      @database_inserter.stub!(:create_database_schema!)
+    end
+
+    it 'should create the ORM mdoule in which the classes can be created' do
+      @database_inserter.should_receive(:initialize_orm_module!)
+      @database_inserter.prepare
+    end
+
+    it 'should establish the database connection' do
+      @database_inserter.should_receive(:establish_database_connection!)
+      @database_inserter.prepare
+    end
+    
+    it 'should create the database schema during preparation' do
+      @database_inserter.should_receive(:create_database_schema!)
+      @database_inserter.prepare
+    end
+  end
+  
+  # The database inserter creates is own "Database" module within the file format 
+  # class to create all the classes that are needed.
+  describe '#initialize_orm_module!' do
+    
+    before(:all) { @database_inserter.send(:deinitialize_orm_module!) }
+    after(:all)  { @database_inserter.send(:initialize_orm_module!) }
+    
+    before(:each) { @database_inserter.send(:initialize_orm_module!) }
+    after(:each)  { @database_inserter.send(:deinitialize_orm_module!) }
+    
+    it "should create a Database module under the file format's class" do
+      testing_format.class.should be_const_defined('Database')
+    end
+    
+    it "should define a Base class in the Database module" do
+      testing_format.class::Database.should be_const_defined('Base')
+    end
+    
+    it "should create a ActiveRecord::Base class in the Database module" do
+      testing_format.class::Database::Base.ancestors.should include(ActiveRecord::Base)
+    end
+    
+  end
+  
+  # The create_database_table method should create a database table according to the line definition,
+  # so that parsed lines can be stored in it later on.
+  describe '#create_database_table' do
+    
+    before(:each) do
+      @connection = mock_migrator
+      @database_inserter.stub!(:connection).and_return(@connection)
+    end
+    
+    it "should create a table based on the line type name" do
+      @connection.should_receive(:create_table).with('test_lines')
+      @database_inserter.send(:create_database_table, @line_definition)
+    end    
+    
+    it "should create an index on the request_id field" do
+      @connection.should_receive(:add_index).with('test_lines', [:request_id])
+      @database_inserter.send(:create_database_table, @line_definition)
+    end
+    
+    it "should create a request_id field to link the requests together" do
+      @connection.table_creator.should_receive(:column).with(:request_id, :integer)
+      @database_inserter.send(:create_database_table, @line_definition)
+    end
+    
+    it "should create a lineno field to save the location of the line in the original file" do
+      @connection.table_creator.should_receive(:column).with(:lineno, :integer)
+      @database_inserter.send(:create_database_table, @line_definition)
+    end
+    
+    it "should create a field of the correct type for every defined field" do
+      @connection.table_creator.should_receive(:column).with(:what, :string)
+      @connection.table_creator.should_receive(:column).with(:tries, :integer)
+      # :hash capture type should map on a :text field type
+      @connection.table_creator.should_receive(:column).with(:evaluated, :text) 
+      @database_inserter.send(:create_database_table, @line_definition)      
+    end
+    
+    it "should create a field of the correct type for every provided field" do
+      # :duration capture type should map on a :double field type
+      @connection.table_creator.should_receive(:column).with(:evaluated_field, :double) 
+      @database_inserter.send(:create_database_table, @line_definition)   
+    end
+  end
+  
+  describe '#create_activerecord_class' do
+    before(:each) do
+      # Make sure the ORM module exists
+      @database_inserter.send(:initialize_orm_module!)     
+      
+      # Mockthe request ORM class
+      @request_class = mock('Request ActiveRecord::Base class')
+      @request_class.stub!(:has_many)
+      @database_inserter.stub!(:request_class).and_return(@request_class)
+    end
+    
+    it "should register the constant for the line type AR class" do
+      @database_inserter.send(:create_activerecord_class, @line_definition)
+      @database_inserter.orm_module.const_defined?('TestLine').should be_true
+    end
+    
+    it "should create a class that inherits from ActiveRecord::Base and the base class of the ORM module" do
+      @database_inserter.send(:create_activerecord_class, @line_definition)
+      @database_inserter.orm_module.const_get('TestLine').ancestors.should include(ActiveRecord::Base, @database_inserter.orm_module::Base)
+    end    
+    
+    describe 'defining the new ORM class' do
+      before(:each) do
+        # Mock the newly created ORM class for the test_line
+        @orm_class = mock('Line ActiveRecord::Base class')
+        @orm_class.stub!(:belongs_to)
+        @orm_class.stub!(:serialize)
+        Class.stub!(:new).and_return(@orm_class)
+      end
+
+      it "should create a has_many relation on the Request class" do
+        @request_class.should_receive(:has_many).with(:test_lines)
+        @database_inserter.send(:create_activerecord_class, @line_definition)
+      end
+    
+      it "should create a belongs_to relation to the request class" do
+        @orm_class.should_receive(:belongs_to).with(:request)
+        @database_inserter.send(:create_activerecord_class, @line_definition)            
+      end
+    
+      it "should serialize the :evaluate field into the database" do
+        @orm_class.should_receive(:serialize).with(:evaluated, Hash)
+        @database_inserter.send(:create_activerecord_class, @line_definition)            
+      end    
+    end
+  end
+  
+  describe '#create_database_schema!' do
+  
+    before(:each) do
+      @line_type_cnt = testing_format.line_definitions.length
+
+      @connection = mock_migrator
+      @database_inserter.stub!(:connection).and_return(@connection)      
+      
+      # Stub the expected method calls for the preparation
+      @database_inserter.stub!(:create_database_table)
+      @database_inserter.stub!(:create_activerecord_class) 
+
+      # Make sure the ORM module exists
+      @database_inserter.send(:initialize_orm_module!)
+    end
+
+    it "should create a requests table to join request lines" do
+      @connection.should_receive(:create_table).with("requests")
+      @database_inserter.send :create_database_schema!
+    end
+        
+    it "should create a Request class inheriting from ActiveRecord and the base class of the ORM module" do
+      @database_inserter.send :create_database_schema!
+      @database_inserter.request_class.ancestors.should include(ActiveRecord::Base, @database_inserter.orm_module::Base)
+    end
+    
+    it "should create a warnings table for logging parse warnings" do
+      @connection.should_receive(:create_table).with("warnings")
+      @database_inserter.send :create_database_schema!
+    end
+
+    it "should create a Warnng class inheriting from ActiveRecord and the base class of the ORM module" do
+      @database_inserter.send :create_database_schema!
+      @database_inserter.warning_class.ancestors.should include(ActiveRecord::Base, @database_inserter.orm_module::Base)
+    end
+  
+    it "should create a table for every line type" do
+      @database_inserter.should_receive(:create_database_table).with(an_instance_of(RequestLogAnalyzer::LineDefinition)).exactly(@line_type_cnt).times
+      @database_inserter.send :create_database_schema!
+    end
+    
+    it "should create a ORM for every line type" do
+      @database_inserter.should_receive(:create_activerecord_class).with(an_instance_of(RequestLogAnalyzer::LineDefinition)).exactly(@line_type_cnt).times
+      @database_inserter.send :create_database_schema!
+    end
+  end
+  
+  describe '#aggregate' do
+    before(:each) do
+      @database_inserter.prepare
+
+      @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   
+    
+    it "should insert a record in the request table" do
+      TestingFormat::Database::Request.count.should == 0
+      @database_inserter.aggregate(@incomplete_request)
+      TestingFormat::Database::Request.count.should == 1
+    end
+
+    it "should insert records in all relevant line tables" do
+      @database_inserter.aggregate(@completed_request)
+      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
+      TestingFormat::Database::Warning.should_receive(:create!).with(hash_including(:warning_type => 'test_warning'))
+      @database_inserter.warning(:test_warning, "Testing the warning system", 12)
+    end    
+  end
+end

data/spec/unit/aggregator/summarizer_spec.rb

@@ -1,8 +1,6 @@
 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)

data/spec/unit/controller/controller_spec.rb

@@ -2,8 +2,6 @@ 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')

data/spec/unit/controller/log_processor_spec.rb

@@ -4,8 +4,6 @@ require 'request_log_analyzer/log_processor'
 
 describe RequestLogAnalyzer::LogProcessor, 'stripping log files' do
 
-  include RequestLogAnalyzer::Spec::Helper
-  
   before(:each) do
     @log_stripper = RequestLogAnalyzer::LogProcessor.new(testing_format, :strip, {})
   end

data/spec/unit/file_format/file_format_api_spec.rb

@@ -1,90 +1,69 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe RequestLogAnalyzer::FileFormat, :format_definition do
+describe RequestLogAnalyzer::FileFormat do
+
+  describe ".format_definition" do
   
-  before(:each) do
-    @first_file_format = Class.new(RequestLogAnalyzer::FileFormat::Base)
-    @second_file_format = Class.new(RequestLogAnalyzer::FileFormat::Base)
-  end
-    
-  it "should specify lines with a hash" do
-    
-    @first_file_format.new.should have(0).line_definitions
-        
-    @first_file_format.format_definition do |line|
-      line.hash_test :regexp => /test/, :captures => []
+    before(:each) do
+      @first_file_format  = Class.new(RequestLogAnalyzer::FileFormat::Base)
+      @second_file_format = Class.new(RequestLogAnalyzer::FileFormat::Base)
     end
     
-    @format_instance = @first_file_format.new
-    @format_instance.should have(1).line_definitions
-    @format_instance.line_definitions[:hash_test].should_not be_nil
-  end
-  
-  it "should specift lines directly" do
-    @first_file_format.new.should have(0).line_definitions    
-    
-    @first_file_format.format_definition.direct_test do |line|
-      line.regexp   = /test/
-    end 
-    
-    @first_file_format.new.line_definitions[:direct_test].should_not be_nil
-  end
+    it "should specify line definitions directly within the file_format" do
+      @first_file_format.format_definition.direct_test :regexp => /test/
+      @first_file_format.should have_line_definition(:direct_test)
+    end
  
-  it "specify lines with a block" do
-    
-    @first_file_format.new.should have(0).line_definitions    
+    it "specify lines with a block for the format definition" do
+      @first_file_format.format_definition do |format|
+        format.block_test :regexp => /test (\w+)/, :captures => [:tester]
+      end 
+          
+      @first_file_format.should have_line_definition(:block_test).capturing(:tester)
+    end
     
-    @first_file_format.format_definition do |format|
-      format.block_test do |line|
+    it "should specify a line with a block" do
+      @first_file_format.format_definition.hash_test do |line|
         line.regexp   = /test/
         line.captures = []
       end
-    end 
-    
-    @first_file_format.new.line_definitions[:block_test].should_not be_nil
-  end
-  
-  it "should define lines only for itself" do
     
-    @first_file_format.format_definition do |line|
-      line.first_test :regexp => /test/, :captures => []
+      @first_file_format.should have_line_definition(:hash_test)
     end
-    
-
-    @second_file_format.format_definition do |line|
-      line.second_test :regexp => /test/, :captures => []
-    end
-
-    @first_file_format.line_definer.should_not eql(@second_file_format.line_definer)
-    @first_file_format.new.should have(1).line_definitions    
-    @second_file_format.new.line_definitions[:second_test].should_not be_nil
-  end  
-end
-
-describe RequestLogAnalyzer::FileFormat, :load do
-
-  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)
+  
+    it "should define lines only for its own language" do
+      @first_file_format.format_definition.first   :regexp => /test 123/
+      @second_file_format.format_definition.second :regexp => /test 456/
+ 
+      @first_file_format.should      have_line_definition(:first)
+      @first_file_format.should_not  have_line_definition(:second)
+      @second_file_format.should_not have_line_definition(:first)      
+      @second_file_format.should     have_line_definition(:second)
+    end  
   end
 
+  describe ".load" do
 
-  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 return an instance of a FileFormat class" do
+      @file_format = RequestLogAnalyzer::FileFormat.load(TestingFormat)
+      @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)
-    @file_format.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails)
-  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)
+      @file_format.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails)
+    end
   
-  it "should load a provided format file" do
-    format_filename = File.dirname(__FILE__) + '/../../lib/testing_format.rb'
-    @file_format = RequestLogAnalyzer::FileFormat.load(format_filename)
-    @file_format.should be_kind_of(TestingFormat)
-  end
+    it "should load a provided format file" do
+      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
 end

data/spec/unit/file_format/line_definition_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe RequestLogAnalyzer::LineDefinition, :parsing do
-  
+describe RequestLogAnalyzer::LineDefinition do
+
   before(:each) do
     @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
       :teaser   => /Testing /,
@@ -10,55 +10,59 @@ describe RequestLogAnalyzer::LineDefinition, :parsing do
     })
   end
   
-  it "should return false on an unmatching line" do
-    (@line_definition =~ "nonmatching").should be_false
-  end
-  
-  it "should return false when only the teaser matches" do
-    (@line_definition =~ "Testing LineDefinition").should be_false  
-  end
+  describe '#matches' do
   
-  it "should return a hash if the line matches" do
-    (@line_definition =~ "Testing LineDefinition, tries: 123").should be_kind_of(Hash)
-  end
+    it "should return false on an unmatching line" do
+      @line_definition.should_not parse("nonmatching")
+    end
   
-  it "should return a hash with :captures set to an array" do
-    hash = @line_definition.matches("Testing LineDefinition, tries: 123")
-    hash[:captures][0].should == "LineDefinition"
-    hash[:captures][1].should == "123"
-  end
+    it "should return false when only the teaser matches" do
+      @line_definition.should_not parse("Testing LineDefinition")    
+    end
   
-  it "should return a hash with :line_definition set" do
-    @line_definition.matches("Testing LineDefinition, tries: 123")[:line_definition].should == @line_definition
+    it "should parse a line and capture the expected values" do
+      @line_definition.should parse("Testing LineDefinition, tries: 123").capturing('LineDefinition', '123')
+    end
   end
-end
 
-describe RequestLogAnalyzer::LineDefinition, :converting do
+  describe '#convert_captured_values' do
 
-  include RequestLogAnalyzer::Spec::Helper
-  
-  before(:each) do
-    @file_format = testing_format
-    @request = @file_format.request
-  end
-  
-  it "should convert captures to a hash of converted values" do
-    hash = @file_format.line_definitions[:first].convert_captured_values(["456"], @request)
-    hash[:request_no].should == 456
-  end
+    before(:each) do
+      @request = mock('request')
+      @request.stub!(:convert_value).and_return('foo')
+    end
+    
+    it "should call convert_value for every captured value" do
+      @request.should_receive(:convert_value).twice
+      @line_definition.convert_captured_values(['test', '123'], @request)
+    end
+    
+    it "should set the converted values" do
+      @line_definition.convert_captured_values(['test', '123'], @request).should == {:what => 'foo', :tries => 'foo'}
+    end
+    
+    context 'when using :provides option' do
+      before(:each) do
+        @ld = RequestLogAnalyzer::LineDefinition.new(:test, :regexp   => /Hash\: (\{.+\})/, 
+            :captures => [{ :name => :hash, :type => :hash, :provides => {:bar => :string}}])
+            
+        @request = mock('request')
 
-  it "should convert captures to a hash" do
-    hash = @file_format.line_definitions[:test].convert_captured_values(["great", nil], @request)
-    hash[:test_capture].should == 'Testing is great'
-    hash[:duration].should be_nil
+        @request.stub!(:convert_value).with("{:bar=>'baz'}", anything).and_return(:bar => 'baz')
+        @request.stub!(:convert_value).with('baz', anything).and_return('foo')
+      end   
+      
+      it "should call Request#convert_value for the initial hash and the value in the hash" do
+        @request.should_receive(:convert_value).with("{:bar=>'baz'}", anything).and_return(:bar => 'baz')
+        @request.should_receive(:convert_value).with("baz", anything)
+        @ld.convert_captured_values(["{:bar=>'baz'}"], @request)
+      end
+      
+      it "should set the provides fields" do
+        # The captures field must be set and converted as well
+        @ld.convert_captured_values(["{:bar=>'baz'}"], @request)[:bar].should eql('foo')
+      end      
+    end
+    
   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/unit/file_format/merb_format_spec.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, :merb do
-  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
     @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:merb))
@@ -24,15 +23,34 @@ describe RequestLogAnalyzer::Source::LogParser, :merb do
     @log_parser.parse_file(log_fixture(:merb))
   end
   
-  it "should parse all details from a request correctly" do
+  it "should parse all details from the first request correctly" do
     request = nil
     @log_parser.parse_file(log_fixture(:merb)) { |found_request| request ||= found_request }
     
     request.should be_completed
+    request[:controller].should == 'session'
+    request[:action].should == 'destroy'    
+    request[:method].should == 'delete'
+    request[:params].should be_kind_of(Hash)      
     request[:timestamp].should == 20080829111023 # 'Fri Aug 29 11:10:23 +0200 2008'
     request[:dispatch_time].should == 0.243424
     request[:after_filters_time].should == 6.9e-05
     request[:before_filters_time].should == 0.213213
     request[:action_time].should == 0.241652
+
+  end
+  
+  it "should parse a prefixed Merb file correctly" do
+    request = nil
+    @log_parser.parse_file(log_fixture(:merb_prefixed)) { |found_request| request ||= found_request }
+    
+    request.should be_completed
+    request[:timestamp].should == 20090831183525
+    request[:controller].should == 'home'
+    request[:action].should == 'index'
+    request[:dispatch_time].should == 0.012001
+    request[:after_filters_time].should == 0.0
+    request[:before_filters_time].should == 0.0
+    request[:action_time].should == 0.012001
   end
 end

data/spec/unit/file_format/rails_format_spec.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, "Rails" do
-  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
     @log_parser = RequestLogAnalyzer::Source::LogParser.new(
@@ -79,7 +78,6 @@ describe RequestLogAnalyzer::Source::LogParser, "Rails" do
 end
 
 describe RequestLogAnalyzer::FileFormat::RailsDevelopment, "Rails with development details" do
-  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
     @file_format = RequestLogAnalyzer::FileFormat.load(:rails_development)

data/spec/unit/filter/anonymize_filter_spec.rb

@@ -1,7 +1,6 @@
 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)

data/spec/unit/filter/field_filter_spec.rb

@@ -1,7 +1,6 @@
 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)
@@ -25,7 +24,6 @@ describe RequestLogAnalyzer::Filter::Field, 'string in accept mode' do
 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)
@@ -49,7 +47,6 @@ describe RequestLogAnalyzer::Filter::Field, 'string in reject mode' do
 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)

data/spec/unit/filter/filter_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Base, 'base filter' do
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Base.new(testing_format)
+  end
+  
+  it "should return everything" do
+    @filter.filter(request(:ip => '123.123.123.123'))[:ip].should eql('123.123.123.123')
+  end
+
+  it "should return nil on nil request" do
+    @filter.filter(nil).should be_nil
+  end
+
+end

data/spec/unit/filter/timespan_filter_spec.rb

@@ -1,7 +1,6 @@
 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'))
@@ -21,7 +20,6 @@ describe RequestLogAnalyzer::Filter::Timespan, 'both before and after'  do
 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'))    
@@ -41,7 +39,6 @@ describe RequestLogAnalyzer::Filter::Timespan, 'only before'  do
 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'))