recog-intrigue 2.3.7

data/spec/data/whitespaced_fingerprint.xml

@@ -0,0 +1,5 @@
+<fingerprint pattern=".*this doesn't matter.*">
+  <description> I    love    
+    whitespace!
+  </description>
+</fingerprint>

data/spec/lib/fingerprint_self_test_spec.rb

@@ -0,0 +1,174 @@
+require 'recog/db'
+require 'regexp_parser'
+require 'nokogiri'
+
+describe Recog::DB do
+  let(:schema) { Nokogiri::XML::Schema(open(File.expand_path(File.join(%w(xml fingerprints.xsd))))) }
+  Dir[File.expand_path File.join('xml', '*.xml')].each do |xml_file_name|
+
+    describe "##{File.basename(xml_file_name)}" do
+
+      it "is valid XML" do
+        doc = Nokogiri::XML(open(xml_file_name))
+        errors = schema.validate(doc)
+        expect(errors).to be_empty, "#{xml_file_name} is invalid recog XML -- #{errors.inspect}"
+      end
+
+      db = Recog::DB.new(xml_file_name)
+
+      it "has a match key" do
+        expect(db.match_key).not_to be_nil
+        expect(db.match_key).not_to be_empty
+      end
+
+      it "has valid 'preference' value" do
+          # Reserve values below 0.10 and above 0.90 for users
+          # See xml/fingerprints.xsd
+          expect(db.preference.class).to be ::Float
+          expect(db.preference).to be_between(0.10, 0.90)
+      end
+
+      fp_descriptions = []
+      db.fingerprints.each_index do |i|
+        fp = db.fingerprints[i]
+
+        it "doesn't have a duplicate description" do
+          if fp_descriptions.include?(fp.name)
+            fail "'#{fp.name}'s description is not unique"
+          else
+            fp_descriptions << fp.name
+          end
+        end
+
+        context "#{fp.name}" do
+          param_names = []
+          it "has consistent os.device and hw.device" do
+            if fp.params['os.device'] && fp.params['hw.device'] && (fp.params['os.device'] != fp.params['hw.device'])
+              fail "#{fp.name} has both hw.device and os.device but with differing values"
+            end
+          end
+          fp.params.each do |param_name, pos_value|
+            pos, value = pos_value
+            it "has valid looking fingerprint parameter names" do
+              unless param_name =~ /^(?:cookie|[^\.]+\..*)$/
+                fail "'#{param_name}' is invalid"
+              end
+            end
+
+            it "doesn't have param values for capture params" do
+              if pos > 0 && !value.to_s.empty?
+                fail "'#{fp.name}'s #{param_name} is a non-zero pos but specifies a value of '#{value}'"
+              end
+            end
+
+            it "has parameter values other than General, Server or Unknown, which are not helpful" do
+              if pos == 0 && value =~ /^(?i:general|server|unknown)$/
+                fail "'#{param_name}' has general/server/unknown value '#{value}'"
+              end
+            end
+
+            it "doesn't omit values for non-capture params" do
+              if pos == 0 && value.to_s.empty?
+                fail "'#{fp.name}'s #{param_name} is not a capture (pos=0) but doesn't specify a value"
+              end
+            end
+
+            it "doesn't have duplicate params" do
+              if param_names.include?(param_name)
+                fail "'#{fp.name}'s has duplicate #{param_name}"
+              else
+                param_names << param_name
+              end
+            end
+
+            it "uses interpolation correctly" do
+              if pos == 0 && /\{(?<interpolated>[^\s{}]+)\}/ =~ value
+                unless fp.params.key?(interpolated)
+                  fail "'#{fp.name}' uses interpolated value '#{interpolated}' that does not exist"
+                end
+              end
+            end
+          end
+        end
+
+        context "#{fp.regex}" do
+
+          it "has a valid looking name" do
+            expect(fp.name).not_to be_nil
+            expect(fp.name).not_to be_empty
+          end
+
+          it "has a regex" do
+            expect(fp.regex).not_to be_nil
+            expect(fp.regex.class).to be ::Regexp
+          end
+
+          it 'uses capturing regular expressions properly' do
+            # the list of index-based captures that the fingerprint is expecting
+            expected_capture_positions = fp.params.values.map(&:first).map(&:to_i).select { |position| position > 0 }
+            if fp.params.empty? && expected_capture_positions.size > 0
+              fail "Non-asserting fingerprint with regex #{fp.regex} captures #{expected_capture_positions.size} time(s); 0 are needed"
+            else
+              # parse the regex and count the number of captures
+              actual_capture_positions = []
+              capture_number = 1
+              Regexp::Scanner.scan(fp.regex).each do |token_parts|
+                if token_parts.first == :group  && ![:close, :passive, :options, :options_switch].include?(token_parts[1])
+                  actual_capture_positions << capture_number
+                  capture_number += 1
+                end
+              end
+              # compare the captures actually performed to those being used and ensure that they contain
+              # the same elements regardless of order, preventing, over-, under- and other forms of mis-capturing.
+              actual_capture_positions = actual_capture_positions.sort.uniq
+              expected_capture_positions = expected_capture_positions.sort.uniq
+              expect(actual_capture_positions).to eq(expected_capture_positions),
+                "Regex has #{actual_capture_positions.size} capture groups, but the fingerprint expected #{expected_capture_positions.size} extractions."
+            end
+          end
+
+          # Not yet enforced
+          # it "has test cases" do
+          #  expect(fp.tests.length).not_to equal(0)
+          # end
+
+          it "Has a reasonable number (<= 20) of test cases" do
+            expect(fp.tests.length).to be <= 20
+          end
+
+          fp_examples = []
+          fp.tests.each do |example|
+            it "doesn't have a duplicate examples" do
+              if fp_examples.include?(example.content)
+                fail "'#{fp.name}' has duplicate example '#{example.content}'"
+              else
+                fp_examples << example.content
+              end
+            end
+            it "Example '#{example.content}' matches this regex" do
+              match = fp.match(example.content)
+              expect(match).to_not be_nil, 'Regex did not match'
+              # test any extractions specified in the example
+              example.attributes.each_pair do |k,v|
+                next if k == '_encoding'
+                expect(match[k]).to eq(v), "Regex didn't extract expected value for fingerprint attribute #{k} -- got #{match[k]} instead of #{v}"
+              end
+            end
+
+            it "Example '#{example.content}' matches this regex first" do
+              db.fingerprints.slice(0, i).each_index do |previous_i|
+                prev_fp = db.fingerprints[previous_i]
+                prev_fp.tests.each do |prev_example|
+                  match = prev_fp.match(example.content)
+                  expect(match).to be_nil, "Matched regex ##{previous_i} (#{db.fingerprints[previous_i].regex}) rather than ##{i} (#{db.fingerprints[i].regex})"
+                end
+              end
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/recog/db_spec.rb

