request-log-analyzer 1.0.2 → 1.6.3

data/spec/file_format_spec.rb

@@ -1,78 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe RequestLogAnalyzer::FileFormat, :format_definition do
-  
-  before(:each) do
-    @first_file_format = Class.new(RequestLogAnalyzer::FileFormat)
-    @second_file_format = Class.new(RequestLogAnalyzer::FileFormat)
-  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 => []
-    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 "specify lines with a block" do
-    
-    @first_file_format.new.should have(0).line_definitions    
-    
-    @first_file_format.format_definition do |format|
-      format.block_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 => []
-    end
-    
-    @second_file_format.format_definition do |line|
-      line.second_test :regexp => /test/, :captures => []
-    end
-
-    @first_file_format.new.should have(1).line_definitions    
-    @first_file_format.new.line_definitions[:first_test].should_not be_nil
-    @second_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 RequestLogAnalyzerSpecHelper
-
-  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
-    @file_format = RequestLogAnalyzer::FileFormat.load(format_file(:spec_format))
-    @file_format.should be_kind_of(SpecFormat)
-  end
-  
-end

data/spec/file_formats/spec_format.rb

@@ -1,26 +0,0 @@
-class SpecFormat < RequestLogAnalyzer::FileFormat
-
-  format_definition.first do |line|
-    line.header = true
-    line.teaser = /processing /
-    line.regexp = /processing request (\d+)/
-    line.captures = [{ :name => :request_no, :type => :integer, :anonymize => :slightly }]    
-  end
-  
-  format_definition.test do |line|
-    line.teaser = /testing /
-    line.regexp = /testing is (\w+)/
-    line.captures = [{ :name => :test_capture, :type => :string, :anonymize => true}]
-  end
-  
-  format_definition.last do |line|
-    line.footer = true
-    line.teaser = /finishing /
-    line.regexp = /finishing request (\d+)/
-    line.captures = [{ :name => :request_no, :type => :integer}]
-  end
-  
-  report do |analyze|
-    analyze.category :test_capture, :title => 'What is testing exactly?'
-  end
-end

data/spec/filter_spec.rb

@@ -1,137 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/../lib/request_log_analyzer/filter/timespan'
-require File.dirname(__FILE__) + '/../lib/request_log_analyzer/filter/field'
-
-describe RequestLogAnalyzer::Filter::Timespan, 'both before and after'  do
-  include RequestLogAnalyzerSpecHelper
-
-  before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Timespan.new(spec_format, :after => DateTime.parse('2009-01-01'), :before => DateTime.parse('2009-02-02'))
-    @filter.prepare
-  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 RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Timespan.new(spec_format, :before => DateTime.parse('2009-02-02'))    
-    @filter.prepare
-  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 RequestLogAnalyzerSpecHelper 
-  
-  before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Timespan.new(spec_format, :after => DateTime.parse('2009-01-01'))
-    @filter.prepare
-  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
-
-describe RequestLogAnalyzer::Filter::Field, 'string in accept mode' do
-  include RequestLogAnalyzerSpecHelper
-
-  before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Field.new(spec_format, :field => :test, :value => 'test', :mode => :select)
-    @filter.prepare
-  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 RequestLogAnalyzerSpecHelper
-
-  before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Field.new(spec_format, :field => :test, :value => 'test', :mode => :reject)
-    @filter.prepare
-  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 RequestLogAnalyzerSpecHelper
-
-  before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Field.new(spec_format, :field => :test, :value => '/test/', :mode => :select)
-    @filter.prepare
-  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/line_definition_spec.rb

