apachecrunch 0.4 → 0.5

data/lib/progress.rb

@@ -39,7 +39,7 @@ class TimeProgressMeter < ProgressMeter
     def output_progress(entry)
         @_entry_count += 1
         if @_entry_count % @_period == 0
-            puts "Processed through %s" % [entry[:time]]
+            puts "Processed through %s" % [entry.fetch(:time)]
         end
     end
 end

data/test/mock.rb

@@ -0,0 +1,37 @@
+require 'test/stub'
+
+class MockFile
+    attr_accessor :gets, :path, :close_count, :lines
+    def initialize
+        @close_count = 0
+    end
+    def close
+        @close_count += 1
+    end
+    def gets
+        @lines.shift
+    end
+end
+
+# Pretends to be Ruby's File class but just logs what it's asked to do
+class MockFileClass
+    attr_accessor :rename_calls, :open_calls
+    def initialize
+        @rename_calls = []
+        @open_calls = []
+    end
+    def rename(*args); @rename_calls << args; end
+    def open(*args); @open_calls << args; end
+end
+
+# Pretends to be a FormatTokenFactory class but just logs what it's asked to do
+class MockFormatTokenFactoryClass
+    attr_accessor :from_abbrev_calls
+    def initialize
+        @from_abbrev_calls = []
+    end
+    def from_abbrev(*args)
+        @from_abbrev_calls << args
+        StubAlphanumericFormatToken.new
+    end
+end

data/test/runner.rb

@@ -5,6 +5,14 @@ $: << ".."
 $: << "./lib"
 require 'apachecrunch'
 
+class ParticularTests
+    def self.run(tests)
+        tests.each do |test_file|
+            require test_file
+        end
+    end
+end
+
 class AllTests
     def self.run
         Dir.glob("test/test_*.rb").each do |test_file|
@@ -13,4 +21,8 @@ class AllTests
     end
 end
 
-AllTests.run
+if ARGV.length > 0
+    ParticularTests.run(ARGV)
+else
+    AllTests.run
+end

data/test/stub.rb

@@ -1,56 +1,86 @@
-class StubFormatElement < LogFormatElement
-    @abbrev = "%z"
-    @name = :stub
-    @regex = %q!.*!
+class StubAlphanumericFormatToken < ApacheCrunch::FormatToken
+    def name; :alnum; end
+    def regex; %q![A-Za-z0-9]+!; end
+    def captured?; true; end
+    def derivation_rule; ApacheCrunch::NullDerivationRule.new; end
 end
 
-class StubAlphanumericFormatElement < LogFormatElement
-    @abbrev = "%Z"
-    @name = :alnum
-    @regex = %q![A-Za-z0-9]+!
+class StubNumericFormatToken < ApacheCrunch::FormatToken
+    def name; :num; end
+    def regex; %q!\d+!; end
+    def captured?; true; end
+    def derivation_rule; ApacheCrunch::NullDerivationRule.new; end
 end
 
-class StubNumericFormatElement < LogFormatElement
-    @abbrev = "%y"
-    @name = :num
-    @regex = %q!\d+!
+class StubStringFormatToken < ApacheCrunch::FormatToken
+    def initialize(s); @_s = s; end
+    def regex; @_s; end
+    def captured?; false; end
+    def derivation_rule; ApacheCrunch::NullDerivationRule.new; end
 end
 
-class StubFormatString
-    attr_accessor :regex
-    def initialize(regex)
-        @regex = regex
+class StubDerivedToken < ApacheCrunch::FormatToken
+    @name = :derived
+    def derivation_rule; ApacheCrunch::NullDerivationRule.new; end
+end
+
+class StubDerivationRule
+    def source_name; :derivation_source; end
+    def target_names; [:derived]; end
+    def derive(name, source_value)
+        "derived from #{source_value}"
     end
 end
 
-class StubDerivedElement < LogFormatElement
-    @abbrev = ""
-    @name = :derived
-    @regex = %q!.*!
+# Pretends to be the DerivationRuleFinder class, but find() always returns the value it was
+# initialized with
+class StubDerivationRuleFinder
+    def initialize(rule); @_rule = rule; end
+    def find(element_name); return @_rule; end
 end
 
