bundler-audit 0.7.0.1 → 0.9.0.1

data/spec/cli/formats_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'bundler/audit/cli/formats'
+
+describe Bundler::Audit::CLI::Formats do
+  describe ".[]" do
+    context "when given the name of a registered format" do
+      it "should return the format" do
+        expect(subject[:text]).to be described_class::Text
+      end
+    end
+
+    context "when given an unknown name" do
+      it { expect(subject[:foo]).to be(nil) }
+    end
+  end
+
+  describe ".register" do
+    context "when given a valid format module" do
+      module GoodModule
+        def print_report(report)
+        end
+      end
+
+      let(:name)   { :good_module }
+      let(:format) { GoodModule   }
+
+      it "should register the module" do
+        subject.register name, format
+
+        expect(subject[name]).to be format
+      end
+    end
+
+    context "when given a format module that does not define #print_report" do
+      module BadModule
+        def pront_report(report)
+        end
+      end
+
+      let(:name)   { :bad_module }
+      let(:format) { BadModule   }
+
+      it do
+        expect { subject.register(name,format) }.to raise_error(
+          NotImplementedError, "#{format.inspect} does not define #print_report"
+        )
+      end
+    end
+  end
+
+  describe ".load" do
+    LIB_DIR = File.expand_path('../fixtures/lib',File.dirname(__FILE__))
+
+    before(:all) { $LOAD_PATH.unshift(LIB_DIR) }
+
+    context "when given the name of a valid format" do
+      let(:name) { :good }
+
+      it "should require and return the format" do
+        expect(subject.load(name)).to be described_class::Good
+      end
+    end
+
+    context "when given the name of a non-existant format" do
+      let(:name) { :foo }
+
+      it do
+        expect { subject.load(name) }.to raise_error(
+          described_class::FormatNotFound, "could not load format \"#{name}\""
+        )
+      end
+    end
+
+    context "when given the name of a printer which incorrectly registers itself" do
+      let(:name) { :bad }
+
+      it do
+        expect { subject.load(name) }.to raise_error(
+          described_class::FormatNotFound, "unknown format \"#{name}\""
+        )
+      end
+    end
+
+    after(:all) { $LOAD_PATH.delete(LIB_DIR) }
+  end
+end

data/spec/cli_spec.rb

@@ -2,36 +2,90 @@ require 'spec_helper'
 require 'bundler/audit/cli'
 
 describe Bundler::Audit::CLI do
+  describe ".start" do
+    context "with wrong arguments" do
+      it "exits with error status code" do
+        expect {
+          described_class.start ["check", "foo/bar/baz"]
+        }.to raise_error(SystemExit) do |error|
+          expect(error.success?).to eq(false)
+          expect(error.status).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe "#stats" do
+    let(:size) { 1234 }
+    let(:last_updated_at) { Time.now }
+    let(:commit_id) { 'f0f97c4c493b853319e029d226e96f2c2f0dc539' }
+
+    let(:database) { double(Bundler::Audit::Database) }
+
+    before do
+      expect(Bundler::Audit::Database).to receive(:new).and_return(database)
+
+      expect(database).to receive(:size).and_return(size)
+      expect(database).to receive(:last_updated_at).and_return(last_updated_at)
+      expect(database).to receive(:commit_id).and_return(commit_id)
+    end
+
+    it "prints total advisory count" do
+      expect { subject.stats }.to output(
+        include(
+          "advisories:\t#{size} advisories",
+          "last updated:\t#{last_updated_at}",
+          "commit:\t#{commit_id}"
+        )
+      ).to_stdout
+    end
+  end
+
   describe "#update" do
+    let(:database) { double(Bundler::Audit::Database) }
+
+    before do
+      allow(Bundler::Audit::Database).to receive(:new).and_return(database)
+    end
+
     context "not --quiet (the default)" do
       context "when update succeeds" do
+        let(:size) { 1234 }
+        let(:last_updated_at) { Time.now }
+        let(:commit_id) { 'f0f97c4c493b853319e029d226e96f2c2f0dc539' }
 
-        before { expect(Bundler::Audit::Database).to receive(:update!).and_return(true) }
-
-        it "prints updated message" do
-          expect { subject.update }.to output(/Updated ruby-advisory-db/).to_stdout
+        before do
+          expect(database).to receive(:update!).and_return(true)
+          expect(database).to receive(:size).and_return(size)
+          expect(database).to receive(:last_updated_at).and_return(last_updated_at)
+          expect(database).to receive(:commit_id).and_return(commit_id)
         end
 
-        it "prints total advisory count" do
-          database = double
-          expect(database).to receive(:size).and_return(1234)
-          expect(Bundler::Audit::Database).to receive(:new).and_return(database)
-
-          expect { subject.update }.to output(/ruby-advisory-db: 1234 advisories/).to_stdout
+        it "prints updated message and then the stats" do
+          expect { subject.update }.to output(
+            include(
+              "Updated ruby-advisory-db",
+              "ruby-advisory-db:",
+              "  advisories:\t#{size} advisories",
+              "  last updated:\t#{last_updated_at}",
+              "  commit:\t#{commit_id}"
+            )
+          ).to_stdout
         end
       end
 
       context "when update fails" do
