threatinator 0.1.1

data/spec/threatinator/actions/run/output_config_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'threatinator/actions/run/output_config'
+require 'threatinator/plugin_loader'
+require 'fixtures/plugins/fake'
+
+describe Threatinator::Actions::Run::OutputConfig do
+  let(:plugin_loader) { Threatinator::PluginLoader.new }
+
+  describe ".generate(plugin_loader)" do
+    before :each do
+      plugin_loader.register_plugin(:output, :plugin1, FakeOutputPlugins::Plugin1)
+      plugin_loader.register_plugin(:output, :plugin2, FakeOutputPlugins::Plugin2)
+      plugin_loader.register_plugin(:output, :plugin3, FakeOutputPlugins::Plugin3)
+    end
+
+    let(:generated_class) { described_class.generate(plugin_loader) }
+    it "returns a subclass of Threatinator::Config::Base" do
+      expect(generated_class.superclass).to be(Threatinator::Config::Base)
+    end
+
+    describe "#formats" do
+      it "returns an array containing all the registered output format names" do
+        expect(generated_class.formats).to contain_exactly('plugin1', 'plugin2', 'plugin3')
+      end
+    end
+
+    describe "#formats_str" do
+      it "returns a string of the #formats sorted alphabetically" do
+        expect(generated_class.formats_str).to eq('plugin1, plugin2, plugin3')
+      end
+    end
+
+    describe "attributes" do
+      describe ":format" do
+        describe "description" do
+          it "should describe the output and the available formats" do
+            a = generated_class.attribute_set[:format]
+            desc_proc = a.options[:description]
+            ret = desc_proc.call(generated_class, a)
+            expect(ret).to eq('Output format (plugin1, plugin2, plugin3)')
+          end
+        end
+      end
+    end
+
+    describe "an instance" do
+      let(:config) { generated_class.new }
+      specify "has an attribute for each plugin name that is an instance of that plugin's config" do
+        expect(config.plugin1).to be_a(FakeOutputPlugins::Plugin1::Config)
+        expect(config.plugin1).to respond_to(:foo)
+        expect(config.plugin2).to be_a(FakeOutputPlugins::Plugin2::Config)
+        expect(config.plugin2).to respond_to(:bar)
+        expect(config.plugin3).to be_a(FakeOutputPlugins::Plugin3::Config)
+        expect(config.plugin3).to respond_to(:woof)
+      end
+
+      describe "#build_output" do
+        it "raises UnknownPlugin when no plugin is found for the value of #format" do
+          config.format = :asdf
+          expect {
+            config.build_output
+          }.to raise_error(Threatinator::Exceptions::UnknownPlugin)
+        end
+
+        it "raises CouldNotFindOutputConfigError if there is no config for the #format" do
+          config.format = :plugin1
+          config.plugin1 = nil
+          expect {
+            config.build_output
+          }.to raise_error(Threatinator::Exceptions::CouldNotFindOutputConfigError)
+        end
+
+        context "when #format is associated with a reigstered plugin" do
+          it "initializes the output plugin with the plugin's config" do
+            config.format = :plugin2
+            expect(FakeOutputPlugins::Plugin2).to receive(:new).with(config.plugin2)
+            config.build_output
+          end
+
+          it "returns an instance of the output plugin" do
+            config.format = :plugin3
+            expect(config.build_output).to be_a(FakeOutputPlugins::Plugin3)
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/threatinator/cli/list_action_builder_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'threatinator/cli/list_action_builder'
+
+describe Threatinator::CLI::ListActionBuilder do
+  describe 'an instance' do
+    let(:config_hash) { {} }
+    let(:extra_args) { [] }
+    let(:builder) { described_class.new(config_hash, extra_args) }
+
+    it_behaves_like "an action builder"
+    
+    describe "#config" do
+      context "when config_hash['list'] is provided" do
+        let(:list_hash) { double('list hash') }
+        before :each do
+          config_hash['list'] = list_hash
+        end
+        it "builds a new Threatinator::Actions::List::Config using config_hash['list']" do
+          expect(Threatinator::Actions::List::Config).to receive(:new).with(list_hash)
+          builder.config
+        end
+      end
+      context "when config_hash['list'] does not exist" do
+        before :each do
+          config_hash.delete 'list'
+        end
+        it "builds a new Threatinator::Config::FeedSearch using an empty hash" do
+          expect(Threatinator::Actions::List::Config).to receive(:new).with({})
+          builder.config
+        end
+      end
+    end
+
+    describe "#build" do
+      let(:action) { double('action') }
+      let(:config) { double('config') }
+      let(:feed_registry) { double('feed registry') }
+      before :each do
+        allow(Threatinator::Actions::List::Action).to receive(:new).and_return(action)
+        allow(builder).to receive(:config).and_return(config)
+        allow(builder).to receive(:feed_registry).and_return(feed_registry)
+      end
+
+      let(:result) { builder.build }
+
+      it "builds an instance of Threatinator::Actions::List::Action using #feed_registry and #config" do
+        expect(Threatinator::Actions::List::Action).to receive(:new).with(feed_registry, config)
+        builder.build
+      end
+
+      it "returns the instance of the action" do
+        expect(builder.build).to be(action)
+      end
+
+    end
+  end
+end