-class StubDerivationSourceElement < LogFormatElement
-    @name = :derivation_source
+class StubDerivationSourceToken
+    def derivation_rule; StubDerivationRule.new; end
+    def name; :derivation_source; end
+    def captured?; true; end
+end
 
-    def derived_elements
-        [StubDerivedElement]
+class StubFormat
+    attr_accessor :tokens, :captured_tokens
+end
+
+class StubEntry
+    attr_accessor :captured_elements
+    def initialize; @captured_elements = {}; end
+end
+
+class StubElement
+    attr_accessor :token, :value, :name, :derivation_rule
+    def populate!(token, value)
+        @token = token
+        @value = value
+        @name = token.name
+        @derivation_rule = @token.derivation_rule
     end
+end
 
-    def self.derive(name, our_own_value)
-        if name == :derived
-            return "derived from #{our_own_value}"
-        end
+class StubValueFetcher
+    def initialize(fetch_result); @fetch = fetch_result; end
+    def fetch(*args); @fetch; end
+end
 
-        nil
+# Pretends to be a Raw- or DerivedValueFetcher class, but StubValueFetcher instance returned by
+# new() just fetches whatever you set fetch_result to.
+class StubValueFetcherClass
+    attr_accessor :fetch_result
+    def new(*args)
+        StubValueFetcher.new(@fetch_result)
     end
 end
 
-class StubLogFormatElementFactory
-    def from_abbrev(abbrev)
-        if abbrev =~ /^%/
-            return StubFormatElement.new
-        else
-            return StubFormatString.new
-        end
+class StubEntryParser
+    def parse_return_values=(value_list)
+        @_parse_return_values = value_list.clone
     end
+    def parse(format, log_text); @_parse_return_values.shift; end
 end

data/test/test_derived_value_fetcher.rb

@@ -0,0 +1,36 @@
+require 'test/stub'
+
+class TestDerivedValueFetcher < Test::Unit::TestCase
+    def setup
+        @inst = ApacheCrunch::DerivedValueFetcher.new
+    end
+
+    def teardown
+        @inst = nil
+    end
+
+    # Tests a successful fetch call
+    def test_fetch
+        entry = StubEntry.new
+        alnum_element = StubElement.new
+        alnum_element.populate!(StubAlphanumericFormatToken.new, "foo123")
+        ds_element = StubElement.new
+        ds_element.populate!(StubDerivationSourceToken.new, "herpaderp")
+
+        @inst.dep_inject!(StubDerivationRuleFinder.new(StubDerivationRule.new))
+        entry.captured_elements = {:alnum => alnum_element, :derivation_source => ds_element}
+        assert_equal("derived from herpaderp", @inst.fetch(entry, :derived))
+    end
+
+    # Tests a fetch call for an element that's not derivable
+    def test_fetch_missing
+        entry = StubEntry.new
+        alnum_element = StubElement.new
+        alnum_element.populate!(StubAlphanumericFormatToken.new, "foo123")
+        ds_element = StubElement.new
+        ds_element.populate!(StubDerivationSourceToken.new, "herpaderp")
+
+        entry.captured_elements = [alnum_element, ds_element]
+        assert_nil(@inst.fetch(entry, :missing_element))
+    end
+end

data/test/test_element.rb

@@ -0,0 +1,18 @@
+require 'test/stub'
+
+class TestElement < Test::Unit::TestCase
+    def setup
+        @inst = ApacheCrunch::Element.new
+    end
+
+    def teardown
+        @inst = nil
+    end
+
+    # Tests a successful derivation_rule call
+    def test_derivation_rule
+        @inst.populate!(StubDerivationSourceToken.new, "bar456")
+        assert_instance_of(StubDerivationRule, @inst.derivation_rule,
+                           "#{@inst.class}#derivation_rule returned wrong type of thing")
+    end
+end

