shadowbq-threatinator 0.5.0

data/spec/threatinator/parsers/xml/node_spec.rb

@@ -0,0 +1,335 @@
+require 'spec_helper'
+require 'threatinator/parsers/xml/node'
+require 'set'
+
+describe Threatinator::Parsers::XML::Node do
+  describe "initializing" do
+    describe "name" do
+      context "when a symbol is provided" do
+        specify "the name is the symbol" do
+          node = described_class.new(:foobar)
+          expect(node.name).to be(:foobar)
+        end
+      end
+      context "when a string is provided" do
+        specify "the name is the symbolized version of the string" do
+          node = described_class.new("foobar")
+          expect(node.name).to be(:foobar)
+        end
+      end
+      context "when it is neither a string nor a symbol" do
+        it "raises a TypeError" do
+          expect { described_class.new(Object.new) }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe ":text" do
+      context "when a string" do
+        specify "the text is the string" do
+          node = described_class.new(:foo, text: "hey there big boy")
+          expect(node.text).to eq("hey there big boy")
+        end
+      end
+
+      context "when nil" do
+        specify "the text is an empty string" do
+          node = described_class.new(:foo, text: nil)
+          expect(node.text).to eq("")
+        end
+      end
+
+      context "when not provided" do
+        specify "the text is an empty string" do
+          node = described_class.new(:foo)
+          expect(node.text).to eq("")
+        end
+      end
+      context "when something other than a string or nil" do
+        it "raises a TypeError" do
+          expect { described_class.new(:foo, text: Object.new) }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe ":attrs" do
+      context "when not provided" do
+        specify "the attrs are an empty hash" do
+          node = described_class.new(:foo)
+          expect(node.attrs).to eq({})
+        end
+      end
+      context "when nil" do
+        specify "the attrs are an empty hash" do
+          node = described_class.new(:foo, attrs: nil)
+          expect(node.attrs).to eq({})
+        end
+      end
+      context "when a hash of attributes" do
+        specify "the attrs are the provided attributes" do
+          node = described_class.new(:foo, attrs: {foo: "asdf", bar: "123"})
+          expect(node.attrs).to eq({foo:"asdf", bar:"123"})
+        end
+      end
+      context "when something other than a hash or nil" do
+        it "raises a TypeError" do
+          expect { described_class.new(:foo, attrs: Object.new) }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    describe ":children" do
+      context "when not provided" do
+        specify "it should have no children" do
+          node = described_class.new(:foo)
+          expect(node.children).to eq({})
+        end
+      end
+
+      context "when nil" do
+        specify "it should have no children" do
+          node = described_class.new(:foo, children: nil)
+          expect(node.children).to eq({})
+        end
+      end
+
+      context "when a collection of Nodes" do
+        specify "it should have all those nodes as children" do
+          children = build_list(:xml_node, 20, name: :bla)
+          node = described_class.new(:foo, children: children)
+          expect(node.num_children).to eq(20)
+          expect(node[:bla]).to match_array(children)
+        end
+      end
+    end
+  end
+
+  describe "#==" do
+    it "returns true when compared to itself" do
+      node = build(:xml_node)
+      expect(node).to be == node
+    end
+
+    it "returns true when compared an identically configured node" do
+      node1 = build(:xml_node)
+      node2 = build(:xml_node)
+      expect(node1).to be == node2
+    end
+
+    it "returns true when compared to an object that looks like the node" do
+      node1 = build(:xml_node)
+      node2 = build(:xml_node)
+      fake_node_class = Struct.new(:name, :attrs, :text, :children)
+      fake_node = fake_node_class.new(node2.name, node2.attrs, node2.text, node2.children)
+      expect(node1).to be == fake_node
+    end
+
+    it "returns false when the attributes are different" do
+      node1 = build(:xml_node, attrs: {attr1: "abc"} )
+      node2 = build(:xml_node, attrs: {attr1: "xyz"} )
+      expect(node1).not_to be == node2
+    end
+
+    it "returns false when the text is different" do
+      node1 = build(:xml_node, text: "abc")
+      node2 = build(:xml_node, text: "xyz")
+      expect(node1).not_to be == node2
+    end
+
+    it "returns false when the children are different" do
+      node1 = build(:xml_node, children: [build(:xml_node, name: "a", text: "123"), build(:xml_node, name: "b", text: "xyz")] )
+      node2 = build(:xml_node, children: [build(:xml_node, name: "a", text: "456"), build(:xml_node, name: "b", text: "abc")] )
+      expect(node1).not_to be == node2
+    end
+
+    it "returns false when the name is different" do
+      node1 = build(:xml_node, name: "foo")
+      node2 = build(:xml_node, name: "bar")
+      expect(node1).not_to be == node2
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true when compared to itself" do
+      node = build(:xml_node)
+      expect(node).to be_eql(node)
+    end
+
+    it "returns true when compared an identically configured node" do
+      node1 = build(:xml_node)
+      node2 = build(:xml_node)
+      expect(node1).to be_eql(node2)
+    end
+
+    it "returns false when compared to an object that looks like the node" do
+      node1 = build(:xml_node)
+      node2 = build(:xml_node)
+      fake_node_class = Struct.new(:name, :attrs, :text, :children)
+      fake_node = fake_node_class.new(node2.name, node2.attrs, node2.text, node2.children)
+      expect(node1).not_to be_eql(fake_node)
+    end
+
+    it "returns false when the attributes are different" do
+      node1 = build(:xml_node, attrs: {attr1: "abc"} )
+      node2 = build(:xml_node, attrs: {attr1: "xyz"} )
+      expect(node1).not_to be_eql(node2)
+    end
+
+    it "returns false when the text is different" do
+      node1 = build(:xml_node, text: "abc")
+      node2 = build(:xml_node, text: "xyz")
+      expect(node1).not_to be_eql(node2)
+    end
+
+    it "returns false when the children are different" do
+      node1 = build(:xml_node, children: [build(:xml_node, name: "a", text: "123"), build(:xml_node, name: "b", text: "xyz")] )
+      node2 = build(:xml_node, children: [build(:xml_node, name: "a", text: "456"), build(:xml_node, name: "b", text: "abc")] )
+      expect(node1).not_to be_eql(node2)
+    end
+
+    it "returns false when the name is different" do
+      node1 = build(:xml_node, name: "foo")
+      node2 = build(:xml_node, name: "bar")
+      expect(node1).not_to be_eql(node2)
+    end
+  end
+
+  describe "#equal?" do
+    it "returns true tested against itself" do
+      node = build(:xml_node)
+      expect(node).to be_equal(node)
+    end
+    it "returns true when compared an identically configured node" do
+      node = build(:xml_node)
+      node2 = build(:xml_node)
+      expect(node).not_to be_equal(node2)
+    end
+  end
+
+  describe "#children" do
+    let(:children) { [] }
+    let(:node) { build(:xml_node, children: children) }
+
+    it "returns a Hash" do
+      expect(node.children).to be_a(Hash)
+    end
+
+    it "is empty when there are no children" do
+      expect(node.children).to be_empty
+    end
+
+    context "with children" do
+      let(:children) {
+        [
+          build(:xml_node, name: "a", text: "1"),
+          build(:xml_node, name: "a", text: "2"),
+          build(:xml_node, name: "b", text: "3"),
+          build(:xml_node, name: "c", text: "4")
+        ]
+      }
+
+      specify "the keys are all symbols" do
+        expect(node.children.keys).to contain_exactly(kind_of(Symbol), kind_of(Symbol), kind_of(Symbol))
+      end
+      specify "the keys are names of the children" do
+        expect(node.children.keys).to contain_exactly(:a, :b, :c)
+      end
+
+      specify "the corresponding values are collections of the child nodes" do
+        expect(node.children[:a]).to contain_exactly(
+          build(:xml_node, name: "a", text: "1"), 
+          build(:xml_node, name: "a", text: "2"))
+        expect(node.children[:b]).to contain_exactly(
+          build(:xml_node, name: "b", text: "3"))
+        expect(node.children[:c]).to contain_exactly(
+          build(:xml_node, name: "c", text: "4"))
+      end
+    end
+  end
+
+  describe "#[]" do
+    it "returns an empty array if there are no child elements for the given name" do
+      node = build(:xml_node)
+      expect(node[:foo]).to eq([])
+    end
+
+    it "returns an array the matching child nodes in the order in which they were added" do
+      child1 = build(:xml_node, name: :woof)
+      child2 = build(:xml_node, name: :woof)
+      child3 = build(:xml_node, name: :woof)
+      child4 = build(:xml_node, name: :bark)
+      child5 = build(:xml_node, name: :bark)
+      child6 = build(:xml_node, name: :bark)
+      node = build(:xml_node, children: [child1, child4, child2, child5, child3, child6])
+      children = node[:woof]
+      expect(children[0]).to be(child1)
+      expect(children[1]).to be(child2)
+      expect(children[2]).to be(child3)
+    end
+
+    it "accepts either a String or a Symbol, treating them equally" do
+      child = build(:xml_node, name: :moo)
+      node = build(:xml_node, children: [ child ])
+      expect(node[:moo]).to eq([child])
+      expect(node["moo"]).to eq([child])
+    end
+  end
+
+  describe "#child_names" do
+    context "with no children" do
+      it "returns an empty array" do
+        node = build(:xml_node)
+        expect(node.child_names).to eq([])
+      end
+    end
+    context "with children" do
+      it "returns an array of symbols for all the names of the child elements" do
+        children = [
+          build(:xml_node, name: :a),
+          build(:xml_node, name: :a),
+          build(:xml_node, name: :b),
+          build(:xml_node, name: :b),
+          build(:xml_node, name: :c),
+          build(:xml_node, name: :c)
+        ]
+        node = build(:xml_node, children: children)
+        expect(node.child_names).to contain_exactly(:a, :b, :c)
+      end
+    end
+  end
+
+  describe "#num_children" do
+    context "with no children" do
+      let(:node) { build(:xml_node) }
+      it "returns 0" do
+        expect(node.num_children).to eq(0)
+      end
+    end
+
+    context "with a bunch of children added" do
+      let(:node) { build(:xml_node, children: children) }
+      let(:children) { build_list(:xml_node, 50) }
+      it "returns the total number of children" do
+        expect(node.num_children).to eq(50)
+      end
+    end
+  end
+
+  describe "#text" do
+    it "returns an empty string when the node has no text" do
+      node = build(:xml_node)
+      expect(node.text).to eq("")
+    end
+
+    it "returns the string of text assigned to the node" do
+      node = build(:xml_node, text: "hey there big boy")
+      expect(node.text).to eq("hey there big boy")
+    end
+  end
+  describe "#name" do
+    it "it returns the name of the node as a symbol" do
+      node = build(:xml_node, name: :foobar)
+      expect(node.name).to be(:foobar)
+    end
+  end
+end

