shadowbq-threatinator 0.5.0

data/spec/support/shared/feeds.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+require 'threatinator/feed_builder'
+require 'threatinator/feed_runner'
+require 'threatinator/plugins/output/null'
+require 'pathname'
+
+shared_context 'a parsed record' do
+  # Expects :observer
+  before :each do
+    @record, @status, @events = observer.first
+  end
+  let(:record) { @record }
+  let(:events) { @events }
+  let(:status) { @status }
+end
+
+shared_context 'a parsed feed' do 
+  # expects :observer
+  let(:events) { observer.events }
+  let(:records) { observer.records }
+  let(:num_records) { observer.count }
+  let(:num_records_filtered) { observer.num_records_filtered }
+  let(:num_records_parsed) { observer.num_records_parsed }
+  let(:num_records_missed) { observer.num_records_missed }
+  let(:num_records_errored) { observer.num_records_errored }
+
+  it "should have 0 error records" do
+    expect(num_records_errored).to eq(0)
+  end
+
+  it "should have missed 0 records" do
+    expect(num_records_missed).to eq(0)
+  end
+end
+
+shared_context 'for feeds', :feed => lambda { true } do
+  _feed_path = Pathname.new(self.description)
+  if _feed_path.relative?
+    # It's relative to the root of our project.
+   _feed_path = PROJECT_ROOT + _feed_path 
+  end
+  _feed_path = _feed_path.expand_path
+
+  before :all do
+    @feed_builder = Threatinator::FeedBuilder.from_file(_feed_path.to_s)
+  end
+
+  let(:feed_path) { feed_path.to_s }
+  let(:output_formatter) { Threatinator::Plugins::Output::Null.new(Threatinator::Plugins::Output::Null::Config.new) }
+  let(:feed_runner) { Threatinator::FeedRunner.new(feed, output_formatter) }
+  let(:feed) { @feed_builder.build() }
+end
+
+shared_examples_for 'any feed', :feed do
+  # Expects :provider, :name, :feed
+  subject { feed } 
+  it { should be_a(Threatinator::Feed) }
+
+  describe "#provider" do
+    subject { feed.provider }
+    it { is_expected.to be_a(::String) }
+    it { is_expected.to eq(provider) }
+  end
+
+  describe "#name" do
+    subject { feed.name}
+    it { is_expected.to be_a(::String) }
+    it { is_expected.to eq(name) }
+  end
+
+  describe "#parser_block" do
+    subject { feed.parser_block }
+    it { is_expected.to be_a(::Proc) }
+  end
+
+  describe "#fetcher_builder" do
+    subject { feed.fetcher_builder }
+    it { is_expected.to be_a ::Proc }
+    specify "when called, it should generate a kind of Threatinator::Fetcher" do
+      expect(subject.call).to be_kind_of(Threatinator::Fetcher)
+    end
+  end
+
+  describe "#parser_builder" do
+    subject { feed.parser_builder }
+    it { is_expected.to be_a ::Proc }
+
+    specify "when called, it should generate a kind of Threatinator::Parser" do
+      expect(subject.call).to be_kind_of(Threatinator::Parser)
+    end
+  end
+
+  describe "#filter_builders" do
+    subject { feed.filter_builders }
+
+    it "should be an Array of Proc objects" do
+      expect(subject).to be_an ::Array
+    end
+
+    specify "each Proc, when called, should generate an object that responds to :filter?" do
+      subject.each do |filter_builder|
+        expect(filter_builder.call).to respond_to(:filter?)
+      end
+    end
+  end
+
+  describe "#decoder_builders" do
+    subject { feed.decoder_builders }
+
+    it "should be an Array of Proc objects" do
+      expect(subject).to be_an ::Array
+    end
+
+    specify "each Proc, when called, should generate a kind of Threatinator::Decoder" do
+      subject.each do |decoder_builder|
+        expect(decoder_builder.call).to be_kind_of(Threatinator::Decoder)
+      end
+    end
+  end
+end
+
+module FeedHelpers
+  class FeedRunnerObserver
+    include Enumerable
+    attr_reader :records, :statuses, :events, :num_records_filtered, 
+      :num_records_missed, :num_records_parsed, :num_records_errored
+
+    def initialize
+      @records = []
+      @statuses = []
+      @events = []
+      @num_records_filtered = 0
+      @num_records_parsed = 0
+      @num_records_missed = 0
+      @num_records_errored = 0
+    end
+
+    def each
+      @records.each_with_index do |record, i|
+        yield(record, @statuses[i], @events[i])
+      end
+    end
+
+    # Handles FeedRunner observations
+    def update(message, *args)
+      case message
+      when :record_missed
+        @records << args.shift
+        @statuses << :missed
+        @events << []
+        @num_records_missed += 1
+      when :record_filtered
+        @records << args.shift
+        @statuses << :filtered
+        @events << []
+        @num_records_filtered += 1
+      when :record_parsed
+        @records << args.shift
+        @statuses << :parsed
+        @events << args.shift
+        @num_records_parsed += 1
+      when :record_error
+        @records << args.shift
+        @statuses << :error
+        @events << []
+        @num_records_errored += 1
+      end
+    end
+  end
+
+  module FeedHelperMethods
+    def it_fetches_url(url)
+      describe 'fetching' do
+        it "should fetch the url #{url}" do
+          stub_request(:get, url)
+          feed.fetcher_builder.call().fetch()
+          expect(a_request(:get, url)).to have_been_made
+        end
+      end
+    end
+
+    def feed_data(filename)
+      (FEED_DATA_ROOT + filename).to_s
+    end
+
+    def describe_parsing_a_record(data, &block)
+      context("parsing a record from '#{data}'", :caller => caller) do
+        let(:observer) { FeedRunnerObserver.new }
+        before :each do
+          sio = StringIO.new(data)
+          feed_runner.add_observer(observer)
+          feed_runner.run(:io => sio, :skip_decoding => true)
+          @status, @record, @events = observer.first
+        end
+
+        after :each do
+          feed_runner.delete_observer(observer)
+        end
+
+        it "should have handled exactly 1 record" do
+          expect(observer.count).to eq(1)
+        end
+
+        describe "the record" do
+          include_context 'a parsed record'
+          instance_exec(&block)
+        end
+      end
+    end
+
+    def describe_parsing_the_file(filename, &block)
+      filepath = Pathname.new(filename)
+      relative_filename = filepath.relative_path_from(PROJECT_ROOT).to_s
+
+      context("parsing the file '#{relative_filename}'", :caller => caller) do
+        let(:observer) { FeedRunnerObserver.new }
+        before :each do
+          fio = File.open(filename, 'r')
+          feed_runner.add_observer(observer)
+          feed_runner.run(:io => fio)
+          fio.close unless fio.closed?
+        end
+
+        after :each do
+          feed_runner.delete_observer(observer)
+        end
+
+        include_context "a parsed feed"
+        instance_exec(&block)
+      end
+    end
+  end
+end