data/test/test_element_value_fetcher.rb

@@ -0,0 +1,45 @@
+require 'test/stub'
+
+class TestElementValueFetcher < Test::Unit::TestCase
+    def setup
+        @inst = ApacheCrunch::ElementValueFetcher.new
+        @_raw_fetcher = StubValueFetcherClass.new
+        @_derived_fetcher = StubValueFetcherClass.new
+    end
+
+    def teardown
+        @inst = nil
+        @_raw_fetcher = nil
+        @_derived_fetcher = nil
+    end
+
+    # Tests a successful fetch call that hits a raw element
+    def test_fetch_raw
+        @_raw_fetcher.fetch_result = "raw value"
+        @_derived_fetcher.fetch_result = nil
+        @inst.dep_inject!(@_raw_fetcher, @_derived_fetcher)
+
+        entry = StubEntry.new
+        assert_equal("raw value", @inst.fetch(entry, :irrelevant))
+    end
+
+    # Tests a successful fetch call that hits a derived element
+    def test_fetch_derived
+        @_raw_fetcher.fetch_result = nil
+        @_derived_fetcher.fetch_result = "derived value"
+        @inst.dep_inject!(@_raw_fetcher, @_derived_fetcher)
+
+        entry = StubEntry.new
+        assert_equal("derived value", @inst.fetch(entry, :irrelevant))
+    end
+
+    # Tests a fetch call for an element that's not there
+    def test_fetch_missing
+        @_raw_fetcher.fetch_result = nil
+        @_derived_fetcher.fetch_result = nil
+        @inst.dep_inject!(@_raw_fetcher, @_derived_fetcher)
+
+        entry = StubEntry.new
+        assert_nil(@inst.fetch(entry, :missing_element))
+    end
+end

data/test/test_entry_parser.rb

@@ -0,0 +1,39 @@
+require 'test/stub'
+
+class TestEntryParser < Test::Unit::TestCase
+    def setup
+        @inst = ApacheCrunch::EntryParser.new
+
+        @format = StubFormat.new
+        alnum_token = StubAlphanumericFormatToken.new
+        string_token = StubStringFormatToken.new(" stuff ")
+        num_token = StubNumericFormatToken.new
+        @format.tokens = [alnum_token, string_token, num_token]
+        @format.captured_tokens = [alnum_token, num_token]
+    end
+
+    def teardown
+        @inst = nil
+    end
+
+    # Tests a successful parse call
+    def test_parse
+        line_text = "hurrdurr stuff 01560"
+        @inst.dep_inject!(StubEntry, StubElement)
+
+        result = @inst.parse(@format, line_text)
+        assert_instance_of(StubEntry, result,
+                           "#{@inst.class}#parse returned wrong type of thing")
+    end
+
+    # Tests a parse call on a malformatted line
+    def test_parse_fail
+        line_text = "slammadamma doesn't match"
+        @inst.dep_inject!(StubEntry, StubElement)
+
+        $VERBOSE = nil
+        result = @inst.parse(@format, line_text)
+        $VERBOSE = true
+        assert_nil(result, "#{@inst.class}#parse returned non-nil for malformmated line")
+    end
+end

data/test/test_format.rb

@@ -1,4 +1,4 @@
-require 'test/stub'
+require 'test/mock'
 
 class TestFormat < Test::Unit::TestCase
     def setup
@@ -9,55 +9,17 @@ class TestFormat < Test::Unit::TestCase
         @inst = nil
     end
 