data/spec/threatinator/parsers/xml/parser_spec.rb

@@ -0,0 +1,263 @@
+require 'spec_helper'
+require 'threatinator/parsers/xml'
+require 'threatinator/parsers/xml/pattern'
+
+describe Threatinator::Parsers::XML::Parser, :parser do
+  context "two instances with identically configured patterns" do
+    it_should_behave_like "a parser when compared to an identically configured parser" do
+      let(:pattern1) { Threatinator::Parsers::XML::Pattern.new('/foo/bar') }
+      let(:pattern2) { Threatinator::Parsers::XML::Pattern.new('/foo/bar') }
+      let(:parser1) { described_class.new(pattern: pattern1) }
+      let(:parser2) { described_class.new(pattern: pattern2) }
+    end
+  end
+
+  context "two instances with differently configured patterns" do
+    it_should_behave_like "a parser when compared to a differently configured parser" do
+      let(:pattern1) { Threatinator::Parsers::XML::Pattern.new('/foo/bar') }
+      let(:pattern2) { Threatinator::Parsers::XML::Pattern.new('//foo/bar') }
+      let(:parser1) { described_class.new(pattern: pattern1) }
+      let(:parser2) { described_class.new(pattern: pattern2) }
+    end
+  end
+
+  shared_examples_for "an XML::Record" do
+    it { is_expected.to be_a(Threatinator::Parsers::XML::Record) }
+    its(:node) { is_expected.to be_a(Threatinator::Parsers::XML::Node) }
+  end
+
+
+  shared_examples_for "a parser matching nothing" do
+    it "should yield 0 records" do
+      expect(records.count).to eq(0)
+    end
+  end # 
+
+  shared_context "parsing xml" do
+    let(:io) { StringIO.new(xml) }
+    let(:parser) { described_class.new(pattern: pattern) }
+    let!(:records) { 
+      ret = []
+      parser.run(io) { |r| ret << r }
+      ret
+    }
+  end
+
+  context "parsing records from test_self_closing.xml" do
+    let(:xml) { File.read(parser_data('test_self_closing.xml')) } 
+    include_context "parsing xml"
+
+    shared_examples_for "a parser matching each 'z' element" do
+      it "should yield 4 records" do
+        expect(records.count).to eq(4)
+      end
+
+      describe "record 0" do
+        let(:record) { records[0] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:z) }
+          its(:attrs) { is_expected.to eq({foo: "bar1"}) }
+          its(:text) { is_expected.to eq("") }
+        end
+      end
+      describe "record 1" do
+        let(:record) { records[1] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:z) }
+          its(:attrs) { is_expected.to eq({foo: "bar2"}) }
+          its(:text) { is_expected.to eq("") }
+        end
+      end
+      describe "record 2" do
+        let(:record) { records[2] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:z) }
+          its(:attrs) { is_expected.to eq({foo: "bar3"}) }
+          its(:text) { is_expected.to eq("")}
+        end
+      end
+      describe "record 3" do
+        let(:record) { records[3] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:z) }
+          its(:attrs) { is_expected.to eq({foo: "bar4"}) }
+          its(:text) { is_expected.to eq("")}
+        end
+      end
+    end # 
+
+    context "with the pattern '/doc/x/y/z'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("/doc/x/y/z") }
+      it_should_behave_like "a parser matching each 'z' element"
+    end
+
+    context "with the pattern '//x/y/z'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("//x/y/z") }
+      it_should_behave_like "a parser matching each 'z' element"
+    end
+
+    context "with the pattern '//z'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("//z") }
+      it_should_behave_like "a parser matching each 'z' element"
+    end
+
+
+    context "with the pattern '/y/z/x'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("/y/z/x") }
+      it_should_behave_like "a parser matching nothing"
+    end
+  end
+
+  context "parsing records from test.xml" do
+    let(:xml) { File.read(parser_data('test.xml')) } 
+    include_context "parsing xml"
+
+    shared_examples_for "a parser matching each 'b' element" do
+      it "should yield 2 records" do
+        expect(records.count).to eq(2)
+      end
+
+      describe "record 0" do
+        let(:record) { records[0] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:b) }
+          its(:attrs) { is_expected.to eq({}) }
+          its(:text) { is_expected.to eq("")}
+          its(:children) { 
+            is_expected.to match(
+              {
+                c: a_collection_containing_exactly(
+                  build(:xml_node, name: 'c', text: 'deep1A'),
+                  build(:xml_node, name: 'c', text: 'deep1B')
+                )
+              }
+            )
+          }
+        end
+      end
+      describe "record 1" do
+        let(:record) { records[1] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:b) }
+          its(:attrs) { is_expected.to eq({}) }
+          its(:text) { is_expected.to eq("")}
+          its(:children) { 
+            is_expected.to match(
+              {
+                c: a_collection_containing_exactly(
+                  build(:xml_node, name: 'c', text: 'deep2A'),
+                  build(:xml_node, name: 'c', text: 'deep2B')
+                )
+              }
+            )
+          }
+        end
+      end
+    end # 
+
+    shared_examples_for "a parser matching each 'c' element" do
+      it "should yield 4 records" do
+        expect(records.count).to eq(4)
+      end
+
+      describe "record 0" do
+        let(:record) { records[0] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:c) }
+          its(:attrs) { is_expected.to eq({}) }
+          its(:text) { "deep1A" }
+        end
+      end
+      describe "record 1" do
+        let(:record) { records[1] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:c) }
+          its(:attrs) { is_expected.to eq({}) }
+          its(:text) { "deep1B" }
+        end
+      end
+      describe "record 2" do
+        let(:record) { records[2] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:c) }
+          its(:attrs) { is_expected.to eq({}) }
+          its(:text) { "deep2A" }
+        end
+      end
+      describe "record 3" do
+        let(:record) { records[3] }
+        let(:node) { record.node }
+        subject { record }
+        it_should_behave_like "an XML::Record"
+        describe "the data from the node" do
+          subject { node } 
+          its(:name) { is_expected.to eq(:c) }
+          its(:attrs) { is_expected.to eq({}) }
+          its(:text) { "deep2B" }
+        end
+      end
+    end # 
+
+    context "with the pattern '/doc/a/b/c'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("/doc/a/b/c") }
+      it_should_behave_like "a parser matching each 'c' element"
+    end
+
+
+    context "with the pattern '//a/b/c'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("//a/b/c") }
+      it_should_behave_like "a parser matching each 'c' element"
+    end
+
+    context "with the pattern '//b'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("//b") }
+      it_should_behave_like "a parser matching each 'b' element"
+    end
+
+    context "with the pattern '//c'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("//a/b/c") }
+      it_should_behave_like "a parser matching each 'c' element"
+    end
+
+    context "with the pattern '/c/b/a'" do
+      let(:pattern) { Threatinator::Parsers::XML::Pattern.new("/c/b/a") }
+      it_should_behave_like "a parser matching nothing"
+    end
+  end
+end