request-log-analyzer 1.1.2 → 1.1.3

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -1,5 +1,7 @@
 module RequestLogAnalyzer::Output
   
+  # Fixed Width output class.
+  # Outputs a fixed width ASCII or UF8 report.
   class FixedWidth < Base
   
     module Monochrome
@@ -126,8 +128,12 @@ module RequestLogAnalyzer::Output
       end
      
       if column_widths.include?(nil)
+        fill_column = columns[column_widths.index(nil)]
         width_left = options[:width] - ((columns.length - 1) * (style[:cell_separator] ? 3 : 1)) - column_widths.compact.inject(0) { |sum, col| sum + col}
-        column_widths[column_widths.index(nil)] = width_left
+        column_widths[column_widths.index(nil)] = case fill_column[:type]
+          when :ratio; width_left # max out
+          else;        [width_left, fill_column[:actual_width]].min
+        end
       end
     
       # Print table header

data/lib/request_log_analyzer/output/html.rb

@@ -1,5 +1,6 @@
 module RequestLogAnalyzer::Output
   
+  # HTML Output class. Generated a HTML-formatted report, including CSS.
   class HTML < Base
   
     # def initialize(io, options = {})

data/lib/request_log_analyzer/request.rb

@@ -30,6 +30,10 @@ module RequestLogAnalyzer
         end
       end
       
+      def convert_eval(value, capture_definition)
+        eval(value)
+      end
+      
       # Slow default method to parse timestamps
       def convert_timestamp(value, capture_definition)
         DateTime.parse(value).strftime('%Y%m%d%H%M%S').to_i unless value.nil?

data/lib/request_log_analyzer/source/log_parser.rb

@@ -11,6 +11,9 @@ module RequestLogAnalyzer::Source
   # occurs.
   class LogParser < Base
 
+    DEFAULT_PARSE_STRATEGY = 'assume-correct'
+    PARSE_STRATEGIES = ['cautious', 'assume-correct']
+
     attr_reader :source_files
 
     # Initializes the parser instance.
@@ -25,9 +28,10 @@ module RequestLogAnalyzer::Source
       @skipped_requests = 0
       @current_io       = nil
       @source_files     = options[:source_files]
-
-      # install the file format module (see RequestLogAnalyzer::FileFormat)
-      # and register all the line definitions to the parser
+      
+      @options[:parse_strategy] ||= DEFAULT_PARSE_STRATEGY
+      raise "Unknown parse strategy" unless PARSE_STRATEGIES.include?(@options[:parse_strategy])
+      
       self.register_file_format(format)
     end
     
@@ -69,24 +73,17 @@ module RequestLogAnalyzer::Source
     # Yeilds a Hash when it encounters a chunk of information.
     def parse_io(io, options = {}, &block)
 
-      # parse every line type by default
-      line_types = options[:line_types] || file_format.line_definitions.keys
-
-      # check whether all provided line types are valid
-      unknown = line_types.reject { |line_type| file_format.line_definitions.has_key?(line_type) }
-      raise "Unknown line types: #{unknown.join(', ')}" unless unknown.empty?
-
       @current_io = io
       @current_io.each_line do |line|
 
         @progress_handler.call(:progress, @current_io.pos) if @progress_handler && @current_io.kind_of?(File)
 
         request_data = nil
-        line_types.each do |line_type|
-          line_type_definition = file_format.line_definitions[line_type]
-          break if request_data = line_type_definition.matches(line, @current_io.lineno, self)
+        file_format.line_definitions.each do |line_type, definition|
+          request_data = definition.matches(line, @current_io.lineno, self)
+          break if request_data
         end
-
+        
         if request_data
           @parsed_lines += 1
           update_current_request(request_data, &block)
@@ -130,16 +127,17 @@ module RequestLogAnalyzer::Source
     def update_current_request(request_data, &block)
       if header_line?(request_data)
         unless @current_request.nil?
-          if options[:assume_correct_order]
-            handle_request(@current_request, &block) #yield @current_request
-            @current_request = @file_format.create_request(request_data)
-          else
+          case options[:parse_strategy]
+          when 'assume-correct'
+            handle_request(@current_request, &block)
+            @current_request = @file_format.request(request_data)
+          when 'cautious'
             @skipped_lines += 1
-            warn(:unclosed_request, "Encountered header line, but previous request was not closed!")
+            warn(:unclosed_request, "Encountered header line (#{request_data[:line_definition].name.inspect}), but previous request was not closed!")
             @current_request = nil # remove all data that was parsed, skip next request as well.
           end
         else
-          @current_request = @file_format.create_request(request_data)              
+          @current_request = @file_format.request(request_data)              
         end
       else
         unless @current_request.nil?
@@ -150,7 +148,7 @@ module RequestLogAnalyzer::Source
           end
         else
           @skipped_lines += 1
-          warn(:no_current_request, "Parsebale line found outside of a request!")
+          warn(:no_current_request, "Parsebale line (#{request_data[:line_definition].name.inspect}) found outside of a request!")
         end
       end
     end

data/lib/request_log_analyzer/source.rb