-    # Tests appending an element to the format
-    def test_append
-        format_element = StubFormatElement.new
-        @inst.append(format_element)
-        assert_same(@inst.tokens[-1], format_element)
-    end
-
-    # Tests regex compilation for a simple format
-    def test_regex_simple
-        @inst.append(StubAlphanumericFormatElement.new)
-        "abc123\n" =~ @inst.regex
-        assert_equal($1, "abc123")
-
-        "!abc123\n" =~ @inst.regex
-        assert_nil($1)
-    end
-
-    # Tests regex compilation for a more complex format
-    def test_regex_complex
-        @inst.append(StubNumericFormatElement.new)
-        @inst.append(StubFormatString.new(' \(some stuff\) '))
-        @inst.append(StubAlphanumericFormatElement.new)
-
-        "54321 (some stuff) alphaNumericStuff" =~ @inst.regex
-        assert_equal([Regexp.last_match(1), Regexp.last_match(2)],
-                      ["54321", "alphaNumericStuff"])
-
-        "54321 (doesn't match) alphaNumericStuff" =~ @inst.regex
-        assert_equal([Regexp.last_match(1), Regexp.last_match(2)],
-                      [nil, nil])
-    end
-
-    # Tests the list of matchable elements
-    def test_elements
-        num_element = StubNumericFormatElement.new
-        alnum_element = StubAlphanumericFormatElement.new
-        @inst.append(num_element)
-        @inst.append(StubFormatString.new(' \(some stuff\) '))
-        @inst.append(alnum_element)
-
-        assert_equal(@inst.elements, [num_element, alnum_element])
-    end
-
-    # Tests the derivation map
-    def test_derivation_map
-        @inst.append(StubNumericFormatElement.new)
-        @inst.append(StubFormatString.new(' \(some stuff\) '))
-        @inst.append(StubDerivationSourceElement.new)
-
-        assert(@inst.derivation_map, {:derived => StubDerivationSourceElement})
+    def test_captured_tokens
+        tokens = [
+            StubAlphanumericFormatToken.new,
+            StubStringFormatToken.new("foo"),
+            StubNumericFormatToken.new,
+            StubStringFormatToken.new("bar"),
+            StubAlphanumericFormatToken.new
+        ]
+
+        @inst.tokens = tokens
+        assert_equal([tokens[0], tokens[2], tokens[4]], @inst.captured_tokens,
+                     "#{@inst.class}#captured_tokens returned the wrong list of captured tokens")
     end
 end

data/test/test_format_parser.rb

@@ -1,26 +1,35 @@
-require 'test/stub'
+require 'test/mock'
 
 class TestFormatParser < Test::Unit::TestCase
     def setup
-        @inst = ApacheCrunch::FormatParser.new(StubLogFormatElementFactory.new,
-                                               StubFormatString)
+        @inst = ApacheCrunch::FormatParser.new
     end
 
     def teardown
         @inst = nil
     end
 
-    def test_parse_simple
-        tokens = @inst.parse_def("%Z %z")
-        [StubFormatElement, StubFormatString, StubFormatElement].each_with_index do |c,i|
-            assert_instance_of(c, tokens[i])
-        end
-    end
+    def test_parse
+        datasets = [
+            ["%a %b", [["%a"], [" "], ["%b"]]],
+            ["%a bare string %{Request-Header}i",
+                [["%a"], [" bare string "], ["%{Request-Header}i"]]],
+            ["%{foo:[A-Za-z0-9]}r %% %a %b",
+                [["%{foo:[A-Za-z0-9]}r"], [" "], ["%%"], [" "], ["%a"], [" "], ["%b"]]]
+        ]
+
+        datasets.each do |dataset|
+            format_def = dataset[0]
+            from_abbrev_calls = dataset[1]
+
+            mock_format_token_factory = MockFormatTokenFactoryClass.new
+            @inst.dep_inject!(mock_format_token_factory)
 
-    def test_parse_complex
-        tokens = @inst.parse_def("%{Foo-Bar}i %{baz:\d+}r")
-        [StubFormatElement, StubFormatString, StubFormatElement].each_with_index do |c,i|
-            assert_instance_of(c, tokens[i])
+            result = @inst.parse_def(format_def).length
+            assert_equal(from_abbrev_calls, mock_format_token_factory.from_abbrev_calls,
+                         "#{@inst.class}#parse_def didn't call FormatTokenFactory with right parameters")
+            assert_equal(from_abbrev_calls.length, result,
+                         "#{@inst.class}#parse_def didn't return right number of tokens")
         end
     end
 end