@@ -1,124 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe RequestLogAnalyzer::LineDefinition, :parsing do
-  
-  before(:each) do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-      :teaser   => /Testing /,
-      :regexp   => /Testing (\w+), tries\: (\d+)/,
-      :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer }]
-    })
-  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
-  
-  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 a hash with all captures set" do
-    hash = @line_definition.matches("Testing LineDefinition, tries: 123")
-    hash[:what].should == "LineDefinition"
-    hash[:tries].should == 123
-  end
-  
-  it "should return a hash with :line_type set" do
-     @line_definition.matches("Testing LineDefinition, tries: 123")[:line_type].should == :test
-   end
-end
-
-describe RequestLogAnalyzer::LineDefinition, :anonymizing_basics do
-  before(:each) do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-      :teaser   => /Anonymize /,
-      :regexp   => /Anonymize (\w+)!/,
-      :captures => [{ :name => :what, :type => :string }]
-    })
-  end 
-  
-  it "should return nil if the teaser does not match" do
-    @line_definition.anonymize("Nonsense").should be_nil
-  end
-  
-  it "should return nil if no teaser exists and the regexp doesn't match" do
-    line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize!/, :captures => []})
-
-    line_definition.anonymize('nonsense').should be_nil
-  end
-  
-  it "should return itself if only the teaser matches" do
-    @line_definition.anonymize("Anonymize 456").should == "Anonymize 456"
-  end  
-  
-  it "should return an empty string if the teaser matches and discard_teaser_lines is set" do
-    @line_definition.anonymize("Anonymize 456", :discard_teaser_lines => true).should == ""
-  end
-  
-  it "should return a string if the line matches" do
-    @line_definition.anonymize("Anonymize anonymizing!").should be_kind_of(String)
-  end
-  
-  it "should not anonymize :what" do
-    @line_definition.anonymize("Anonymize anonymizing!").should == "Anonymize anonymizing!"
-  end  
-end
-
-describe RequestLogAnalyzer::LineDefinition, :anonymizing_specifics do
-
-  it "should anonymize completely if anonymize is true" do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize (.+)!/, :captures => [{ :name => :what, :type => :string, :anonymize => true }]})
-
-    @line_definition.anonymize("Anonymize 1.2.3.4!").should == "Anonymize ***!"
-  end    
-    
-  it "should anonymize a URL" do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize (.+)!/, :captures => [{ :name => :what, :type => :string, :anonymize => :url }]})
-    
-    @line_definition.anonymize("Anonymize https://www.not-anonymous.com/path/to/file.html!").should == "Anonymize http://example.com/path/to/file.html!"
-  end
-  
-  it "should anonymize an IP address" do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize (.+)!/, :captures => [{ :name => :what, :type => :string, :anonymize => :ip }]})
-    
-    @line_definition.anonymize("Anonymize 1.2.3.4!").should == "Anonymize 127.0.0.1!"
-  end 
-  
-  it "should anonymize completely if the anonymizer is unknown" do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize (.+)!/, :captures => [{ :name => :what, :type => :string, :anonymize => :unknown }]})
-
-    @line_definition.anonymize("Anonymize 1.2.3.4!").should == "Anonymize ***!"
-  end
-  
-  it "should anonymize an integer slightly" do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize (.+)!/, :captures => [{ :name => :what, :type => :integer, :anonymize => :slightly }]})
-
-    @line_definition.anonymize("Anonymize 1234!").should =~ /Anonymize \d{3,4}\!/
-  end
-  
-  it "should anonymize an integer slightly" do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize (.+)!/, :captures => [{ :name => :what, :type => :integer, :anonymize => :slightly }]})
-
-    @line_definition.anonymize("Anonymize 1234!").should =~ /Anonymize \d{3,4}\!/
-  end
-  
-  it "should anonymize an double slightly" do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
-          :regexp => /Anonymize (.+)!/, :captures => [{ :name => :what, :type => :double, :anonymize => :slightly }]})
-
-    @line_definition.anonymize("Anonymize 1.3!").should =~ /Anonymize 1\.\d+\!/
-  end
-   
-end

data/spec/log_parser_spec.rb

@@ -1,68 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe RequestLogAnalyzer::LogParser, :requests do
-  include RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @log_parser = RequestLogAnalyzer::LogParser.new(spec_format)
-  end
-  
-  it "should have multiple line definitions" do
-    @log_parser.file_format.line_definitions.length.should >= 2
-  end  
-  
-  it "should have a valid language" do
-    @log_parser.file_format.should be_valid
-  end
-  
-  it "should parse more lines than requests" do
-    @log_parser.should_receive(:handle_request).with(an_instance_of(RequestLogAnalyzer::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(RequestLogAnalyzer::Request)).once
-    @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)])
-  end
-  
-  it "should parse all request values when spanned over multiple files" do
-    @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)]) do |request|
-      request.lines.should have(4).items
-      
-      request[:request_no].should == 1
-      request[:test_capture].should == "amazing"      
-    end
-  end  
-  
-  it "should parse a stream and find valid requests" do
-    io = File.new(log_fixture(:test_file_format), 'r')
-    @log_parser.parse_io(io) do |request|
-      request.should be_kind_of(RequestLogAnalyzer::Request)
-      request.should =~ :test
-      request[:test_capture].should_not be_nil      
-    end
-    io.close
-  end  
-  
-end
-
-describe RequestLogAnalyzer::LogParser, :warnings do
-  include RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @log_parser = RequestLogAnalyzer::LogParser.new(spec_format)
-  end
-    
-  it "should warn about teaser matching problems" do
-    @log_parser.should_receive(:warn).with(:teaser_check_failed, anything).exactly(5).times
-    @log_parser.parse_file(log_fixture(:test_file_format))
-  end
-  
-  it "should warn about unmatching request headers and footers" do
-    @log_parser.should_receive(:warn).with(:unclosed_request, anything).at_least(1).times    
-    @log_parser.should_receive(:warn).with(:no_current_request, anything).at_least(1).times    
-    @log_parser.should_not_receive(:handle_request)    
-    @log_parser.parse_file(log_fixture(:test_order))    
-  end  
-end