data/spec/support/shared/fetcher.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+shared_examples_for "a fetcher" do
+  let(:expected_data) { "here's some data" }
+
+  subject { fetcher }
+  it { should respond_to(:fetch) }
+
+  it "should == itself" do
+    expect(fetcher).to be == fetcher
+  end
+
+  it "should == an identically configured instance" do
+    expect(fetcher_builder.call()).to be == fetcher_builder.call()
+  end
+
+  it "should not == a differently configured instance" do
+    expect(fetcher_builder.call()).not_to be == fetcher_builder_different.call()
+  end
+
+  it "should eql?(itself)" do
+    expect(fetcher).to eql(fetcher)
+  end
+
+  it "should eql? an identically configured instance" do
+    expect(fetcher_builder.call()).to eql(fetcher_builder.call())
+  end
+
+  it "should not eql? an differently configured instance" do
+    expect(fetcher_builder.call()).not_to eql(fetcher_builder_different.call())
+  end
+
+  context "the object returned by #fetch" do
+    subject { fetcher.fetch }
+
+    it_should_behave_like "an IO-like object"
+
+    it "should return the expected data when #read" do
+      expect(subject.read()).to eq(expected_data)
+    end
+  end
+end
+
+shared_examples_for "a #fetch call that failed" do
+  it "should raise Threatinator::Exceptions::FetchFailed" do
+    expect { fetcher.fetch() }.to raise_error(Threatinator::Exceptions::FetchFailed)
+  end
+end

data/spec/support/shared/filter.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+shared_examples_for "a filter" do
+  # expects :filter, :should_filter, and :shouldnt_filter
+
+  describe "#filter?" do
+    it "should return true for data that is meant to be filtered" do
+      expect(filter.filter?(should_filter)).to eq(true)
+    end
+    it "should return false for data that is meant to be filtered" do
+      expect(filter.filter?(shouldnt_filter)).to eq(false)
+    end
+  end
+end

data/spec/support/shared/io-like.rb

@@ -0,0 +1,7 @@
+
+shared_examples_for "an IO-like object" do
+  it { is_expected.to respond_to(:close) }
+  it { is_expected.to respond_to(:read) }
+  it { is_expected.to respond_to(:gets) }
+  it { is_expected.to respond_to(:pos) }
+end

