license_finder 1.2 → 2.0.0.rc2

data/spec/lib/license_finder/package_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe Package do
+    subject do
+      described_class.new(
+        "a package",
+        "1.3.1",
+        summary: "a summary",
+        description: "a description",
+        homepage: "a homepage",
+        groups: %w[dev test],
+        children: %w[child-1 child2],
+        install_path: "some/package/path",
+        spec_licenses: %w[MIT GPL]
+      )
+    end
+
+    it_behaves_like "a Package"
+
+    its(:name) { should == "a package" }
+    its(:version) { should == "1.3.1" }
+    its(:summary) { should == "a summary" }
+    its(:description) { should == "a description" }
+    its(:homepage) { should == "a homepage" }
+    its(:groups) { should == %w[dev test] }
+    its(:children) { should == %w[child-1 child2] }
+    its(:install_path) { should eq "some/package/path" }
+
+    it "has defaults" do
+      subject = described_class.new(nil, nil)
+      expect(subject.name).to be_nil
+      expect(subject.version).to be_nil
+      expect(subject.summary).to eq ""
+      expect(subject.description).to eq ""
+      expect(subject.homepage).to eq ""
+      expect(subject.groups).to eq []
+      expect(subject.children).to eq []
+      expect(subject.install_path).to be_nil
+      expect(subject.license_names_from_spec).to eq []
+      expect(subject.licenses.map(&:name)).to eq ['unknown']
+    end
+
+    describe '#licenses' do
+      def stub_license_files(*license_names)
+        license_files = license_names.map do |license_name|
+          double(:file, license: License.find_by_name(license_name), path: "some/path")
+        end
+        allow(PossibleLicenseFiles).to receive(:find).
+          with("some/package/path").and_return(license_files)
+      end
+
+      it "are not required" do
+        subject = described_class.new(nil, nil)
+        expect(subject.licenses.map(&:name)).to eq ['unknown']
+      end
+
+      describe "decided by user" do
+        it "returns all decided licenses" do
+          subject = described_class.new(nil, nil)
+          subject.decide_on_license(License.find_by_name("MIT"))
+          subject.decide_on_license(License.find_by_name("GPL"))
+          expect(subject.licenses.map(&:name)).to match_array ["MIT", "GPL"]
+        end
+
+        it "de-duplicates across license aliases" do
+          subject = described_class.new(nil, nil)
+          subject.decide_on_license(License.find_by_name("MIT"))
+          subject.decide_on_license(License.find_by_name("Expat"))
+          expect(subject.licenses.map(&:name)).to eq ["MIT"]
+        end
+
+        it "trumps licenses from the spec" do
+          subject = described_class.new(nil, nil, spec_licenses: ["GPL"])
+          subject.decide_on_license(License.find_by_name("MIT"))
+          expect(subject.licenses.map(&:name)).to eq ["MIT"]
+        end
+
+        it "trumps licenses from the install path" do
+          stub_license_files 'Detected License'
+          subject = described_class.new(nil, nil, install_path: "some/package/path")
+          subject.decide_on_license(License.find_by_name("MIT"))
+          expect(subject.licenses.map(&:name)).to eq ["MIT"]
+        end
+      end
+
+      describe "from the spec" do
+        it "converts the names to licenses" do
+          subject = described_class.new(nil, nil, spec_licenses: ["MIT", "GPL"])
+          expect(subject.licenses.map(&:name)).to match_array ["MIT", "GPL"]
+        end
+
+        it "de-duplicates across license aliases" do
+          subject = described_class.new(nil, nil, spec_licenses: ["MIT", "Expat"])
+          expect(subject.licenses.map(&:name)).to eq ["MIT"]
+        end
+
+        it "trumps licenses from the install path" do
+          stub_license_files 'Detected License'
+          subject = described_class.new(nil, nil, spec_licenses: ["MIT"], install_path: "some/package/path")
+          expect(subject.licenses.map(&:name)).to eq ["MIT"]
+        end
+      end
+
+      describe "from the install path" do
+        it "uses the licenses reported by files in the install path" do
+          stub_license_files 'MIT', 'GPL'
+          subject = described_class.new(nil, nil, install_path: "some/package/path")
+          expect(subject.licenses.map(&:name)).to eq ["MIT", "GPL"]
+        end
+
+        it "de-duplicates across license aliases" do
+          stub_license_files 'MIT', 'Expat'
+          subject = described_class.new(nil, nil, install_path: "some/package/path")
+          expect(subject.licenses.map(&:name)).to eq ["MIT"]
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/license_finder/possible_license_file_spec.rb