data/spec/log_processor_spec.rb

@@ -1,57 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'request_log_analyzer/log_processor'
-
-describe RequestLogAnalyzer::LogProcessor, 'anonymization' do
-
-  include RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @log_anonymizer = RequestLogAnalyzer::LogProcessor.new(spec_format, :anonymize, {})
-    @alternate_log_anonymizer = RequestLogAnalyzer::LogProcessor.new(spec_format, :anonymize, {:keep_junk_lines => true, :discard_teaser_lines => true})
-  end
-  
-  it "should keep a junk line if :keep_junk_lines is true" do
-    @alternate_log_anonymizer.anonymize_line("junk line\n").should == "junk line\n"
-  end
-  
-  it "should remove a junk line" do
-    @log_anonymizer.anonymize_line("junk line\n").should be_empty
-  end
-
-  it "should keep a teaser line intact" do
-    @log_anonymizer.anonymize_line("processing 1234\n").should == "processing 1234\n"
-  end
-  
-  it "should discard a teaser line if discard_teaser_line is true" do
-    @alternate_log_anonymizer.anonymize_line("processing 1234\n").should be_empty
-  end
-  
-  it "should keep a matching line intact if no anonymizing is declared" do
-    @alternate_log_anonymizer.anonymize_line("finishing request 130\n").should == "finishing request 130\n"
-  end  
-
-  it "should anonymize values completely if requested" do
-    @alternate_log_anonymizer.anonymize_line("testing is great\n").should == "testing is ***\n"
-  end  
-  
-  it "should anonymize values slightly if requested" do
-    @alternate_log_anonymizer.anonymize_line("finishing request 130\n").should =~ /^finishing request 1\d\d\n$/
-  end
-end
-
-describe RequestLogAnalyzer::LogProcessor, 'stripping log files' do
-
-  include RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @log_stripper = RequestLogAnalyzer::LogProcessor.new(spec_format, :strip, {})
-  end
-  
-  it "should remove a junk line" do
-    @log_stripper.strip_line("junk line\n").should be_empty
-  end
-
-  it "should keep a teaser line intact" do
-    @log_stripper.strip_line("processing 1234\n").should be_empty
-  end
-end

data/spec/merb_format_spec.rb

@@ -1,38 +0,0 @@
-# require File.dirname(__FILE__) + '/spec_helper'
-# 
-# describe RequestLogAnalyzer::LogParser, "Merb" do
-#   include RequestLogAnalyzerSpecHelper
-#   
-#   before(:each) do
-#     @log_parser = RequestLogAnalyzer::LogParser.new(:merb)
-#   end
-#   
-#   it "should have a valid language definitions" do
-#     @log_parser.file_format.should be_valid
-#   end
-#   
-#   it "should parse a stream and find valid requests" do
-#     File.open(log_fixture(:merb), 'r') do |io|
-#       @log_parser.parse_io(io) do |request| 
-#         request.should be_kind_of(RequestLogAnalyzer::Request)
-#       end
-#     end
-#   end
-#
-#   it "should find 11 completed requests" do
-#     @log_parser.should_receive(:handle_request).exactly(11).times
-#     @log_parser.parse_file(log_fixture(:merb))
-#   end
-#   
-#   it "should parse all details from a request correctly" do
-#     request = nil
-#     @log_parser.parse_file(log_fixture(:merb)) { |found_request| request ||= found_request }
-#     
-#     request.should be_completed
-#     request[:timestamp].should == DateTime.parse('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
-# end

data/spec/rails_format_spec.rb