data/spec/support/shared/model/collection.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+shared_examples_for "a model collection" do
+  # expect generate_ten_valid_members, generate_invalid_members
+  let(:collection) { described_class.new }
+
+  describe "initialize" do
+    context "when no parameters are provided" do
+      specify "the collection is empty" do
+        x = described_class.new
+        expect(x).to be_empty
+      end
+    end
+
+    context "when an array of members is provided" do
+      it "calls #<< for each member, adding it to the collection" do
+        members = generate_ten_valid_members()
+        expect_any_instance_of(described_class).to receive(:<<).exactly(10).times.and_call_original
+        x = described_class.new(members)
+        expect(x.to_a).to match_array(members)
+      end
+    end
+  end
+  describe "#<<(member)" do
+    it "adds the member to the collection" do
+      member = generate_ten_valid_members()[0]
+      expect(collection.include?(member)).to eq(false)
+      collection << member
+      expect(collection.include?(member)).to eq(true)
+    end
+
+    it "does not add the member if it is equal to any member of the collection" do
+      member = generate_ten_valid_members()[0]
+      expect(collection.count).to eq(0)
+      collection << member
+      expect(collection.count).to eq(1)
+      collection << member
+      expect(collection.count).to eq(1)
+    end
+
+    it "raises InvalidAttributeError if the added member is not valid for the collection" do
+      expect {
+        collection << generate_invalid_members()[0]
+      }.to raise_error(Threatinator::Exceptions::InvalidAttributeError)
+    end
+  end
+  
+  describe "#valid_member?(member)" do
+    it "returns true if the member is valid" do
+      expect(collection.valid_member?(generate_ten_valid_members()[0])).to eq(true)
+    end
+    it "returns false if the member is not valid" do
+      expect(collection.valid_member?(generate_invalid_members()[0])).to eq(false)
+    end
+  end
+
+  describe "#include?(member)" do
+    let(:member) { generate_ten_valid_members()[0] }
+    it "returns true if the member is in the collection" do
+      collection << member
+      expect(collection).to include(member)
+    end
+
+    it "returns false if the member is not in the collection" do
+      expect(collection).not_to include(member)
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true when the collection is empty" do
+      expect(collection).to be_empty
+    end
+    it "returns false when something has been added to the collection" do
+      member = generate_ten_valid_members()[0]
+      collection << member
+      expect(collection).not_to be_empty
+    end
+  end
+
+  describe "#count" do
+    it "returns 0 when the collection is empty" do
+      expect(collection.count).to eq(0)
+    end
+
+    it "returns the number of members in the collection" do
+      members = generate_ten_valid_members()
+      members.each do |member|
+        collection << member
+      end
+      expect(collection.count).to eq(members.count)
+    end
+  end
+
+  [:to_ary, :to_a].each do |method_name|
+    describe "##{method_name}" do 
+      it "returns an empty array instance when the collection is empty" do
+        expect(collection.send(method_name)).to eq([])
+      end
+
+      it "returns an array containing members that have been added" do
+        members = generate_ten_valid_members()
+        members.each do |member|
+          collection << member
+        end
+        expect(collection.send(method_name)).to match_array(members)
+      end
+    end
+  end
+
+  describe "#each" do
+    it "returns an Enumerator if no block is provided" do
+      expect(collection.each).to be_a(::Enumerator)
+    end
+
+    it "yields each member of the collection" do
+      members = generate_ten_valid_members()
+      members.each do |member|
+        collection << member
+      end
+
+      actual = []
+      collection.each do |member|
+        actual << member
+      end
+
+      expect(actual).to match_array(members)
+    end
+  end
+
+  describe "#==(other)" do
+    before :each do
+    end
+
+    it "returns true when compared to itself" do
+      collection = described_class.new(generate_ten_valid_members())
+      expect(collection).to be == collection
+    end
+
+    it "returns true when compared to a collection with equal members" do
+      collection = described_class.new(generate_ten_valid_members())
+      collection2 = described_class.new(generate_ten_valid_members())
+      expect(collection).to be == collection2
+    end
+
+    it "returns false if the number of members is different" do
+      collection = described_class.new(generate_ten_valid_members()[0..5])
+      collection2 = described_class.new(generate_ten_valid_members())
+      expect(collection).not_to be == collection2
+    end
+
+    it "returns false if the members are different" do
+      collection = described_class.new(generate_ten_valid_members()[0..4])
+      collection2 = described_class.new(generate_ten_valid_members()[5..9])
+      expect(collection).not_to be == collection2
+    end
+
+    it "returns false when compared to something other than a collection" do
+      members = generate_ten_valid_members()
+      collection = described_class.new(members)
+      expect(collection).not_to be == members
+    end
+  end
+end
+

