request-log-analyzer 1.1.2 → 1.2.0

data/lib/request_log_analyzer/tracker/frequency.rb

@@ -21,36 +21,48 @@ module RequestLogAnalyzer::Tracker
   #  DELETE |    512 hits (1.1%)  |
   class Frequency < Base
 
-    attr_reader :categories
+    attr_reader :frequencies
 
     def prepare
       raise "No categorizer set up for category tracker #{self.inspect}" unless options[:category]
-      @categories = {}
+      @frequencies = {}
       if options[:all_categories].kind_of?(Enumerable)
-        options[:all_categories].each { |cat| @categories[cat] = 0 }
+        options[:all_categories].each { |cat| @frequencies[cat] = 0 }
       end
     end
             
     def update(request)
       cat = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
       if !cat.nil? || options[:nils]
-        @categories[cat] ||= 0
-        @categories[cat] += 1
+        @frequencies[cat] ||= 0
+        @frequencies[cat] += 1
       end
     end
 
+    def frequency(cat)
+      frequencies[cat] || 0
+    end
+    
+    def overall_frequency
+      frequencies.inject(0) { |carry, item| carry + item[1] }
+    end
+    
+    def sorted_by_frequency
+      @frequencies.sort { |a, b| b[1] <=> a[1] }
+    end
+
     def report(output)
       output.title(options[:title]) if options[:title]
     
-      if @categories.empty?
+      if @frequencies.empty?
         output << "None found.\n" 
       else
-        sorted_categories = @categories.sort { |a, b| b[1] <=> a[1] }
-        total_hits        = sorted_categories.inject(0) { |carry, item| carry + item[1] }
-        sorted_categories = sorted_categories.slice(0...options[:amount]) if options[:amount]
+        sorted_frequencies = @frequencies.sort { |a, b| b[1] <=> a[1] }
+        total_hits         = sorted_frequencies.inject(0) { |carry, item| carry + item[1] }
+        sorted_frequencies = sorted_frequencies.slice(0...options[:amount]) if options[:amount]
 
         output.table({:align => :left}, {:align => :right }, {:align => :right}, {:type => :ratio, :width => :rest}) do |rows|        
-          sorted_categories.each do |(cat, count)|
+          sorted_frequencies.each do |(cat, count)|
             rows << [cat, "#{count} hits", '%0.1f%%' % ((count.to_f / total_hits.to_f) * 100.0), (count.to_f / total_hits.to_f)]
           end
         end

data/lib/request_log_analyzer/tracker/hourly_spread.rb

@@ -44,25 +44,36 @@ module RequestLogAnalyzer::Tracker
       @last  = timestamp if @last.nil?  || timestamp > @last
     end
 
+    def total_requests
+      @request_time_graph.inject(0) { |sum, value| sum + value }
+    end
+    
+    def first_timestamp
+      DateTime.parse(@first.to_s, '%Y%m%d%H%M%S') rescue nil
+    end
+    
+    def last_timestamp
+      DateTime.parse(@last.to_s, '%Y%m%d%H%M%S') rescue nil
+    end
+    
+    def timespan
+      last_timestamp - first_timestamp
+    end
+
     def report(output)
       output.title("Requests graph - average per day per hour")
     