@@ -3,20 +3,19 @@ require 'spec_helper'
 module LicenseFinder
   describe PossibleLicenseFile do
     context "file parsing" do
-      subject { described_class.new('root', 'root/nested/path') }
+      subject { described_class.new('root/nested/path') }
 
       context "ignoring text" do
         before do
           allow(subject).to receive(: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
         its(:path) { should == 'root/nested/path' }
       end
     end
 
-    subject { described_class.new('gem', 'gem/license/path') }
+    subject { described_class.new('gem/license/path') }
 
     context "with a known license" do
       before do

data/spec/lib/license_finder/possible_license_files_spec.rb

@@ -3,51 +3,47 @@ require 'spec_helper'
 module LicenseFinder
   describe PossibleLicenseFiles do
     def fixture_path(fixture)
-      Pathname.new(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec', 'fixtures', fixture)).realpath.to_s
+      Pathname.new(__FILE__).dirname.join('..', '..', 'fixtures', fixture)
     end
 
     describe "#find" do
+      def files_in(fixture)
+        root_path = fixture_path(fixture)
+        subject = described_class.find(root_path.to_s)
+
+        subject.map do |f|
+          Pathname(f.path).relative_path_from(root_path).to_s
+        end
+      end
+
       it "is empty if passed a nil install path" do
         subject = described_class.new nil
         expect(subject.find).to eq([])
       end
 
       it "is empty if there aren't any license files" do
-        subject = described_class.new('/not/a/dir')
-        expect(subject.find).to eq([])
+        expect(files_in('not/a/dir')).to eq([])
       end
 
-      it "includes files with names like LICENSE, License or COPYING" do
-        subject = described_class.new(fixture_path('license_names'))
-
-        expect(subject.find.map(&:file_path)).to match_array(
+      it "includes files with names like LICENSE, README or COPYING" do
+        expect(files_in('license_names')).to match_array(
         %w[COPYING.txt LICENSE Mit-License README.rdoc Licence.rdoc]
         )
       end
 
       it "includes files deep in the hierarchy" do
-        subject = described_class.new(fixture_path('nested_gem'))
-
-        expect(subject.find.map(&:file_path)).to match_array(%w[vendor/LICENSE])
+        expect(files_in('nested_gem')).to eq(['vendor/LICENSE'])
       end
 
-      it "includes both files nested inside LICENSE directory and top level files" do
-        subject = described_class.new(fixture_path('license_directory'))
-        found_license_files = subject.find
-
-        expect(found_license_files.map(&:file_path)).to match_array(%w[
-          LICENSE/BSD-2-Clause.txt
-          LICENSE/GPL-2.0.txt
-          LICENSE/MIT.txt
-          LICENSE/RUBY.txt
+      it "includes files nested inside LICENSE directory" do
+        expect(files_in('license_directory')).to match_array(%w[
           COPYING
-          LICENSE/LICENSE
+          LICENSE/Apache.txt
         ])
       end
 
       it "handles non UTF8 encodings" do
-        subject = described_class.new(fixture_path('utf8_gem'))
-        expect { subject.find }.not_to raise_error
+        expect { files_in('utf8_gem') }.not_to raise_error
       end
     end
   end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe CsvReport do
+    it "accepts a custom list of columns" do
+      dep = Package.new('gem_a', '1.0')
+      subject = described_class.new([dep], columns: %w[name version])
+      expect(subject.to_s).to eq("gem_a,1.0\n")
+    end
+
+    it "understands many columns" do
+      dep = Package.new('gem_a', '1.0', description: "A description", summary: "A summary")
+      dep.decide_on_license(License.find_by_name("MIT"))
+      dep.decide_on_license(License.find_by_name("GPL"))
+      dep.whitelisted!
+      subject = described_class.new([dep], columns: %w[name version licenses approved summary description])
+      expect(subject.to_s).to eq("gem_a,1.0,\"MIT,GPL\",Approved,A summary,A description\n")
+    end
+
+    it "ignores unknown columns" do
+      dep = Package.new('gem_a', '1.0')
+      subject = described_class.new([dep], columns: %w[unknown])
+      expect(subject.to_s).to eq("\n")
+    end
+  end
+end

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

@@ -4,17 +4,22 @@ require "capybara"
 module LicenseFinder
   describe HtmlReport do
     describe "#to_s" do
-      let(:dependency_name) { "the-name" }
       let(:dependency) do
-        dep = Dependency.create name: dependency_name
-        dep.set_licenses [License.find_by_name("MIT")].to_set
+        dep = Package.new("the-dep")
+        dep.decide_on_license License.find_by_name("MIT")
         dep
       end
+      let(:dependencies) { [dependency] }
 
-      subject { Capybara.string(HtmlReport.new([dependency]).to_s) }
+      subject { Capybara.string(HtmlReport.new(dependencies, project_name: "project name").to_s) }
+
+      it "should show the project name" do
+        title = subject.find "h1"
+        expect(title).to have_text "project name"
+      end
 
       context "when the dependency is manually approved" do
-        before { dependency.approve! "the-approver", "the-approval-note" }
+        before { dependency.approved_manually!(Decisions::TXN.new("the-approver", "the-approval-note", Time.now.utc)) }
 
         it "should show approved dependencies without action items" do
           is_expected.to have_selector ".approved"
@@ -31,7 +36,7 @@ module LicenseFinder
       end
 
       context "when the dependency is whitelisted" do
-        before { allow(dependency).to receive_messages(whitelisted?: true) }
+        before { dependency.whitelisted! }
 
         it "should show approved dependencies without action items" do
           is_expected.to have_selector ".approved"
@@ -45,38 +50,50 @@ module LicenseFinder
       end
 
       context "when the dependency is not approved" do
-        before {
-          dependency.licenses = [License.find_by_name('GPL')].to_set
-          dependency.manual_approval = nil
-        }
-
         it "should show unapproved dependencies with action items" do
           is_expected.to have_selector ".unapproved"
           is_expected.to have_selector ".action-items li"
         end
       end
 
+      context "when the gem has a group" do
+        let(:dependency) do
+          Package.new(nil, nil, groups: ["foo group"])
+        end
+
+        it "should show the group" do
+          is_expected.to have_text "(foo group)"
+        end
+      end
+
+      context "when the gem does not have a group" do
+        it "should not show the group" do
+          is_expected.not_to have_text "()"
+        end
+      end
+
       context "when the gem has many relationships" do
-        before do
-          allow(dependency).to receive_messages(bundler_groups: [double(name: "foo group")],
-                          parents: [double(name: "foo parent")],
-                          children: [double(name: "foo child")])
+        let(:dependencies) do
+          grandparent = Package.new("foo grandparent", nil, children: ["foo parent"])
+          parent      = Package.new("foo parent",      nil, children: ["foo child"])
+          child       = Package.new("foo child")
+          pm = PackageManager.new
+          allow(pm).to receive(:current_packages) { [grandparent, parent, child] }
+          pm.current_packages_with_relations
         end
 
         it "should show the relationships" do
-          is_expected.to have_text "(foo group)"
-          is_expected.to have_text "#{dependency_name} is required by:"
-          is_expected.to have_text "foo parent"
-          is_expected.to have_text "#{dependency_name} relies on:"
+          is_expected.to have_text "foo parent is required by:"
+          is_expected.to have_text "foo grandparent"
+          is_expected.to have_text "foo parent relies on:"
           is_expected.to have_text "foo child"
         end
       end
 
       context "when the gem has no relationships" do
         it "should not show any relationships" do
-          is_expected.not_to have_text "()"
-          is_expected.not_to have_text "#{dependency_name} is required by:"
-          is_expected.not_to have_text "#{dependency_name} relies on:"
+          is_expected.not_to have_text "is required by:"
+          is_expected.not_to have_text "relies on:"
         end
       end
     end

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

@@ -4,27 +4,19 @@ module LicenseFinder
   describe MarkdownReport do
     describe '#to_s' do
       let(:dep1) do
-        Dependency.new(
-          'name' => 'gem_a',
-          'version' => '1.0',
-          'licenses' => [License.find_by_name('other')].to_set
-        )
+        Package.new('gem_a', '1.0')
       end
 
       let(:dep2) do
-        dependency = Dependency.create(
-          'name' => 'gem_b',
-          'version' => '2.3',
-          'licenses' => [License.find_by_name('BSD')].to_set
-        )
-        dependency.approve!
-        dependency
+        result = Package.new('gem_b', '2.3')
+        result.decide_on_license(License.find_by_name('BSD'))
+        result.approved_manually!(double(:approval).as_null_object)
+        result
       end
 
-      subject { MarkdownReport.new([dep2, dep1]).to_s }
+      subject { MarkdownReport.new([dep2, dep1], project_name: "new_project_name").to_s }
 
       it 'should have the correct header' do
-        LicenseFinder.config.project_name = "new_project_name"
         is_expected.to match "# new_project_name"
       end
 
@@ -34,12 +26,12 @@ module LicenseFinder
       end
 
       it "should list the unapproved dependency" do
-        is_expected.to match "href='#gem_a'"
+        is_expected.to match 'href="#gem_a"'
       end
 
       it "should display a summary" do
         is_expected.to match "## Summary"
-        is_expected.to match /\s+\* 1 other/
+        is_expected.to match /\s+\* 1 unknown/
         is_expected.to match /\s+\* 1 BSD/
       end
 

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

@@ -4,25 +4,34 @@ module LicenseFinder
   describe TextReport do
     describe '#to_s' do
       let(:dep1) do
-        Dependency.new(
-          'name' => 'gem_a',
-          'version' => '1.0',
-          'licenses' => [License.find_by_name('MIT')].to_set
-        )
+        result = Package.new('gem_a', '1.0')
+        result.decide_on_license(License.find_by_name('MIT'))
+        result
       end
 
       let(:dep2) do
-        Dependency.new(
-          'name' => 'gem_b',
-          'version' => '1.0',
-          'licenses' => [License.find_by_name('MIT')].to_set
-        )
+        result = Package.new('gem_b', '1.0')
+        result.decide_on_license(License.find_by_name('MIT'))
+        result
       end
 
-      subject { TextReport.new([dep2, dep1]).to_s }
+      let(:dep3) do
+        result = Package.new('gem_c', '2.0')
+        result.decide_on_license(License.find_by_name('MIT'))
+        result.decide_on_license(License.find_by_name('BSD'))
+        result
+      end
+
+      subject { described_class.new([dep3, dep2, dep1]).to_s }
 
       it 'should generate a text report with the name, version and license of each dependency, sorted by name' do
-        is_expected.to eq("gem_a, 1.0, MIT\ngem_b, 1.0, MIT")
+        is_expected.to eq("gem_a, 1.0, MIT\ngem_b, 1.0, MIT\ngem_c, 2.0, \"MIT, BSD\"\n")
+      end
+
+      it 'prints a warning message for packages that have not been installed' do
+        dep = Package.new('gem_d', '2.0', missing: true)
+        report = described_class.new([dep]).to_s
+        expect(report).to eq("gem_d, 2.0, \"This package is not installed. Please install to determine licenses.\"\n")
       end
     end
   end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require 'license_finder'
 require 'rspec'
 require 'webmock/rspec'
 require 'rspec/its'
+require 'fileutils'
 
 ENV['test_run'] = true.to_s
 
@@ -18,10 +19,6 @@ RSpec.configure do |config|
 end
 
 RSpec.configure do |config|
-  config.around do |example|
-    LicenseFinder::DB.transaction(rollback: :always) { example.run }
-  end
-
   config.after(:suite) do
     ["./doc", "./elsewhere", "./test path", "./config"].each do |tmp_dir|
       FileUtils.rm_rf(tmp_dir)