-
-        before { expect(Bundler::Audit::Database).to receive(:update!).and_return(false) }
+        before do
+          expect(database).to receive(:update!).and_return(false)
+        end
 
         it "prints failure message" do
-          expect do
+          expect {
             begin
               subject.update
             rescue SystemExit
             end
-          end.to output(/Failed updating ruby-advisory-db!/).to_stdout
+          }.to output(/Failed updating ruby-advisory-db!/).to_stderr
         end
 
         it "exits with error status code" do
@@ -44,22 +98,22 @@ describe Bundler::Audit::CLI do
             expect(error.status).to eq(1)
           end
         end
-
       end
 
       context "when git is not installed" do
         before do
-          expect(Bundler::Audit::Database).to receive(:update!).and_return(nil)
+          expect(database).to receive(:update!).and_return(nil)
+
           expect(Bundler).to receive(:git_present?).and_return(false)
         end
 
         it "prints failure message" do
-          expect do
+          expect {
             begin
               subject.update
             rescue SystemExit
             end
-          end.to output(/Git is not installed!/).to_stdout
+          }.to output(/Git is not installed!/).to_stderr
         end
 
         it "exits with error status code" do
@@ -76,14 +130,13 @@ describe Bundler::Audit::CLI do
     end
 
     context "--quiet" do
-      before do
-        allow(subject).to receive(:options).and_return(double("Options", quiet?: true))
+      subject do
+        described_class.new([], {quiet: true})
       end
 
       context "when update succeeds" do
-
         before do
-          expect(Bundler::Audit::Database).to(
+          expect(database).to(
             receive(:update!).with(quiet: true).and_return(true)
           )
         end
@@ -94,20 +147,19 @@ describe Bundler::Audit::CLI do
       end
 
       context "when update fails" do
-
         before do
-          expect(Bundler::Audit::Database).to(
+          expect(database).to(
             receive(:update!).with(quiet: true).and_return(false)
           )
         end
 
         it "prints failure message" do
-          expect do
+          expect {
             begin
               subject.update
             rescue SystemExit
             end
-          end.to output(/Failed updating ruby-advisory-db!/).to_stdout
+          }.to_not output.to_stderr
         end
 
         it "exits with error status code" do

data/spec/configuration_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'bundler/audit/configuration'
+
+describe Bundler::Audit::Configuration do
+  describe "when building from a yaml file" do
+    let(:fixtures_dir) { File.expand_path('../fixtures/config',__FILE__) }
+
+    subject { described_class.load(path) }
+
+    context "when the file does not exist" do
+      let(:path) { File.join(fixtures_dir,'bad','does_not_exist.yml') }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(described_class::FileNotFound, /Configuration file '.*' does not exist/)
+      end
+    end
+
+    context "when the file does exist" do
+      let(:path) { File.join(fixtures_dir,'valid.yml')   }
+
+      it { should be_a(described_class) }
+    end
+
+    context "validations" do
+      context "when the file is empty" do
+        let(:path) { File.join(fixtures_dir,'bad','empty.yml') }
+
+        it 'raises a validation error' do
+          expect { subject }.to raise_error(described_class::InvalidConfigurationError)
+        end
+      end
+
+      context "when ignore is not an array" do
+        let(:path) { File.join(fixtures_dir,'bad','ignore_is_not_an_array.yml') }
+
+        it 'raises a validation error' do
+          expect { subject }.to raise_error(described_class::InvalidConfigurationError)
+        end
+      end
+
+      context 'when ignore is an array' do
+        context 'when ignore only contains strings' do
+          let(:path) { File.join(fixtures_dir,'valid.yml')   }
+
+          it { should be_a(described_class) }
+        end
+
+        describe "when ignore contains non-strings" do
+          let(:path) { File.join(fixtures_dir,'bad','ignore_contains_a_non_string.yml') }
+
+          it "raises a validation error" do
+            expect { subject }.to raise_error(described_class::InvalidConfigurationError)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+    context "when given no arguments" do
+      it "must set @ignore to an empty Set" do
+        expect(subject.ignore).to be_kind_of(Set)
+        expect(subject.ignore).to be_empty
+      end
+    end
+
+    context "when given :ignore" do
+      let(:advisory_ids) { %w[CVE-123 CVE-456] }
+
+      subject { described_class.new(ignore: advisory_ids) }
+
+      it "must initialize @ignore to contain :ignore" do
+        expect(subject.ignore).to be_kind_of(Set)
+        expect(subject.ignore).to be == Set.new(advisory_ids)
+      end
+    end
+  end
+end