-      if @request_time_graph == [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+      if total_requests == 0
         output << "None found.\n"
         return
       end
 
-      first_date     = DateTime.parse(@first.to_s, '%Y%m%d%H%M%S')
-      last_date      = DateTime.parse(@last.to_s, '%Y%m%d%H%M%S')
-      days           = (@last && @first) ? (last_date - first_date).ceil : 1
-      total_requests = @request_time_graph.inject(0) { |sum, value| sum + value }
-    
+      days = [1, timespan].max
       output.table({}, {:align => :right}, {:type => :ratio, :width => :rest, :treshold => 0.15}) do |rows|
         @request_time_graph.each_with_index do |requests, index|
           ratio = requests.to_f / total_requests.to_f
-          requests_per_day = requests / days
-    
-          rows << ["#{index.to_s.rjust(3)}:00", "#{requests_per_day} hits", ratio]
+          requests_per_day = (requests / days).ceil
+          rows << ["#{index.to_s.rjust(3)}:00", "%d hits" % requests_per_day, ratio]
         end
       end
     end

data/lib/request_log_analyzer/tracker/timespan.rb

@@ -31,20 +31,27 @@ module RequestLogAnalyzer::Tracker
       @last  = timestamp if @last.nil?  || timestamp > @last
     end
 
+    def first_timestamp
+      DateTime.parse(@first.to_s, '%Y%m%d%H%M%S') rescue nil
+    end
+    
+    def last_timestamp
+      DateTime.parse(@last.to_s, '%Y%m%d%H%M%S') rescue nil      
+    end
+    
+    def timespan
+      last_timestamp - first_timestamp
+    end
+
     def report(output)
       output.title(options[:title]) if options[:title]
     
-      first_date  = DateTime.parse(@first.to_s, '%Y%m%d%H%M%S') rescue nil
-      last_date   = DateTime.parse(@last.to_s, '%Y%m%d%H%M%S') rescue nil
-    
       if @last && @first
-        days        = (@last && @first) ? (last_date - first_date).ceil : 1
-           
         output.with_style(:cell_separator => false) do         
           output.table({:width => 20}, {}) do |rows|
-            rows << ['First request:', first_date.strftime('%Y-%m-%d %H:%M:%I')]
-            rows << ['Last request:', last_date.strftime('%Y-%m-%d %H:%M:%I')]
-            rows << ['Total time analyzed:', "#{days} days"]                    
+            rows << ['First request:', first_timestamp.strftime('%Y-%m-%d %H:%M:%I')]
+            rows << ['Last request:', last_timestamp.strftime('%Y-%m-%d %H:%M:%I')]
+            rows << ['Total time analyzed:', "#{timespan.ceil} days"]                    
           end
         end
       end

data/lib/request_log_analyzer.rb

@@ -1,11 +1,30 @@
 require 'date'
-require File.dirname(__FILE__) + '/cli/progressbar'
 
+# Satisfy ruby 1.9 sensitivity about encoding.
+if defined? Encoding and Encoding.respond_to? 'default_external='
+  Encoding.default_external = 'binary'
+end
+
+# RequestLogAnalyzer is the base namespace in which all functionality of RequestLogAnalyzer is implemented.
+#
+# - This module itselfs contains some functions to help with class and source file loading.
+# - The actual application resides in the RequestLogAnalyzer::Controller class.
 module RequestLogAnalyzer
-   
-  VERSION = '1.1'
+  
+  # The current version of request-log-analyzer.
+  # This will be diplayed in output reports etc.  
+  VERSION = '1.1.7'
+  
+  # Loads constants in the RequestLogAnalyzer namespace using self.load_default_class_file(base, const)
+  # <tt>const</tt>:: The constant that is not yet loaded in the RequestLogAnalyzer namespace. This should be passed as a string or symbol.
+  def self.const_missing(const)
+    load_default_class_file(RequestLogAnalyzer, const)
+  end
     
-  # Function to implement 
+  # Loads constants that reside in the RequestLogAnalyzer tree using the constant name
+  # and its base constant to determine the filename.
+  # <tt>base</tt>:: The base constant to load the constant from. This should be Foo when the constant Foo::Bar is being loaded.
+  # <tt>const</tt>:: The constant to load from the base constant as a string or symbol. This should be 'Bar' or :Bar when the constant Foo::Bar is being loaded.
   def self.load_default_class_file(base, const)
     path     = to_underscore(base.to_s)
     basename = to_underscore(const.to_s)
@@ -15,22 +34,16 @@ module RequestLogAnalyzer
   end
 
   # Convert a string/symbol in camelcase (RequestLogAnalyzer::Controller) to underscores (request_log_analyzer/controller)
+  # This function can be used to load the file (using require) in which the given constant is defined.
+  # <tt>str</tt>:: The string to convert in the following format: <tt>ModuleName::ClassName</tt>
   def self.to_underscore(str)
     str.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
   end  
 
-  # Convert a string/symbol in underscores (request_log_analyzer/controller) to camelcase (RequestLogAnalyzer::Controller)    
+  # Convert a string/symbol in underscores (<tt>request_log_analyzer/controller</tt>) to camelcase 
+  # (<tt>RequestLogAnalyzer::Controller</tt>). This can be used to find the class that is defined in a given filename.
+  # <tt>str</tt>:: The string to convert in the following format: <tt>module_name/class_name</tt>
   def self.to_camelcase(str)
-    str.to_s.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    str.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
   end
 end
-
-require File.dirname(__FILE__) + '/request_log_analyzer/file_format'
-require File.dirname(__FILE__) + '/request_log_analyzer/line_definition'
-require File.dirname(__FILE__) + '/request_log_analyzer/request'
-require File.dirname(__FILE__) + '/request_log_analyzer/aggregator'
-require File.dirname(__FILE__) + '/request_log_analyzer/filter'
-require File.dirname(__FILE__) + '/request_log_analyzer/controller'
-require File.dirname(__FILE__) + '/request_log_analyzer/source'
-require File.dirname(__FILE__) + '/request_log_analyzer/output'
-

data/spec/integration/command_line_usage_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe RequestLogAnalyzer, 'running from command line' do
+  
+  include RequestLogAnalyzer::Spec::Helper
+  
+  TEMPORARY_DIRECTORY = "#{File.dirname(__FILE__)}/../fixtures"
+  TEMP_DATABASE_FILE  = TEMPORARY_DIRECTORY + "/output.db"
+  TEMP_REPORT_FILE    = TEMPORARY_DIRECTORY + "/report"
+
+  before(:each) do
+    File.unlink(TEMP_DATABASE_FILE) if File.exist?(TEMP_DATABASE_FILE)
+    File.unlink(TEMP_REPORT_FILE) if File.exist?(TEMP_REPORT_FILE)    
+  end
+
+  after(:each) do
+    File.unlink(TEMP_DATABASE_FILE) if File.exist?(TEMP_DATABASE_FILE)
+    File.unlink(TEMP_REPORT_FILE) if File.exist?(TEMP_REPORT_FILE)    
+  end
+
+  it "should find 4 requests in default mode" do  
+    output = run("#{log_fixture(:rails_1x)}")
+    output.detect { |line| /Parsed requests\:\s*4/ =~ line }.should_not be_nil
+  end
+
+  it "should find 3 requests with a --select option" do  
+    output = run("#{log_fixture(:rails_1x)} --select controller PeopleController")
+    output.detect { |line| /Parsed requests\:\s*4/ =~ line }.should_not be_nil
+  end
+
+  it "should find 1 requests with a --reject option" do  
+    output = run("#{log_fixture(:rails_1x)} --reject controller PeopleController")
+    output.detect { |line| /Parsed requests\:\s*4/ =~ line }.should_not be_nil
+  end
+  
+  it "should write output to a file with the --file option" do  
+    run("#{log_fixture(:rails_1x)} --file #{TEMP_REPORT_FILE}")
+    File.exist?(TEMP_REPORT_FILE).should be_true
+  end
+
+  it "should write only ASCII characters to a file with the --file option" do  
+    run("#{log_fixture(:rails_1x)} --file #{TEMP_REPORT_FILE}")
+    /^[\x00-\x7F]*$/.match(File.read(TEMP_REPORT_FILE)).should_not be_nil
+  end
+
+  it "should write HTML if --output HTML is provided" do
+    output = run("#{log_fixture(:rails_1x)} --output HTML")
+    output.any? { |line| /<html.*>/ =~ line}
+  end
+  
+  it "should run with the --database option" do  
+    run("#{log_fixture(:rails_1x)} --database #{TEMP_DATABASE_FILE}")
+    File.exist?(TEMP_DATABASE_FILE).should be_true
+  end
+
+  it "should use no colors in the report with the --boring option" do  
+    output = run("#{log_fixture(:rails_1x)} --boring")
+    output.any? { |line| /\e/ =~ line }.should be_false
+  end
+  
+  it "should use only ASCII characters in the report with the --boring option" do  
+    output = run("#{log_fixture(:rails_1x)} --boring")
+    output.all? { |line| /^[\x00-\x7F]*$/ =~ line }.should be_true
+  end
+  
+  it "should parse a Merb file if --format merb is set" do  
+    output = run("#{log_fixture(:merb)} --format merb")
+    output.detect { |line| /Parsed requests\:\s*11/ =~ line }.should_not be_nil   
+  end  
+  
+end

data/spec/lib/helper.rb

@@ -0,0 +1,33 @@
+module RequestLogAnalyzer::Spec::Helper
+  
+  include RequestLogAnalyzer::Spec::Mocks
+
+
+  def testing_format
+    @testing_format ||= TestingFormat.new
+  end
+  
+  def log_fixture(name)
+    File.dirname(__FILE__) + "/../fixtures/#{name}.log"
+  end
+
+  def request(fields, format = testing_format)
+    if fields.kind_of?(Array)
+      format.request(*fields)
+    else
+      format.request(fields)      
+    end
+  end
+
+  def run(arguments)
+    binary = "#{File.dirname(__FILE__)}/../../bin/request-log-analyzer"
+    arguments = arguments.join(' ') if arguments.kind_of?(Array)
+    
+    output = []
+    IO.popen("#{binary} #{arguments}") do |pipe|
+      output = pipe.readlines
+    end
+    $?.exitstatus.should == 0
+    output
+  end
+end

data/spec/lib/mocks.rb

@@ -0,0 +1,47 @@
+module RequestLogAnalyzer::Spec::Mocks
+  
+  def mock_source
+    source = mock('RequestLogAnalyzer::Source::Base')
+    source.stub!(:file_format).and_return(testing_format)
+    source.stub!(:parsed_requests).and_return(2)
+    source.stub!(:skipped_requests).and_return(1)    
+    source.stub!(:parse_lines).and_return(10)
+    
+    source.stub!(:warning=)
+    source.stub!(:progress=)
+
+    source.stub!(:prepare)
+    source.stub!(:finalize)
+        
+    source.stub!(:each_request).and_return do |block|
+      block.call(testing_format.request(:field => 'value1'))
+      block.call(testing_format.request(:field => 'value2'))
+    end
+    
+    return source
+  end
+
+  def mock_io
+    mio = mock('IO')
+    mio.stub!(:print)
+    mio.stub!(:puts)    
+    mio.stub!(:write)
+    return mio
+  end
+  
+  def mock_output
+    output = mock('RequestLogAnalyzer::Output::Base')
+    output.stub!(:header)
+    output.stub!(:footer)   
+    output.stub!(:puts)
+    output.stub!(:<<)    
+    output.stub!(:title)
+    output.stub!(:line)
+    output.stub!(:with_style)    
+    output.stub!(:table) { yield [] }
+    output.stub!(:io).and_return(mock_io)
+    return output
+  end
+  
+  
+end

data/spec/{file_formats/spec_format.rb → lib/testing_format.rb}

@@ -1,4 +1,4 @@
-class SpecFormat < RequestLogAnalyzer::FileFormat::Base
+class TestingFormat < RequestLogAnalyzer::FileFormat::Base
 
   format_definition.first do |line|
     line.header = true
@@ -14,6 +14,11 @@ class SpecFormat < RequestLogAnalyzer::FileFormat::Base
                      { :name => :duration, :type => :duration, :unit => :msec }]
   end
   