@@ -0,0 +1,98 @@
+require 'recog/db'
+
+describe Recog::DB do
+  let(:xml_file) { File.expand_path File.join('spec', 'data', 'test_fingerprints.xml') }
+  subject { Recog::DB.new(xml_file) }
+
+  describe "#fingerprints" do
+    subject(:fingerprints) { described_class.new(xml_file).fingerprints }
+
+    it { is_expected.to be_a(Enumerable) }
+
+    context "with only a pattern" do
+      subject(:entry) { described_class.new(xml_file).fingerprints[0] }
+
+      it "has a blank name with no description" do
+        expect(entry.name).to be_empty
+      end
+
+      it "has a pattern" do
+        expect(entry.regex.source).to eq(".*\\(iSeries\\).*")
+      end
+
+      it "has no params" do
+        expect(entry.params).to be_empty
+      end
+
+      it "has no tests" do
+        expect(entry.tests).to be_empty
+      end
+    end
+
+    context "with params" do
+      subject(:entry) { described_class.new(xml_file).fingerprints[1] }
+
+      it "has a name" do
+        expect(entry.name).to eq('PalmOS')
+      end
+
+      it "has a pattern" do
+        expect(entry.regex.source).to eq(".*\\(PalmOS\\).*")
+      end
+
+      it "has params" do
+        expect(entry.params).to eq({"os.vendor"=>[1, "Palm"], "os.device"=>[2, "General"]})
+      end
+
+      it "has no tests" do
+        expect(entry.tests).to be_empty
+      end
+    end
+
+    context "with pattern flags" do
+      subject(:entry) { described_class.new(xml_file).fingerprints[2] }
+
+      it "has a name and only uses the first value" do
+        expect(entry.name).to eq('HP Designjet printer')
+      end
+
+      it 'creates a Regexp with expected flags' do
+        expect(entry.regex).to be_a(Regexp)
+        expect(entry.regex.options).to eq(Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::IGNORECASE)
+      end
+
+      it "has a pattern" do
+        expect(entry.regex).to be_a(Regexp)
+        expect(entry.regex.source).to eq("(designjet \\S+)")
+      end
+
+      it "has params" do
+        expect(entry.params).to eq({"service.vendor"=>[0, "HP"]})
+      end
+
+      it "has no tests" do
+        expect(entry.tests).to be_empty
+      end
+    end
+
+    context "with test" do
+      subject(:entry) { described_class.new(xml_file).fingerprints[3] }
+
+      it "has a name" do
+        expect(entry.name).to eq('HP JetDirect Printer')
+      end
+
+      it "has a pattern" do
+        expect(entry.regex.source).to eq("laserjet (.*)(?: series)?")
+      end
+
+      it "has params" do
+        expect(entry.params).to eq({"service.vendor"=>[0, "HP"]})
+      end
+
+      it "has no tests" do
+        expect(entry.tests.map(&:content)).to match_array(["HP LaserJet 4100 Series", "HP LaserJet 2200"])
+      end
+    end
+  end
+end

data/spec/lib/recog/fingerprint/regexp_factory_spec.rb

