license_finder 1.0.0.0-java → 1.1.1-java

data/spec/lib/license_finder/package_managers/pip_spec.rb

@@ -41,26 +41,20 @@ module LicenseFinder
     end
 
     describe '.active?' do
-      let(:requirements) { Pathname.new('requirements.txt').expand_path }
+      let(:requirements) { double(:requirements_file) }
 
-      context 'with a requirements file' do
-        before :each do
-          allow(File).to receive(:exists?).with(requirements).and_return(true)
-        end
-
-        it 'returns true' do
-          expect(Pip.active?).to eq(true)
-        end
+      before do
+        Pip.stub(requirements_path: requirements)
       end
 
-      context 'without a requirements file' do
-        before :each do
-          allow(File).to receive(:exists?).with(requirements).and_return(false)
-        end
+      it 'is true with a requirements.txt file' do
+        requirements.stub(:exist? => true)
+        expect(Pip).to be_active
+      end
 
-        it 'returns false' do
-          expect(Pip.active?).to eq(false)
-        end
+      it 'is false without a requirements.txt file' do
+        requirements.stub(:exist? => false)
+        expect(Pip).to_not be_active
       end
     end
   end

data/spec/lib/license_finder/package_saver_spec.rb

@@ -5,7 +5,7 @@ module LicenseFinder
     let(:package) do
       double(
         :package,
-        license: 'license',
+        license: License.find_by_name('license'),
         children: ['child'],
         groups: [:group],
         summary: 'summary',
@@ -34,7 +34,7 @@ module LicenseFinder
           summary: 'old summary',
           description: 'old desription',
           homepage: 'old homepage',
-          license: LicenseAlias.named('old license')
+          license_name: 'old license'
         )
         dep.add_bundler_group BundlerGroup.named("old group")
         dep.add_child Dependency.named("old child")
@@ -56,13 +56,37 @@ module LicenseFinder
       it "keeps approval" do
         dep = Dependency.create(
           name: 'spec_name',
-          manually_approved: true
         )
+        dep.approve!
         saver = described_class.new(dep, package)
         subject = saver.save
 
         subject.should be_approved
       end
+
+      context "to minimize db changes" do
+        it "does not re-save unchanged dependencies" do
+          # See note in PackageSaver#save
+
+          first_run = described_class.find_or_create_by_name(package)
+          # Can't set this expectation, because rspec method expectations
+          # have no way to allow the real save to happen.
+          # expect(first_run.dependency).to receive(:save)
+          first_run.save
+
+          second_run = described_class.find_or_create_by_name(package)
+          expect(second_run.dependency).to_not receive(:save)
+          second_run.save
+        end
+
+        it "saves new dependencies" do
+          # Just a sanity check that the above test is testing what we think it
+          # is testing.
+          saver = described_class.find_or_create_by_name(package)
+          expect(saver.dependency).to receive(:save)
+          saver.save
+        end
+      end
     end
   end
 end

data/spec/lib/license_finder/possible_license_file_spec.rb

@@ -1,36 +1,38 @@
 require 'spec_helper'
 
-describe LicenseFinder::PossibleLicenseFile do
-  context "file parsing" do
-    subject { LicenseFinder::PossibleLicenseFile.new('root', 'root/nested/path') }
-
-    context "ignoring text" do
-      before do
-        subject.stub(:text).and_return('file text')
+module LicenseFinder
+  describe PossibleLicenseFile do
+    context "file parsing" do
+      subject { described_class.new('root', 'root/nested/path') }
+
+      context "ignoring text" do
+        before do
+          subject.stub(:text).and_return('file text')
+        end
+
+        its(:file_path) { should == 'nested/path' }
+        its(:text) { should == 'file text' } # this is a terrible test, considering the stubbing
       end
-
-      its(:file_path) { should == 'nested/path' }
-      its(:text) { should == 'file text' } # this is a terrible test, considering the stubbing
     end