+  format_definition.eval do |line|
+    line.regexp = /evaluation (\{.*\})/
+    line.captures = [{ :name => :evaluated, :type => :eval, :provides => { :greating => :string, :what => :string } }]
+  end 
+  
   format_definition.last do |line|
     line.footer = true
     line.teaser = /finishing /

data/spec/spec_helper.rb

@@ -1,49 +1,13 @@
+$:.reject! { |e| e.include? 'TextMate' }
 $: << File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rubygems'
 require 'spec'
 require 'request_log_analyzer'
 
-module RequestLogAnalyzerSpecHelper
-  
-  def format_file(format)
-    File.dirname(__FILE__) + "/file_formats/#{format}.rb"
-  end
-  
-  def spec_format
-    @spec_format ||= begin
-      require format_file(:spec_format)
-      SpecFormat.new
-    end
-  end
-      
-  def log_fixture(name)
-    File.dirname(__FILE__) + "/fixtures/#{name}.log"
-  end
-  
-  def request(fields, format = spec_format)
-    if fields.kind_of?(Array)
-      format.create_request(*fields)
-    else
-      format.create_request(fields)      
-    end
-  end
-
-  def mock_io
-    mio = mock('IO')
-    mio.stub!(:print)
-    mio.stub!(:puts)    
-    mio.stub!(:write)
-    return mio
-  end
-  
-  def mock_output
-    output = mock('RequestLogAnalyzer::Output')
-    output.stub!(:header)
-    output.stub!(:footer)    
-    output.stub!(:io).and_return(mock_io)
-    return output
-  end
-  
+module RequestLogAnalyzer::Spec
 end
 
+require File.dirname(__FILE__) + '/lib/testing_format'
+require File.dirname(__FILE__) + '/lib/mocks'
+require File.dirname(__FILE__) + '/lib/helper'

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