@@ -1,76 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe RequestLogAnalyzer::LogParser, "Rails" do
-  include RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @log_parser = RequestLogAnalyzer::LogParser.new(RequestLogAnalyzer::FileFormat.load(:rails))
-  end
-  
-  it "should have a valid language definitions" do
-    @log_parser.file_format.should be_valid
-  end
-  
-  it "should parse a stream and find valid requests" do
-    io = File.new(log_fixture(:rails_1x), 'r')
-    @log_parser.parse_io(io) do |request| 
-      request.should be_kind_of(RequestLogAnalyzer::Request)
-    end
-    io.close
-  end  
-  
-  it "should find 4 completed requests" do
-    @log_parser.should_not_receive(:warn)  
-    @log_parser.should_receive(:handle_request).exactly(4).times
-    @log_parser.parse_file(log_fixture(:rails_1x))
-  end  
-  
-  it "should parse a Rails 2.2 request properly" do
-    @log_parser.should_not_receive(:warn)
-    @log_parser.parse_file(log_fixture(:rails_22)) do |request|
-      request.should =~ :processing
-      request.should =~ :completed  
-    
-      request[:controller].should == 'PageController'
-      request[:action].should     == 'demo'
-      request[:url].should        == 'http://www.example.coml/demo'    
-      request[:status].should     == 200
-      request[:duration].should   == 0.614
-      request[:db].should         == 0.031
-      request[:view].should       == 0.120
-    end
-  end
-  
-  it "should parse a syslog file with prefix correctly" do
-    @log_parser.should_not_receive(:warn)    
-    @log_parser.parse_file(log_fixture(:syslog_1x)) do |request| 
-      
-      request.should be_completed
-      
-      request[:controller].should == 'EmployeeController'
-      request[:action].should     == 'index'
-      request[:url].should        == 'http://example.com/employee.xml'    
-      request[:status].should     == 200
-      request[:duration].should   == 0.21665
-      request[:db].should         == 0.0
-      request[:view].should       == 0.00926
-    end
-  end
-  
-  it "should parse cached requests" do
-    @log_parser.should_not_receive(:warn)
-    @log_parser.parse_file(log_fixture(:rails_22_cached)) do |request| 
-      request.should be_completed
-      request =~ :cache_hit
-    end  
-  end
-  
-  it "should detect unordered requests in the logs" do
-    @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
-    @log_parser.should_receive(:warn).with(:no_current_request, anything).twice
-    @log_parser.parse_file(log_fixture(:rails_unordered))
-  end  
-end

data/spec/request_spec.rb

@@ -1,72 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe RequestLogAnalyzer::Request, :incomplete_request do
-  
-  include RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @incomplete_request = RequestLogAnalyzer::Request.new(spec_format)
-    @incomplete_request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
-  end
-  
-  it "should be single if only one line has been added" do
-    @incomplete_request.should_not be_empty
-  end
-  
-  it "should not be a completed request" do
-    @incomplete_request.should_not be_completed
-  end  
-  
-  it "should take the line type of the first line as global line_type" do
-    @incomplete_request.lines[0][:line_type].should == :test
-    @incomplete_request.should =~ :test
-  end
-  
-  it "should return the first field value" do
-    @incomplete_request[:test_capture].should == 'awesome!'
-  end
-  
-  it "should return nil if no such field is present" do
-    @incomplete_request[:nonexisting].should be_nil
-  end
-end  
-
-
-describe RequestLogAnalyzer::Request, :completed_request do
-  
-  include RequestLogAnalyzerSpecHelper
-  
-  before(:each) do
-    @completed_request = RequestLogAnalyzer::Request.new(spec_format)
-    @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' }            
-    @completed_request << { :line_type => :last,  :lineno => 10, :time => 0.03 }
-  end
-  
-  it "should not be empty when multiple liness are added" do
-    @completed_request.should_not be_empty
-  end
-  
-  it "should be a completed request" do
-    @completed_request.should be_completed
-  end
-  
-  it "should recognize all line types" do
-    [:first, :test, :last].each { |type| @completed_request.should =~ type }
-  end
-  
-  it "should detect the correct field value" do
-    @completed_request[:name].should == 'first line!'
-    @completed_request[:time].should == 0.03
-  end
-  
-  it "should detect the first matching field value" do  
-    @completed_request.first(:test_capture).should == 'testing'
-  end
-  
-  it "should detect the every matching field value" do  
-    @completed_request.every(:test_capture).should == ['testing', "testing some more"]
-  end
-  
-end

data/spec/summarizer_spec.rb

@@ -1,9 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'request_log_analyzer/aggregator/summarizer'
-
-describe RequestLogAnalyzer::Aggregator::Summarizer do
-  
-  before(:each) do
-  end
-
-end