-  end
 
-  subject { LicenseFinder::PossibleLicenseFile.new('gem', 'gem/license/path') }
+    subject { described_class.new('gem', 'gem/license/path') }
 
-  context "with a known license" do
-    before do
-      subject.stub(:text).and_return('a known license')
+    context "with a known license" do
+      before do
+        subject.stub(:text).and_return('a known license')
 
-      LicenseFinder::License.stub(:find_by_text).with('a known license').and_return(LicenseFinder::License.find_by_name("MIT"))
+        License.stub(:find_by_text).with('a known license').and_return(License.find_by_name("MIT"))
+      end
+
+      its(:license) { should == License.find_by_name("MIT") }
     end
 
-    its(:license) { should == "MIT" }
-  end
+    context "with an unknown license" do
+      before do
+        subject.stub(:text).and_return('')
+      end
 
-  context "with an unknown license" do
-    before do
-      subject.stub(:text).and_return('')
+      its(:license) { should be_nil }
     end
-
-    its(:license) { should be_nil }
   end
 end

data/spec/lib/license_finder/reports/detailed_text_report_spec.rb

@@ -4,25 +4,23 @@ module LicenseFinder
   describe DetailedTextReport do
     describe '#to_s' do
       let(:dep1) do
-        dependency = Dependency.new(
+        Dependency.new(
           'name' => 'gem_a',
           'version' => '1.0',
           'summary' => 'Summary',
-          'description' => 'Description'
+          'description' => 'Description',
+          'license' => License.find_by_name('MIT')
         )
-        dependency.license = LicenseFinder::LicenseAlias.create(name: 'MIT')
-        dependency
       end
 
       let(:dep2) do
-        dependency = Dependency.new(
+        Dependency.new(
           'name' => 'gem_b',
           'version' => '1.0',
           'summary' => 'Summary',
-          'description' => 'Description'
+          'description' => 'Description',
+          'license' => License.find_by_name('MIT')
         )
-        dependency.license = LicenseFinder::LicenseAlias.create(name: 'MIT')
-        dependency
       end
 
       subject { DetailedTextReport.new([dep2, dep1]).to_s }

data/spec/lib/license_finder/reports/html_report_spec.rb

@@ -4,78 +4,79 @@ require "capybara"
 module LicenseFinder
   describe HtmlReport do
     describe "#to_s" do
+      let(:dependency_name) { "the-name" }
       let(:dependency) do
-        dep = Dependency.new name: "the-name", manually_approved: true
-        dep.license = LicenseAlias.create name: 'MIT'
+        dep = Dependency.create name: dependency_name
+        dep.apply_better_license License.find_by_name("MIT")
         dep
       end
 
       subject { Capybara.string(HtmlReport.new([dependency]).to_s) }
 
-      context "when the dependency is approved" do
-        it "should add an approved class to dependency's container" do
+      context "when the dependency is manually approved" do
+        before { dependency.approve! "the-approver", "the-approval-note" }
+
+        it "should show approved dependencies without action items" do
           should have_selector ".approved"
+          should_not have_selector ".action-items"
         end
 
-        it "does not list the dependency in the action items" do
-          should_not have_selector ".action-items"
+        it "shows the license, approver and approval notes" do
+          deps = subject.find ".dependencies"
+          deps.should have_content "MIT"
+          deps.should have_content "the-approver"
+          deps.should have_content "the-approval-note"
+          deps.should have_selector "time"
         end
       end
 
-      context "when the dependency is not approved" do
-        before { dependency.manually_approved = false }
-
-        it "should not add an approved class to he dependency's container" do
-          should have_selector ".unapproved"
-        end
+      context "when the dependency is whitelisted" do
+        before { dependency.stub(whitelisted?: true) }
 
-        it "lists the dependency in the action items" do
-          should have_selector ".action-items li"
+        it "should show approved dependencies without action items" do
+          should have_selector ".approved"
+          should_not have_selector ".action-items"
         end
-      end
 
-      context "when the gem has at least one bundler group" do
-        before { dependency.stub(bundler_groups: [double(name: "group")]) }
-        it "should show the bundler group(s) in parens" do
-          should have_text "(group)"
+        it "shows the license" do
+          deps = subject.find ".dependencies"
+          deps.should have_content "MIT"
         end
       end
 
-      context "when the gem has no bundler groups" do
-        before { dependency.stub(bundler_groups: []) }
-
-        it "should not show any parens or bundler group info" do
-          should_not have_text "()"
-        end
-
-      end
+      context "when the dependency is not approved" do
+        before {
+          dependency.license = License.find_by_name('GPL')
+          dependency.manual_approval = nil
+        }
 
-      context "when the gem has at least one parent" do
-        before { dependency.stub(parents: [double(:name => "foo parent")]) }
-        it "should include a parents section" do
-          should have_text "Parents"
-          should have_text "foo parent"
+        it "should show unapproved dependencies with action items" do
+          should have_selector ".unapproved"
+          should have_selector ".action-items li"
         end
       end
 
-      context "when the gem has no parents" do
-        it "should not include any parents section in the output" do
-          should_not have_text "Parents"
+      context "when the gem has many relationships" do
+        before do
+          dependency.stub(bundler_groups: [double(name: "foo group")],
+                          parents: [double(name: "foo parent")],
+                          children: [double(name: "foo child")])
         end
-      end
 
-      context "when the gem has at least one child" do
-        before { dependency.stub(children: [double(:name => "foo child")]) }
-
-        it "should include a Children section" do
-          should have_text "Children"
+        it "should show the relationships" do
+          should have_text "(foo group)"
+          should have_text "#{dependency_name} is required by:"
+          should have_text "foo parent"
+          should have_text "#{dependency_name} relies on:"
           should have_text "foo child"
         end
       end
 
-      context "when the gem has no children" do
-        it "should not include any Children section in the output" do
-          should_not have_text "Children"
+      context "when the gem has no relationships" do
+        it "should not show any relationships" do
+          should_not have_text "()"
+          should_not have_text "#{dependency_name} is required by:"
+          should_not have_text "#{dependency_name} relies on:"
         end
       end
     end

data/spec/lib/license_finder/reports/markdown_report_spec.rb

@@ -4,22 +4,20 @@ module LicenseFinder
   describe MarkdownReport do
     describe '#to_s' do
       let(:dep1) do
-        dependency = Dependency.new(
+        Dependency.new(
           'name' => 'gem_a',
           'version' => '1.0',
-          'manually_approved' => false
+          'license' => License.find_by_name('other')
         )
-        dependency.license = LicenseFinder::LicenseAlias.create(name: 'MIT')
-        dependency
       end
 
       let(:dep2) do
-        dependency = Dependency.new(
+        dependency = Dependency.create(
           'name' => 'gem_b',
           'version' => '2.3',
-          'manually_approved' => true
+          'license' => License.find_by_name('BSD')
         )
-        dependency.license = LicenseFinder::LicenseAlias.create(name: 'BSD')
+        dependency.approve!
         dependency
       end
 
@@ -31,7 +29,8 @@ module LicenseFinder
       end
 
       it 'should list the total, and unapproved counts' do
-        should match "2 total, _1 unapproved_"
+        should match "2 total"
+        should match /1 \*unapproved\*/
       end
 
       it "should list the unapproved dependency" do
@@ -40,7 +39,7 @@ module LicenseFinder
 
       it "should display a summary" do
         should match "## Summary"
-        should match /\s+\* 1 MIT/
+        should match /\s+\* 1 other/
         should match /\s+\* 1 BSD/
       end
 

data/spec/lib/license_finder/reports/reporter_spec.rb

@@ -6,7 +6,7 @@ module LicenseFinder
       subject { Reporter.write_reports }
 
       before do
-        Dependency.stub(:all) { [double(:dep)] }
+        Dependency.stub(:acknowledged) { [double(:dep)] }
 
         MarkdownReport.stub(:of) { 'markdown report' }
         DetailedTextReport.stub(:of) { 'detailed csv report' }

data/spec/lib/license_finder/reports/text_report_spec.rb

@@ -4,21 +4,19 @@ module LicenseFinder
   describe TextReport do
     describe '#to_s' do
       let(:dep1) do
-        dependency = Dependency.new(
+        Dependency.new(
           'name' => 'gem_a',
-          'version' => '1.0'
+          'version' => '1.0',
+          'license' => License.find_by_name('MIT')
         )
-        dependency.license = LicenseFinder::LicenseAlias.create(name: 'MIT')
-        dependency
       end
 
       let(:dep2) do
-        dependency = Dependency.new(
+        Dependency.new(
           'name' => 'gem_b',
-          'version' => '1.0'
+          'version' => '1.0',
+          'license' => License.find_by_name('MIT')
         )
-        dependency.license = LicenseFinder::LicenseAlias.create(name: 'MIT')
-        dependency
       end
 
       subject { TextReport.new([dep2, dep1]).to_s }

data/spec/lib/license_finder/tables/dependency_spec.rb

@@ -3,19 +3,19 @@ require 'spec_helper'
 module LicenseFinder
   describe Dependency do
     describe '.unapproved' do
-      let(:config) { Configuration.new('whitelist' => ['MIT', 'other']) }
-
       before do
-        LicenseFinder.stub(:config).and_return config
+        License.find_by_name('MIT').stub(:whitelisted? =>  true)
+        allow(LicenseFinder.config).to receive(:ignore_dependencies) { ['this ignored dependency', 'that ignored dependency'] }
       end
 
-      it "should return all unapproved dependencies" do
+      it "should return all unapproved dependencies that are not ignored" do
         dependency = Dependency.create(name: "unapproved dependency", version: '0.0.1')
         approved = Dependency.create(name: "approved dependency", version: '0.0.1')
-        approved.manually_approved = true
-        approved.save
+        this_ignored = Dependency.create(name: "this ignored dependency", version: '0.0.1')
+        that_ignored = Dependency.create(name: "that ignored dependency", version: '0.0.1')
+        approved.approve!
         whitelisted = Dependency.create(name: "approved dependency", version: '0.0.1')
-        whitelisted.license = LicenseAlias.create(name: 'MIT')
+        whitelisted.license = License.find_by_name('MIT')
         whitelisted.save
 
         unapproved = Dependency.unapproved
@@ -40,48 +40,64 @@ module LicenseFinder
       end
     end
 
+    describe ".acknowledged" do
+      it "returns all dependencies that are not ignored" do
+        acknowledged_dependency = Dependency.create(name: "acknowledged dependency", version: '0.0.1')
+        ignored_dependency = Dependency.create(name: "ignored dependency", version: '0.0.1')
+        allow(LicenseFinder.config).to receive(:ignore_dependencies) { [ignored_dependency.name] }
+
+        expect(Dependency.acknowledged).to match_array [acknowledged_dependency]
+      end
+    end
+
     describe '#approve!' do
       it "should update the database to show the dependency is approved" do
-        dependency = Dependency.create(name: "foo", version: '0.0.1')
+        dependency = Dependency.named("foo")
         dependency.approve!
         dependency.reload.should be_approved
       end
+
+      it "should record the approver and notes" do
+        dependency = Dependency.named("foo")
+        dependency.approve!("Julian", "We really need this")
+        approval = dependency.reload.manual_approval
+        approval.approver.should eq "Julian"
+        approval.notes.should eq "We really need this"
+      end
     end
 
     describe "#approved?" do
-      let(:not_manually_approved) { Dependency.create(name: 'some gem', manually_approved: false).reload }
-      let(:manually_approved) { Dependency.create(name: 'some gem', manually_approved: true).reload }
+      let(:not_approved_manually) { Dependency.create(name: 'some gem').reload }
+      let(:approved_manually) { Dependency.create(name: 'some gem').approve!.reload }
 
       it "is true if its license is whitelisted" do
-        not_manually_approved.stub_chain(:license, whitelisted?: true)
-        not_manually_approved.should be_approved
+        not_approved_manually.stub_chain(:license, whitelisted?: true)
+        not_approved_manually.should be_approved
       end
 
       it "is true if it has been approved" do
-        manually_approved.stub_chain(:license, whitelisted?: false)
-        manually_approved.should be_approved
+        approved_manually.stub_chain(:license, whitelisted?: false)
+        approved_manually.should be_approved
       end
 
       it "is false otherwise" do
-        not_manually_approved.stub_chain(:license, whitelisted?: false)
-        not_manually_approved.should_not be_approved
+        not_approved_manually.stub_chain(:license, whitelisted?: false)
+        not_approved_manually.should_not be_approved
       end
     end
 
     describe "#set_license_manually!" do
-      let(:license) { LicenseAlias.create(name: 'foolicense') }
       let(:dependency) { Dependency.create(name: 'foogem') }
 
       it "sets manual license to true" do
-        dependency.license_manual.should be_false
-        dependency.set_license_manually!('Updated')
-        dependency.license_manual.should be_true
+        dependency.should_not be_license_assigned_manually
+        dependency.set_license_manually! License.find_by_name("Updated")
+        dependency.should be_license_assigned_manually
       end
 
       it "modifies the license" do
-        LicenseAlias.should_receive(:named).with('Updated').and_return(license)
-        dependency.set_license_manually!('Updated')
-        dependency.reload.license.should == license
+        dependency.set_license_manually! License.find_by_name("Updated")
+        dependency.reload.license.name.should == 'Updated'
       end
     end
 
@@ -121,39 +137,39 @@ module LicenseFinder
       let(:dependency) { Dependency.named('some gem') }
 
       it "keeps a manually assigned license" do
-        dependency.license = LicenseAlias.named("manual")
-        dependency.license_manual = true
-
-        dependency.apply_better_license "new"
+        dependency.set_license_manually! License.find_by_name("manual")
+        dependency.apply_better_license License.find_by_name("new")
         dependency.license.name.should == "manual"
       end
 
       it "saves a new license" do
-        dependency.apply_better_license "new license"
+        dependency.apply_better_license License.find_by_name("new license")
         dependency.license.name.should == "new license"
       end
 
-      it "re-uses an existing, unassociated, license alias" do
-        dependency.license = LicenseAlias.named("old")
-
-        new_license = LicenseAlias.named("new license")
+      it "updates the license's name" do
+        dependency.license = License.find_by_name("old")
 
-        dependency.apply_better_license "new license"
-        dependency.license.should == new_license
+        dependency.apply_better_license License.find_by_name("new license")
+        dependency.license.name.should == "new license"
       end
 
-      it "updates the license's name" do
-        dependency.license = LicenseAlias.named("old")
+      it "won't update the database if the license isn't changing" do
+        # See note in PackageSaver#save
+        dependency.license = License.find_by_name("same")
+        dependency.should be_modified
+        dependency.save
+        dependency.should_not be_modified
 
-        dependency.apply_better_license "new license"
-        dependency.license.name.should == "new license"
+        dependency.apply_better_license License.find_by_name("same")
+        dependency.should_not be_modified
       end
 
       it "does not change the approval" do
-        dependency.license = LicenseAlias.named("old")
-        dependency.manually_approved = true
+        dependency.license = License.find_by_name("old")
+        dependency.approve!
 
-        dependency.apply_better_license "new license"
+        dependency.apply_better_license License.find_by_name("new license")
         dependency.should be_approved
       end
     end