threatinator 0.1.1

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

@@ -0,0 +1,209 @@
+require 'spec_helper'
+require 'threatinator/parsers/xml/path'
+
+describe Threatinator::Parsers::XML::Path do
+
+  describe 'initializing' do
+    context "with str_or_parts not set" do
+      let (:path) { described_class.new() }
+      describe "#parts" do
+        specify "returns an empty array" do
+          expect(path.parts).to eq([])
+        end
+      end
+    end
+
+    context "with str_or_parts set to a String" do
+      let (:path) { described_class.new('/a/b/c') }
+      describe "#parts" do
+        specify "returns the string split by '/'" do
+          expect(path.parts).to eq(['a', 'b', 'c'])
+        end
+      end
+      it "raises ArgumentError when the string doesn't begin with '/'" do
+        expect {
+          described_class.new("a/b/c")
+        }.to raise_error(ArgumentError)
+      end
+      it "raises ArgumentError when the string is empty" do
+        expect {
+          described_class.new("")
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with str_or_parts set to nil" do
+      let (:path) { described_class.new(nil) }
+      describe "#parts" do
+        specify "returns an empty array" do
+          expect(path.parts).to eq([])
+        end
+      end
+    end
+
+    context "with str_or_parts set to an array" do
+      let(:array) { ['a', 'b', 'c'] }
+      let(:path) { described_class.new(array) }
+      describe "#parts" do
+        specify "returns an array that =='s the original array" do
+          expect(path.parts).to eq(array)
+        end
+        specify "returns a different array instance than the original array" do
+          expect(path.parts).not_to equal(array)
+        end
+      end
+    end
+
+    it "raises TypeError when path_or_str is set to something other than a String, Array, or nil" do
+      expect {
+        described_class.new(1234)
+      }.to raise_error(TypeError)
+    end
+  end
+
+  describe "#==" do
+    it "returns true when testing against itself" do
+      path = described_class.new('/a/b/c')
+      expect(path).to be == path
+    end
+    it "returns true when testing another path with the same parts" do
+      path = described_class.new('/a/b/c')
+      path2 = described_class.new(['a', 'b', 'c'])
+      expect(path).to be == path2
+    end
+    it "returns true when testing an object that responds to #parts with the same values" do
+      path = described_class.new('/a/b/c')
+      object = Class.new do
+        def parts
+          ['a', 'b', 'c']
+        end
+      end.new
+      expect(path).to be == object
+    end
+    it "returns false when testing an object that responds to #parts with different values" do
+      path = described_class.new('/a/b/c')
+      object = Class.new do
+        def parts
+          ['a', 'b', 'c', 'd']
+        end
+      end.new
+      expect(path).not_to be == object
+    end
+    it "returns false when testing against another path with different parts" do
+      path = described_class.new('/a/b/c')
+      path2 = described_class.new('/a/b/c/e')
+      expect(path).not_to be == path2
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true when testing against itself" do
+      path = described_class.new('/a/b/c')
+      expect(path).to eql path
+    end
+    it "returns true when testing another path with the same parts" do
+      path = described_class.new('/a/b/c')
+      path2 = described_class.new(['a', 'b', 'c'])
+      expect(path).to eql path2
+    end
+    it "returns false when testing against another path with different parts" do
+      path = described_class.new('/a/b/c')
+      path2 = described_class.new('/a/b/c/e')
+      expect(path).not_to eql path2
+    end
+    it "returns false when testing an object that responds to #parts with the same values" do
+      path = described_class.new('/a/b/c')
+      object = Class.new do
+        def parts
+          ['a', 'b', 'c']
+        end
+      end.new
+      expect(path).not_to eql object
+    end
+    it "returns false when testing against something that is not a Path" do
+      path = described_class.new('/a/b/c')
+      path2 = "hi there"
+      expect(path).not_to eql path2
+    end
+  end
+
+  describe "#end_with?" do
+    let(:path) { described_class.new('/a/b/c') }
+
+    it "returns true when testing against itself" do
+      expect(path.end_with?(path)).to eq(true)
+    end
+    it "returns true when testing against an identical path" do
+      path2 = described_class.new('/a/b/c')
+      expect(path.end_with?(path2)).to eq(true)
+    end
+
+    it "returns true when tested against any path that it happens to end with" do
+      expect(path.end_with?(described_class.new('/b/c'))).to eq(true)
+      expect(path.end_with?(described_class.new('/c'))).to eq(true)
+    end
+
+    it "returns true when tested against a path with no length" do
+      expect(path.end_with?(described_class.new('/'))).to eq(true)
+    end
+
+    it "returns false when tested against a path that is longer than itself" do
+      expect(path.end_with?(described_class.new('/a/a/b/c'))).to eq(false)
+    end
+
+    it "returns false when tested against a path it does not end with" do
+      expect(path.end_with?(described_class.new('/a'))).to eq(false)
+      expect(path.end_with?(described_class.new('/a/b'))).to eq(false)
+      expect(path.end_with?(described_class.new('/b'))).to eq(false)
+    end
+  end
+
+  describe "#push" do
+    let(:path) { described_class.new }
+    it "adds a new entry to the end of the #parts" do
+      path.push('a')
+      expect(path.parts).to eq(['a'])
+      path.push('b')
+      expect(path.parts).to eq(['a', 'b'])
+      path.push('c')
+      expect(path.parts).to eq(['a', 'b', 'c'])
+    end
+  end
+
+  describe "#pop" do
+    let(:path) { described_class.new('/a/b/c') }
+    it "appends a new entry to the end of the #parts" do
+      expect(path.parts).to eq(['a', 'b', 'c'])
+      path.pop()
+      expect(path.parts).to eq(['a', 'b'])
+      path.pop()
+      expect(path.parts).to eq(['a'])
+      path.pop()
+      expect(path.parts).to eq([])
+    end
+
+    it "returns the value popped off the end of the parts" do
+      expect(path.pop()).to eq('c')
+      expect(path.pop()).to eq('b')
+      expect(path.pop()).to eq('a')
+    end
+
+    it "returns nil if there are no parts" do
+      path.pop(); path.pop(); path.pop();
+      expect(path.pop()).to be_nil
+    end
+  end
+
+  describe "#length" do
+    let(:path) { described_class.new('/a/b/c') }
+    it "returns the number of parts" do
+      expect(path.length).to eq(3)
+      10.times { path.push('Z') }
+      expect(path.length).to eq(13)
+      20.times { path.pop() }
+      expect(path.length).to eq(0)
+    end
+  end
+end
+
+

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

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'threatinator/parsers/xml/pattern'
+
+describe Threatinator::Parsers::XML::Pattern do
+
+  context "when initialized with" do
+    let(:pattern) { described_class.new(pathspec) }
+
+    context "pathspec: '/a/b/c'" do
+      let(:pathspec) { '/a/b/c' }
+      describe "#max_depth" do
+        it "returns 3" do
+          expect(pattern.max_depth).to eq(3)
+        end
+      end
+      describe "#match?" do
+        it "returns true for the path '/a/b/c'" do
+          path = Threatinator::Parsers::XML::Path.new('/a/b/c')
+          expect(pattern.match?(path)).to eq(true)
+        end
+        it "returns false for the path '/a/b/c/d'" do
+          path = Threatinator::Parsers::XML::Path.new('/a/b/c/d')
+          expect(pattern.match?(path)).to eq(false)
+        end
+        it "returns false for the path '/a/b/cd'" do
+          path = Threatinator::Parsers::XML::Path.new('/a/b/cd')
+          expect(pattern.match?(path)).to eq(false)
+        end
+        it "returns false for the path '/a/b'" do
+          path = Threatinator::Parsers::XML::Path.new('/a/b')
+          expect(pattern.match?(path)).to eq(false)
+        end
+      end
+    end
+
+    context "pathspec: '//b/c'" do
+      let(:pathspec) { '//b/c' }
+      describe "#max_depth" do
+        it "returns Infinity" do
+          expect(pattern.max_depth).to eq(Float::INFINITY)
+        end
+      end
+      describe "#match?" do
+        it "returns true for the path '/a/b/c'" do
+          path = Threatinator::Parsers::XML::Path.new('/a/b/c')
+          expect(pattern.match?(path)).to eq(true)
+        end
+        it "returns true for the path '/b/c'" do
+          path = Threatinator::Parsers::XML::Path.new('/b/c')
+          expect(pattern.match?(path)).to eq(true)
+        end
+        it "returns true for the path '/a/a/a/a/a/a/a/a/b/c'" do
+          path = Threatinator::Parsers::XML::Path.new('/a/a/a/a/a/a/a/a/b/c')
+          expect(pattern.match?(path)).to eq(true)
+        end
+        it "returns false for the path '/a/b'" do
+          path = Threatinator::Parsers::XML::Path.new('/a/b')
+          expect(pattern.match?(path)).to eq(false)
+        end
+      end
+    end
+
+    context "pathspec: '///c'" do
+      let(:pathspec) { '///c' }
+      it "should raise an ArgumentError" do
+        expect {
+          pattern
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'threatinator/parsers/xml/record'
+
+describe Threatinator::Parsers::XML::Record do
+  it_should_behave_like 'a record' do
+    let(:data) { 
+      Threatinator::Parsers::XML::Node.new('foo', text: 'bar')
+    }
+    let(:opts) { { } }
+  end
+
+  context "two instances with different data" do
+    it_should_behave_like 'a record when compared to a differently configured record' do
+      let(:data) { 
+        Threatinator::Parsers::XML::Node.new('foo', text: 'bar')
+      }
+      let(:opts) { { } }
+
+      let(:data2) { 
+        Threatinator::Parsers::XML::Node.new('foo', text: 'bar2')
+      }
+      let(:opts2) { {} }
+    end
+  end
+end
+
+

data/spec/threatinator/plugin_loader_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+require 'threatinator/plugin_loader'
+
+shared_context "good test plugins" do
+  before :all do
+    @good_plugin_path = PLUGIN_FIXTURES.join("good").to_s
+    $:.unshift @good_plugin_path
+  end
+
+  after :all do
+    $:.delete_if {|x| x == @good_plugin_path}
+  end
+end
+
+shared_context "bad test plugins" do
+  before :all do
+    @bad_plugin_path = PLUGIN_FIXTURES.join("bad").to_s
+    $:.unshift @bad_plugin_path
+  end
+
+  after :all do
+    $:.delete_if {|x| x == @bad_plugin_path}
+  end
+end
+
+describe Threatinator::PluginLoader do
+  include_context "good test plugins"
+
+  let(:loader) { described_class.new }
+
+  describe "#load_all_plugins" do
+    it "returns itself" do
+      expect(loader.load_all_plugins).to be(loader)
+    end
+
+    it "loads all plugins found in the $LOAD_PATH" do
+      loader.load_all_plugins
+      expect(loader.each(:test_type1).map {|*args| args }).to contain_exactly(
+        [:test_type1, :plugin_a, Threatinator::Plugins::TestType1::PluginA], 
+        [:test_type1, :plugin_b, Threatinator::Plugins::TestType1::PluginB])
+      expect(loader.each(:test_type2).map {|*args| args }).to contain_exactly(
+        [:test_type2, :plugin_c, Threatinator::Plugins::TestType2::PluginC], 
+        [:test_type2, :plugin_d, Threatinator::Plugins::TestType2::PluginD])
+      expect(loader.each(:test_type3).map {|*args| args }).to contain_exactly(
+        [:test_type3, :plugin_e, Threatinator::Plugins::TestType3::PluginE], 
+        [:test_type3, :plugin_f, Threatinator::Plugins::TestType3::PluginF])
+    end
+  end
+
+  describe "#load_plugins" do
+    it "returns itself" do
+      expect(loader.load_plugins(:test_type1)).to be(loader)
+    end
+
+    it "loads all plugins found in the $LOAD_PATH that are of the specified type" do
+      expect { |b| loader.each(:test_type1, &b) }.not_to yield_control
+      expect { |b| loader.each(:test_type2, &b) }.not_to yield_control
+      expect { |b| loader.each(:test_type3, &b) }.not_to yield_control
+
+      loader.load_plugins(:test_type1)
+      expect(loader.each(:test_type1).map {|*args| args }).to contain_exactly(
+        [:test_type1, :plugin_a, Threatinator::Plugins::TestType1::PluginA], 
+        [:test_type1, :plugin_b, Threatinator::Plugins::TestType1::PluginB])
+
+      expect { |b| loader.each(:test_type2, &b) }.not_to yield_control
+      expect { |b| loader.each(:test_type3, &b) }.not_to yield_control
+
+
+      loader.load_plugins(:test_type2)
+      expect(loader.each(:test_type1).map {|*args| args }).to contain_exactly(
+        [:test_type1, :plugin_a, Threatinator::Plugins::TestType1::PluginA], 
+        [:test_type1, :plugin_b, Threatinator::Plugins::TestType1::PluginB])
+      expect(loader.each(:test_type2).map {|*args| args }).to contain_exactly(
+        [:test_type2, :plugin_c, Threatinator::Plugins::TestType2::PluginC], 
+        [:test_type2, :plugin_d, Threatinator::Plugins::TestType2::PluginD])
+      expect { |b| loader.each(:test_type3, &b) }.not_to yield_control
+
+
+      loader.load_plugins(:test_type3)
+      expect(loader.each(:test_type1).map {|*args| args }).to contain_exactly(
+        [:test_type1, :plugin_a, Threatinator::Plugins::TestType1::PluginA], 
+        [:test_type1, :plugin_b, Threatinator::Plugins::TestType1::PluginB])
+      expect(loader.each(:test_type2).map {|*args| args }).to contain_exactly(
+        [:test_type2, :plugin_c, Threatinator::Plugins::TestType2::PluginC], 
+        [:test_type2, :plugin_d, Threatinator::Plugins::TestType2::PluginD])
+      expect(loader.each(:test_type3).map {|*args| args }).to contain_exactly(
+        [:test_type3, :plugin_e, Threatinator::Plugins::TestType3::PluginE], 
+        [:test_type3, :plugin_f, Threatinator::Plugins::TestType3::PluginF])
+    end
+
+    context "when loading a plugin raises an exception" do
+      include_context "bad test plugins"
+      it "raises that error upward" do
+        expect {
+          loader.load_plugins(:test_error1)
+        }.to raise_error()
+      end
+    end
+
+    context "when a plugin class cannot be found" do
+      include_context "bad test plugins"
+      it "raises a PluginLoadError" do
+        expect {
+          loader.load_plugins(:test_missing1)
+        }.to raise_error(Threatinator::Exceptions::PluginLoadError)
+      end
+    end
+  end
+
+  describe "#split_file_name" do
+    it "returns nil if the file name is not formed like 'threatinator/plugins/<type>/<name>.rb'" do
+
+      expect(loader.send(:split_file_name, File.join("foobar", "threatinator", "plugins", "type", "bla", "name.rb"))).to be_nil
+      expect(loader.send(:split_file_name, File.join("plugins", "type", "name.rb"))).to be_nil
+      expect(loader.send(:split_file_name, File.join("type", "name.rb"))).to be_nil
+      expect(loader.send(:split_file_name, "name.rb")).to be_nil
+
+    end
+
+    it "returns an array of the requirable path, plugin type, and plugin name" do
+
+      file_name = File.join("foobar", "threatinator", "plugins", "type", "name.rb")
+      expect(loader.send(:split_file_name, file_name)).to eq(['threatinator/plugins/type/name', 'type', 'name'])
+    end
+
+    FILE_NAME1 = File.join("threatinator", "plugins", "some_type", "some_name.rb")
+    FILE_NAME2 = File.join("foo", "bar", "lib", "threatinator", "plugins", "some_type", "some_name.rb")
+
+    shared_examples_for "simple split_file_name example" do
+      it { should eq([File.join("threatinator", "plugins", "some_type", "some_name"), "some_type", "some_name"]) }
+    end
+    describe "the return of split_file_name('#{FILE_NAME1}')" do
+      subject { loader.send(:split_file_name, FILE_NAME1) }
+      include_examples "simple split_file_name example" 
+    end
+
+    describe "the return of split_file_name('#{FILE_NAME2}')" do
+      subject { loader.send(:split_file_name, FILE_NAME2) }
+      include_examples "simple split_file_name example" 
+    end
+  end
+
+  describe "#types" do
+    context "when no plugins have been loaded" do
+      it "returns an empty array" do
+        expect(loader.types).to eq([])
+      end
+    end
+
+    context "when some plugins have been loaded" do
+      it "returns an array of type names (in symbol form)" do
+        loader.load_plugins(:test_type1)
+        loader.load_plugins(:test_type2)
+        loader.load_plugins(:test_type3)
+        expect(loader.types).to match_array([:test_type1, :test_type2, :test_type3])
+      end
+    end
+  end
+
+  describe "#get(type, name)" do
+    context "when there are no plugins for the specified type" do
+      it "returns nil" do
+        expect(loader.get(:test_type1, :name)).to be_nil
+      end
+    end
+
+    context "when there are plugins for the specified type" do
+      context "when a plugin does not exist for the specified name" do
+        it "returns nil" do
+          loader.load_plugins(:test_type1)
+          expect(loader.get(:test_type1, :foobar)).to be_nil
+        end
+      end
+
+      context "when a plugin does exist for the specified name" do
+        it "returns the plugin" do
+          loader.load_plugins(:test_type1)
+          expect(loader.get(:test_type1, :plugin_a)).to eq(Threatinator::Plugins::TestType1::PluginA)
+        end
+      end
+    end
+  end
+
+  describe "#each" do
+    context "when there are no plugins loaded" do
+      it "doesn't yield anything" do
+        expect { |b|
+          loader.each(&b)
+        }.not_to yield_control
+      end
+    end
+
+    context "when there plugins loaded" do
+      it "yields the type, name, and plugin for all plugins" do
+        loader.load_plugins(:test_type1)
+        loader.load_plugins(:test_type2)
+        loader.load_plugins(:test_type3)
+
+        data = []
+        loader.each do |type, name, plugin|
+          data << [type, name, plugin]
+        end
+        expect(data).to contain_exactly(
+          [:test_type1, :plugin_a, Threatinator::Plugins::TestType1::PluginA],
+          [:test_type1, :plugin_b, Threatinator::Plugins::TestType1::PluginB],
+          [:test_type2, :plugin_c, Threatinator::Plugins::TestType2::PluginC], 
+          [:test_type2, :plugin_d, Threatinator::Plugins::TestType2::PluginD],
+          [:test_type3, :plugin_e, Threatinator::Plugins::TestType3::PluginE], 
+          [:test_type3, :plugin_f, Threatinator::Plugins::TestType3::PluginF]
+        )
+      end
+    end
+  end
+
+  describe "#each(type)" do
+    context "when there are no plugins for the specified type" do
+      it "doesn't yield anything" do
+        expect { |b|
+          loader.each(:foobar, &b)
+        }.not_to yield_control
+      end
+    end
+
+    context "when there are plugins for the specified type" do
+      it "yields the type, name, and plugin for each plugin of the specified type" do
+        loader.load_plugins(:test_type1)
+        data = []
+        loader.each(:test_type1) do |type, name, plugin|
+          data << [type, name, plugin]
+        end
+        expect(data).to contain_exactly(
+          [ :test_type1, :plugin_a, Threatinator::Plugins::TestType1::PluginA],
+          [ :test_type1, :plugin_b, Threatinator::Plugins::TestType1::PluginB]
+        )
+      end
+    end
+  end
+end