data/spec/threatinator/cli/run_action_builder_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'fileutils'
+require 'threatinator/cli/run_action_builder'
+require 'threatinator/plugin_loader'
+
+describe Threatinator::CLI::RunActionBuilder do
+  describe 'an instance' do
+    let(:plugin_loader) { Threatinator::PluginLoader.new }
+    let(:config_class) { Threatinator::Actions::Run::Config.generate(plugin_loader) }
+    let(:config_hash) { { 'run' => {} } }
+    let(:extra_args) { [] }
+    let(:builder) { described_class.new(config_hash, extra_args, config_class) }
+
+    it_behaves_like "an action builder"
+
+    describe "#config" do
+      let(:config) { builder.config }
+      it "returns an instance of config_class" do
+        expect(config).to be_a(config_class)
+      end
+
+      describe "config_hash['run']['coverage_output']" do
+        context "when nil" do
+          before :each do
+            config_hash['run'].delete('coverage_output')
+          end
+
+          it "sets config.observers to []" do
+            config = builder.config
+            expect(config.observers).to contain_exactly()
+          end
+        end
+
+        context "when set to a string" do
+          let(:coverage_proc) { lambda { } }
+          before :each do
+            config_hash['run']['coverage_output'] = "asdf"
+          end
+          it "initializes a CoverageObserver with the string" do
+            expect(Threatinator::Actions::Run::CoverageObserver).to receive(:new).with('asdf')
+            builder.config
+          end
+          it "sets config.observers an array consisting of the CoverageObserver" do
+            observer = double('observer')
+            expect(Threatinator::Actions::Run::CoverageObserver).to receive(:new).and_return(observer)
+
+            config = builder.config
+            expect(config.observers).to contain_exactly(observer)
+          end
+        end
+      end
+
+      context "config_hash['run']['feed_provider']" do
+        context "when nil" do
+          before :each do
+            config_hash['run'].delete('feed_provider')
+          end
+          context "and there are no extra arguments" do
+            specify "#feed_provider is nil" do
+              expect(config.feed_provider).to be_nil
+            end
+          end
+
+          context "and there is at least one extra argument" do
+            before :each do
+              extra_args << "arg1"
+              extra_args << "arg2"
+              extra_args << "arg3"
+            end
+            specify "#feed_provider is the first extra argument" do
+              expect(config.feed_provider).to eq("arg1")
+            end
+          end
+        end
+      end
+
+      context "config_hash['run']['feed_name']" do
+        context "when nil" do
+          before :each do
+            config_hash['run'].delete('feed_name')
+          end
+          context "and there are no extra arguments" do
+            specify "#feed_name is nil" do
+              expect(config.feed_name).to be_nil
+            end
+          end
+
+          context "and there are extra arguments" do
+            before :each do
+              extra_args << "arg1"
+              extra_args << "arg2"
+              extra_args << "arg3"
+            end
+
+            specify "#feed_name is the first extra argument if feed_provider was configured" do
+              config_hash['run']['feed_provider'] = "foo"
+              expect(config.feed_name).to eq("arg1")
+            end
+
+            specify "#feed_name is the second extra argument if feed_provider was not configured" do
+              config_hash['run'].delete('feed_provider')
+              expect(config.feed_name).to eq("arg2")
+            end
+          end
+        end
+      end
+    end
+
+    describe "#build" do
+      let(:action) { double('action') }
+      let(:config) { double('config') }
+      let(:feed_registry) { double('feed registry') }
+      before :each do
+        allow(Threatinator::Actions::Run::Action).to receive(:new).and_return(action)
+        allow(builder).to receive(:config).and_return(config)
+        allow(builder).to receive(:feed_registry).and_return(feed_registry)
+      end
+
+      let(:result) { builder.build }
+
+      it "builds an instance of Threatinator::Actions::Run::Action using #feed_registry and #config" do
+        expect(Threatinator::Actions::Run::Action).to receive(:new).with(feed_registry, config)
+        builder.build
+      end
+
+      it "returns the instance of the action" do
+        expect(builder.build).to be(action)
+      end
+
+    end
+  end
+end
+