@@ -4,6 +4,7 @@ module RequestLogAnalyzer::Source
     RequestLogAnalyzer::load_default_class_file(self, const)
   end
   
+  # Base Source class. All other sources inherit from this class
   class Base
     
     include RequestLogAnalyzer::FileFormat::Awareness
@@ -36,7 +37,7 @@ module RequestLogAnalyzer::Source
     def prepare
     end
     
-    def requests(&block)
+    def each_request(&block)
       return true
     end
 

data/lib/request_log_analyzer/tracker/duration.rb

@@ -31,26 +31,86 @@ module RequestLogAnalyzer::Tracker
     end
 
     def update(request)
-      category = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
-      duration = options[:duration].respond_to?(:call) ? options[:duration].call(request) : request[options[:duration]]
+      if options[:multiple]
+        categories = request.every(options[:category])
+        durations  = request.every(options[:duration])
+        
+        if categories.length == durations.length
+          categories.each_with_index do |category, index|
+            @categories[category] ||= {:hits => 0, :cumulative => 0.0}
+            @categories[category][:hits] += 1
+            @categories[category][:cumulative] += durations[index]
+          end
+        else
+          raise "Capture mismatch for multiple values in a request"
+        end
+      else
+        category = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
+        duration = options[:duration].respond_to?(:call) ? options[:duration].call(request) : request[options[:duration]]
   
-      if !duration.nil? && !category.nil?
-        @categories[category] ||= {:count => 0, :total_duration => 0.0}
-        @categories[category][:count] += 1
-        @categories[category][:total_duration] += duration
+        if !duration.nil? && !category.nil?
+          @categories[category] ||= {:hits => 0, :cumulative => 0.0}
+          @categories[category][:hits] += 1
+          @categories[category][:cumulative] += duration
+        end
       end
     end
+    
+    def hits(cat)
+      categories[cat][:hits]
+    end
+    
+    def cumulative_duration(cat)
+      categories[cat][:cumulative]
+    end
+    
+    def average_duration(cat)
+      categories[cat][:cumulative] / categories[cat][:hits]  
+    end
+    
+    def overall_average_duration
+      overall_cumulative_duration / overall_hits
+    end
+    
+    def overall_cumulative_duration
+      categories.inject(0.0) { |sum, (name, cat)| sum + cat[:cumulative] }  
+    end
+    
+    def overall_hits
+      categories.inject(0) { |sum, (name, cat)| sum + cat[:hits] }
+    end
 
+    def sorted_by_hits
+      sorted_by(:hits)
+    end
+
+    def sorted_by_cumulative
+      sorted_by(:cumulative)
+    end
+
+    def sorted_by_average
+      sorted_by { |cat| cat[:cumulative] / cat[:hits] }
+    end
+          
+    def sorted_by(by = nil) 
+      if block_given?
+        categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) } 
+      else
+        categories.sort { |a, b| b[1][by] <=> a[1][by] } 
+      end
+    end
+    
+    # Builds a result table using a provided sorting function 
     def report_table(output, amount = 10, options = {}, &block)
     
       output.title(options[:title])
     
       top_categories = @categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) }.slice(0...amount)
-      output.table({:title => 'Action'}, {:title => 'Hits', :align => :right, :min_width => 4}, 
+      output.table({:title => 'Category', :width => :rest}, {:title => 'Hits', :align => :right, :min_width => 4}, 
             {:title => 'Cumulative', :align => :right, :min_width => 10}, {:title => 'Average', :align => :right, :min_width => 8}) do |rows|
       
         top_categories.each do |(cat, info)|
-          rows << [cat, info[:count], "%0.02fs" % info[:total_duration], "%0.02fs" % (info[:total_duration] / info[:count])]
+          rows << [cat, info[:hits], "%0.02fs" % info[:cumulative], "%0.02fs" % (info[:cumulative] / info[:hits])]
         end        
       end
 
@@ -59,19 +119,19 @@ module RequestLogAnalyzer::Tracker
     def report(output)
 
       options[:title]  ||= 'Request duration'
-      options[:report] ||= [:total, :average]
+      options[:report] ||= [:cumulative, :average]
       options[:top]    ||= 20
   
       options[:report].each do |report|
         case report
         when :average
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by average time") { |request| request[:total_duration] / request[:count] }  
-        when :total
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by cumulative time") { |request| request[:total_duration] }
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by average time") { |cat| cat[:cumulative] / cat[:hits] }  
+        when :cumulative
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by cumulative time") { |cat| cat[:cumulative] }
         when :hits
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by hits") { |request| request[:count] }
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by hits") { |cat| cat[:hits] }
         else
-          output << "Unknown duration report specified\n"
+          raise "Unknown duration report specified: #{report}!"
         end
       end
     end      

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,19 +44,31 @@ 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

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

@@ -4,6 +4,10 @@ require File.dirname(__FILE__) + '/cli/progressbar'
 module RequestLogAnalyzer
    
   VERSION = '1.1'
+  
+  def self.const_missing(const)
+    load_default_class_file(RequestLogAnalyzer, const)
+  end
     
   # Function to implement 
   def self.load_default_class_file(base, const)
@@ -25,12 +29,4 @@ module RequestLogAnalyzer
   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'