@@ -0,0 +1,73 @@
+
+require 'recog/fingerprint/regexp_factory'
+
+describe Recog::Fingerprint::RegexpFactory do
+
+  describe 'FLAG_MAP' do
+    subject { described_class::FLAG_MAP }
+
+    it "should have the right number of flags" do
+      expect(subject.size).to be 5
+    end
+  end
+
+  describe '.build' do
+    subject { described_class.build(pattern, options) }
+
+    let(:pattern) { 'Apache/(\d+)' }
+    let(:options) { [ 'REG_ICASE' ] }
+
+    it { is_expected.to be_a(Regexp) }
+    it { is_expected.to match('Apache/2') }
+
+  end
+
+  describe '.build_options' do
+    subject { described_class.build_options(flags) }
+
+    let(:flags) { [ ] }
+    it { is_expected.to be_a(Integer) }
+
+    context 'without any explicit flags' do
+      let(:flags) { [ ] }
+      specify "sets default flags" do
+        expect(subject).to be Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS
+      end
+    end
+
+    context 'with REG_ICASE' do
+      let(:flags) { [ 'REG_ICASE' ] }
+      specify "sets IGNORECASE" do
+        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::IGNORECASE)
+      end
+    end
+
+    context 'with REG_DOT_NEWLINE' do
+      let(:flags) { [ 'REG_DOT_NEWLINE' ] }
+      specify "sets MULTILINE" do
+        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE)
+      end
+    end
+
+    context 'with REG_LINE_ANY_CRLF' do
+      let(:flags) { [ 'REG_LINE_ANY_CRLF' ] }
+      specify "sets MULTILINE" do
+        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE)
+      end
+    end
+
+    context 'with multiple flags' do
+      let(:flags) { [ 'REG_LINE_ANY_CRLF', 'REG_ICASE' ] }
+      specify "sets correct flags" do
+        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE | Regexp::IGNORECASE)
+      end
+    end
+
+    context 'with invalid flags' do
+      let(:flags) { %w(SYN ACK FIN) } # oh, wrong flags!
+      specify 'raises and lists supported/unsupported flags' do
+        expect { subject }.to raise_error(/SYN,ACK,FIN. Must be one of: .+/)
+      end
+    end
+  end
+end

data/spec/lib/recog/fingerprint_spec.rb

@@ -0,0 +1,112 @@
+require 'nokogiri'
+require 'recog/fingerprint'
+
+describe Recog::Fingerprint do
+  context "whitespace" do
+    let(:xml) do
+      path = File.expand_path(File.join('spec', 'data', 'whitespaced_fingerprint.xml'))
+      doc = Nokogiri::XML(IO.read(path))
+      doc.xpath("//fingerprint").first
+    end
+    subject { Recog::Fingerprint.new(xml) }
+
+    describe "#name" do
+      it "properly squashes whitespace" do
+        expect(subject.name).to eq('I love whitespace!')
+      end
+    end
+  end
+
+  describe "#verification" do
+    let(:xml_file) { File.expand_path(File.join('spec', 'data', 'verification_fingerprints.xml')) }
+    let(:doc) { Nokogiri::XML(IO.read(xml_file)) }
+
+    context "0 params" do
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[0]) }
+
+      it "does not yield if a fingerprint has 0 parameters" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
+      end
+    end
+
+    context "0 capture groups" do
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[1]) }
+
+      it "does not yield if a fingerprint has parameters, but 0 are defined by a capture group " do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
+      end
+    end
+
+    context "0 examples" do
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[2]) }
+
+      it "does not yield if a fingerprint has 0 examples" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
+      end
+    end
+
+    context "1 capture group, 1 example" do
+
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[3]) }
+
+      it "does not yield when one capture group parameter is tested for in one example" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
+      end
+    end
+
+    context "2 capture groups, 1 example" do
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[4]) }
+
+      it "does not yield when two capture group parameters are tested for in one example" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
+      end
+    end
+
+    context "2 capture groups, 2 examples, 1 in each" do
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[5]) }
+
+      it "does not yield when two capture group parameters are tested for in two examples, one parameter in each" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
+      end
+    end
+
+    context "1 missing capture group, 1 example" do
+
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[6]) }
+
+      it "identifies when a parameter defined by a capture group is not included in one example" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:warn, String])
+      end
+    end
+
+    context "2 missing capture groups, 1 example" do
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[7]) }
+
+      it "identifies when two parameters defined by a capture groups are not included in one example" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:warn, String], [:warn, String])
+      end
+    end
+
+    context "1 missing capture group, 2 examples" do
+
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[8]) }
+
+      it "identifies when a parameter defined by a capture group is not included in one example" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:warn, String])
+      end
+    end
+
+    context "2 missing capture groups, 2 examples" do
+      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[9]) }
+
+      it "identifies when two parameters defined by a capture groups are not included in one example" do
+        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:warn, String], [:warn, String])
+      end
+    end
+
+  end
+
+  skip  "value interpolation" do
+    # TODO
+  end
+end