data/spec/threatinator/cli_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'threatinator/cli'
+require 'fileutils'
+
+shared_context "threatinator commands" do
+  let(:action) { double('action') }
+  let(:builder) { double('builder') }
+
+  before :each do
+    allow(action_builder_class).to receive(:new).and_return(builder)
+    allow(builder).to receive(:build).and_return(action)
+    allow(action).to receive(:exec)
+  end
+
+end
+shared_examples_for "a threatinator command" do
+  context '--feed_search.path=foo/bar' do
+    before :each do
+      global_args << '--feed_search.path=foo/bar'
+      Threatinator::CLI.process!(args)
+    end
+
+    it "generates the proper config hash" do
+      expect(action_builder_class).to have_received(:new) do |opts, args, *extra| 
+        expect(opts).to match(
+          {
+            'feed_search' => {
+              'exclude_default' => false,
+              'path' => ['foo/bar']
+            }
+          }
+        )
+        expect(args).to eq([])
+      end
+    end
+  end
+
+  context '--feed_search.path=foo/bar,woof/bark' do
+    before :each do
+      global_args << '--feed_search.path=foo/bar,woof/bark'
+      Threatinator::CLI.process!(args)
+    end
+
+    it "generates the proper config hash" do
+      expect(action_builder_class).to have_received(:new) do |opts, args, *extra|
+        expect(opts).to match(
+          {
+            'feed_search' => {
+              'exclude_default' => false,
+              'path' => ['foo/bar', 'woof/bark']
+            }
+          }
+        )
+        expect(args).to eq([])
+      end
+    end
+  end
+
+  context '--feed_search.exclude_default' do
+    before :each do
+      global_args << '--feed_search.exclude_default'
+      Threatinator::CLI.process!(args)
+    end
+
+    it "generates the proper config hash" do
+      expect(action_builder_class).to have_received(:new).with({
+        'feed_search' => {
+          'exclude_default' => true
+        }
+      }, [],
+      kind_of(Class)
+     )
+    end
+  end
+
+  context "--help" do
+    before :each do
+      global_args << '--help'
+      @exception = nil
+      @exit_code = nil
+
+      @captured_output = temp_stdout do
+        @exit_code = Threatinator::CLI.process!(args)
+      end
+    end
+
+    it "should have an exit code of 0" do
+      expect(@exit_code).to eq(0)
+    end
+
+    it "should print usage information" do
+      expect(@captured_output).to match(/^NAME/)
+    end
+
+    it "should not create an action builder" do
+      expect(action_builder_class).not_to have_received(:new)
+    end
+  end
+end
+
+describe Threatinator::CLI do
+  let(:global_args) { [] }
+  let(:command) { [] }
+  let(:command_args) { [] }
+  let(:args) { global_args + [ command ] + command_args }
+
+  describe "list command" do
+    let(:command) { 'list' }
+    let(:action) { double('action') }
+    let(:builder) { double('builder') }
+
+    before :each do
+      allow(Threatinator::CLI::ListActionBuilder).to receive(:new).and_return(builder)
+      allow(builder).to receive(:build).and_return(action)
+      allow(action).to receive(:exec)
+    end
+
+    it "should create a ListActionBuilder" do
+      Threatinator::CLI.process!(args)
+      expect(Threatinator::CLI::ListActionBuilder).to have_received(:new).with({"feed_search" => {"exclude_default" => false}}, [])
+    end
+
+    it "should build an action" do
+      Threatinator::CLI.process!(args)
+      expect(builder).to have_received(:build)
+    end
+
+    it "should execute a list action" do
+      Threatinator::CLI.process!(args)
+      expect(action).to have_received(:exec)
+    end
+  end
+
+  describe "run" do
+    let(:action_builder_class) { Threatinator::CLI::RunActionBuilder }
+    let(:command) { 'run' }
+    include_context "threatinator commands"
+
+    context "with no additional arguments" do
+      it "should create an action builder with no config or args" do
+        Threatinator::CLI.process!(args)
+        expect(action_builder_class).to have_received(:new).with(
+          {
+            "feed_search" => {
+              "exclude_default" => false
+            }
+          }, [], kind_of(Class))
+      end
+    end
+
+    context "feed_provider feed_name" do
+      before :each do
+        command_args << 'feed_provider'
+        command_args << 'feed_name'
+      end
+      it "should create an action builder with args feed_provider feed_name" do
+        Threatinator::CLI.process!(args)
+        expect(action_builder_class).to have_received(:new).with(
+          {
+            "feed_search" => {
+              "exclude_default" => false
+            }, 
+            "run" => {
+              "feed_provider" => "feed_provider", 
+              "feed_name" => "feed_name"
+            }
+          }, [], kind_of(Class)
+        )
+      end
+    end
+
+    it_should_behave_like "a threatinator command"
+  end
+end
+