data/spec/support/shared/output.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'tempfile'
+require 'threatinator/plugin_loader'
+
+shared_examples_for "an output plugin" do |name|
+  let(:output) { described_class.new(config) }
+
+  specify "the plugin loader should find the class by (#{name.inspect})" do
+    loader = Threatinator::PluginLoader.new
+    loader.load_plugins(:output)
+    expect(loader.get(:output, name.to_sym)).to be(described_class)
+  end
+end
+
+shared_examples_for "a file-based output plugin" do |name|
+  it_should_behave_like "an output plugin", name
+
+  let(:event) { build(:event) }
+
+  describe "config.io => IO" do
+    let(:output) { described_class.new(config) }
+    let(:io) { StringIO.new }
+    before :each do
+      config.io = io
+    end
+
+    describe "#handle_event" do
+      before :each do
+        output.handle_event(event)
+      end
+
+      it "writes data to the provided IO" do
+        expect(io.string).not_to be_empty
+      end
+    end
+
+    describe "#finish" do
+      before :each do
+        allow(io).to receive(:close)
+        output.finish
+      end
+
+      it "closes the IO" do
+        expect(io).to have_received(:close)
+      end
+    end
+  end
+
+  describe "config.filename => String" do
+    let(:output) { described_class.new(config) }
+    before :each do
+      @tempfile = Tempfile.new("asdf")
+      @tempfile.close
+      @filepath = @tempfile.path
+      config.filename = @filepath
+    end
+
+    let(:filepath) { @filepath }
+
+    describe "#finish" do
+      it "closes the filehandle" do
+        expect(output.instance_variable_get(:"@output_io")).to receive(:close)
+        output.finish
+      end
+    end
+
+    describe "#handle_event" do
+      before :each do
+        output.handle_event(event)
+      end
+      specify "writes data to the path specified by :filename" do
+        output.finish
+        expect(File.read(@filepath)).not_to be_empty
+      end
+    end
+  end
+
+  describe "without specifying config.io or config.filename" do
+    before :each do
+      @orig_stdout = $stdout
+      @duped_io = StringIO.new
+      $stdout = double("stdout").as_null_object
+      allow($stdout).to receive(:dup).and_return(@duped_io)
+      @output = described_class.new(config)
+    end
+
+    let(:output) { @output }
+
+    after :each do
+      $stdout = @orig_stdout
+    end
+
+    it "uses a duplicate of $stdout" do
+      expect($stdout).to have_received(:dup)
+    end
+
+    describe "#handle_event" do
+      before :each do
+        output.handle_event(event)
+      end
+
+      it "writes to the dupe of $stdout" do
+        expect(@duped_io.string).not_to be_empty
+      end
+    end
+
+    describe "#finish" do
+      before :each do
+        allow(@duped_io).to receive(:close).and_call_original
+        output.finish
+      end
+
+      it "closes the dup of $stdout" do
+        expect(@duped_io).to have_received(:close)
+      end
+    end
+
+  end
+end
+

data/spec/support/shared/parsers.rb

@@ -0,0 +1,51 @@
+shared_examples_for "a parser when compared to an identically configured parser" do
+  it "parser1 should eql? parser2" do
+    expect(parser1).to eql(parser2)
+  end
+  it "parser2 should eql? parser1" do
+    expect(parser2).to eql(parser1)
+  end
+  it "parser1 should == parser2" do
+    expect(parser1).to be == parser2
+  end
+  it "parser2 should == parser1" do
+    expect(parser2).to be == parser1
+  end
+  it "parser1 should not be parser2" do
+    expect(parser1).not_to be parser2
+  end
+  it "parser2 should not be parser1" do
+    expect(parser2).not_to be parser1
+  end
+end
+
+shared_examples_for "a parser when compared to a differently configured parser" do
+  it "parser1 should not eql? parser2" do
+    expect(parser1).not_to eql(parser2)
+  end
+  it "parser2 should not eql? parser1" do
+    expect(parser2).not_to eql(parser1)
+  end
+  it "parser1 should not == parser2" do
+    expect(parser1).not_to be == parser2
+  end
+  it "parser2 should not == parser1" do
+    expect(parser2).not_to be == parser1
+  end
+  it "parser1 should not be parser2" do
+    expect(parser1).not_to be parser2
+  end
+  it "parser2 should not be parser1" do
+    expect(parser2).not_to be parser1
+  end
+end
+
+module ParserHelpers
+  def parser_data(filename)
+    PARSER_FIXTURES.join(filename).to_s
+  end
+end
+
+shared_context "a parser", :parser do
+  include ParserHelpers
+end