license_finder 1.1.1-java → 1.2-java

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

@@ -2,6 +2,9 @@ require 'spec_helper'
 
 module LicenseFinder
   describe NPM do
+    let(:npm) { NPM.new }
+    it_behaves_like "a PackageManager"
+
     describe '.current_packages' do
       before { NPM.instance_variable_set(:@modules, nil) }
 
@@ -62,9 +65,9 @@ module LicenseFinder
             }
           }
         JSON
-        allow(NPM).to receive(:capture).with(/npm/).and_return([json, true])
+        allow(npm).to receive(:capture).with(/npm/).and_return([json, true])
 
-        current_packages = NPM.current_packages
+        current_packages = npm.current_packages
 
         expect(current_packages.map(&:name)).to eq(["depjs", "dep2js", "dep3js", "dep5js", "dep4js"])
         expect(current_packages.first).to be_a(Package)
@@ -79,39 +82,36 @@ module LicenseFinder
             }
           }
         JSON
-        allow(NPM).to receive(:capture).with(/npm/).and_return([json, true])
+        allow(npm).to receive(:capture).with(/npm/).and_return([json, true])
 
-        current_packages = NPM.current_packages
+        current_packages = npm.current_packages
 
         expect(current_packages.map(&:name)).to eq([])
       end
 
       it "fails when command fails" do
-        allow(NPM).to receive(:capture).with(/npm/).and_return('Some error', false).once
-        expect { NPM.current_packages }.to raise_error(RuntimeError)
+        allow(npm).to receive(:capture).with(/npm/).and_return('Some error', false).once
+        expect { npm.current_packages }.to raise_error(RuntimeError)
       end
 
       it "does not fail when command fails but produces output" do
-        allow(NPM).to receive(:capture).with(/npm/).and_return('{"foo":"bar"}', false).once
-        NPM.current_packages
+        allow(npm).to receive(:capture).with(/npm/).and_return('{"foo":"bar"}', false).once
+        npm.current_packages
       end
     end
 
     describe '.active?' do
-      let(:package) { double(:package_file) }
-
-      before do
-        NPM.stub(package_path: package)
-      end
+      let(:package_path) { double(:package_file) }
+      let(:npm) { NPM.new package_path: package_path }
 
       it 'is true with a package.json file' do
-        package.stub(:exist? => true)
-        expect(NPM).to be_active
+        allow(package_path).to receive_messages(:exist? => true)
+        expect(npm).to be_active
       end
 
       it 'is false without a package.json file' do
-        package.stub(:exist? => false)
-        expect(NPM).to_not be_active
+        allow(package_path).to receive_messages(:exist? => false)
+        expect(npm).to_not be_active
       end
     end
   end

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

@@ -4,7 +4,7 @@ module LicenseFinder
   describe PipPackage do
     subject { make_package({}) }
 
-    it_behaves_like "it conforms to interface required by PackageSaver"
+    it_behaves_like "a Package"
 
     def make_package(pypi_def)
       described_class.new('jasmine', '1.3.1', "jasmine/install/path", pypi_def)
@@ -49,14 +49,15 @@ module LicenseFinder
       end
     end
 
-    describe '#license' do
+    describe '#licenses' do
       describe "with valid pypi license" do
         it "returns the license from 'license' preferentially" do
           data = { "license" => "MIT", "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
 
           subject = make_package(data)
 
-          expect(subject.license.name).to eq('MIT')
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq('MIT')
         end
 
         context "when there's no explicit license" do
@@ -65,7 +66,8 @@ module LicenseFinder
 
             subject = make_package(data)
 
-            expect(subject.license.name).to eq('Apache 2.0 License')
+            expect(subject.licenses.length).to eq 1
+            expect(subject.licenses.first.name).to eq('Apache 2.0 License')
           end
 
           it "returns 'multiple licenses' if there are multiple licenses in 'classifiers'" do
@@ -73,7 +75,8 @@ module LicenseFinder
 
             subject = make_package(data)
 
-            expect(subject.license.name).to eq('multiple licenses: Apache 2.0 License, GPL')
+            expect(subject.licenses.length).to eq 2
+            expect(subject.licenses.map(&:name)).to eq ['Apache 2.0 License', 'GPL']
           end
         end
 
@@ -84,7 +87,8 @@ module LicenseFinder
 
             subject = make_package(data)
 
-            expect(subject.license.name).to eq('Apache 2.0 License')
+            expect(subject.licenses.length).to eq 1
+            expect(subject.licenses.first.name).to eq('Apache 2.0 License')
           end
         end
       end
@@ -92,17 +96,19 @@ module LicenseFinder
 
       describe "without pypi license" do
         def stub_license_files(license_files)
-          PossibleLicenseFiles.stub(:find).with("jasmine/install/path").and_return(license_files)
+          allow(PossibleLicenseFiles).to receive(:find).with("jasmine/install/path").and_return(license_files)
         end
 
         it 'returns license from file' do
-          stub_license_files [double(:license_file, license: License.find_by_name('License from file'))]
-          expect(subject.license.name).to eq('License from file')
+          stub_license_files [double(:license_file, license: License.find_by_name('License from file'), path: "/")]
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq('License from file')
         end
 
         it 'returns other if no license can be found' do
           stub_license_files []
-          expect(subject.license.name).to eq('other')
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq('other')
         end
       end
     end

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

@@ -2,9 +2,12 @@ require 'spec_helper'
 
 module LicenseFinder
   describe Pip do
+    let(:pip) { Pip.new }
+    it_behaves_like "a PackageManager"
+
     describe '.current_packages' do
       def stub_pip(stdout)
-        allow(Pip).to receive(:`).with(/python/).and_return(stdout)
+        allow(pip).to receive("`").with(/license_finder_pip.py/).and_return(stdout)
       end
 
       def stub_pypi(name, version, response)
@@ -13,48 +16,48 @@ module LicenseFinder
       end
 
       it 'fetches data from pip' do
-        stub_pip('[["jasmine", "1.3.1", "jasmine/path"], ["jasmine-core", "1.3.1", "jasmine-core/path"]]')
+        stub_pip [
+          {"name" => "jasmine", "version" => "1.3.1", "location" => "jasmine/path"},
+          {"name" => "jasmine-core", "version" => "1.3.1", "location" => "jasmine-core/path"}
+        ].to_json
         stub_pypi("jasmine", "1.3.1", status: 200, body: '{}')
         stub_pypi("jasmine-core", "1.3.1", status: 200, body: '{}')
 
-        current_packages = Pip.current_packages
+        current_packages = pip.current_packages
 
         expect(current_packages.size).to eq(2)
         expect(current_packages.first).to be_a(Package)
       end
 
       it "fetches data from pypi" do
-        stub_pip('[["jasmine", "1.3.1", "jasmine/path"]]')
+        stub_pip [{"name" => "jasmine", "version" => "1.3.1", "location" => "jasmine/path"}].to_json
         stub_pypi("jasmine", "1.3.1", status: 200, body: JSON.generate(info: {summary: "A summary"}))
 
-        expect(PipPackage).to receive(:new).with("jasmine", "1.3.1", "jasmine/path/jasmine", "summary" => "A summary")
-        Pip.current_packages
+        expect(PipPackage).to receive(:new).with("jasmine", "1.3.1", "jasmine/path/jasmine", {"summary" => "A summary"}, anything)
+        pip.current_packages
       end
 
       it "ignores pypi if it can't find useful info" do
-        stub_pip('[["jasmine", "1.3.1", "jasmine/path"]]')
+        stub_pip [{"name" => "jasmine", "version" => "1.3.1", "location" => "jasmine/path"}].to_json
         stub_pypi("jasmine", "1.3.1", status: 404, body: '')
 
-        expect(PipPackage).to receive(:new).with("jasmine", "1.3.1", "jasmine/path/jasmine", {})
-        Pip.current_packages
+        expect(PipPackage).to receive(:new).with("jasmine", "1.3.1", "jasmine/path/jasmine", {}, anything)
+        pip.current_packages
       end
     end
 
     describe '.active?' do
-      let(:requirements) { double(:requirements_file) }
-
-      before do
-        Pip.stub(requirements_path: requirements)
-      end
+      let(:package_path) { double(:requirements_file) }
+      let(:pip) { Pip.new package_path: package_path }
 
       it 'is true with a requirements.txt file' do
-        requirements.stub(:exist? => true)
-        expect(Pip).to be_active
+        allow(package_path).to receive_messages(:exist? => true)
+        expect(pip).to be_active
       end
 
       it 'is false without a requirements.txt file' do
-        requirements.stub(:exist? => false)
-        expect(Pip).to_not be_active
+        allow(package_path).to receive_messages(: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.find_by_name('license'),
+        licenses: [License.find_by_name('license')].to_set,
         children: ['child'],
         groups: [:group],
         summary: 'summary',
@@ -20,8 +20,8 @@ module LicenseFinder
       let(:dependency) { double(:dependency).as_null_object }
 
       it "find and updates relevant dependencies" do
-        Dependency.should_receive(:named).with('spec_name').and_return(dependency)
-        dependency.should_receive(:save_changes)
+        expect(Dependency).to receive(:named).with('spec_name').and_return(dependency)
+        expect(dependency).to receive(:save_changes)
         described_class.save_all([package])
       end
     end
@@ -34,7 +34,7 @@ module LicenseFinder
           summary: 'old summary',
           description: 'old desription',
           homepage: 'old homepage',
-          license_name: 'old license'
+          license_names: ["old license"].to_json
         )
         dep.add_bundler_group BundlerGroup.named("old group")
         dep.add_child Dependency.named("old child")
@@ -42,15 +42,15 @@ module LicenseFinder
         saver = described_class.new(dep, package)
         subject = saver.save
 
-        subject.id.should be
-        subject.name.should == "spec_name"
-        subject.version.should == "1.2.3"
-        subject.summary.should == "summary"
-        subject.description.should == "description"
-        subject.homepage.should == "http://example.com"
-        subject.bundler_groups.map(&:name).should == ['group']
-        subject.children.map(&:name).should == ['child']
-        subject.license.name.should == 'license'
+        expect(subject.id).to be
+        expect(subject.name).to eq("spec_name")
+        expect(subject.version).to eq("1.2.3")
+        expect(subject.summary).to eq("summary")
+        expect(subject.description).to eq("description")
+        expect(subject.homepage).to eq("http://example.com")
+        expect(subject.bundler_groups.map(&:name)).to eq(['group'])
+        expect(subject.children.map(&:name)).to eq(['child'])
+        expect(subject.licenses.first.name).to eq('license')
       end
 
       it "keeps approval" do
@@ -61,7 +61,7 @@ module LicenseFinder
         saver = described_class.new(dep, package)
         subject = saver.save
 
-        subject.should be_approved
+        expect(subject).to be_approved
       end
 
       context "to minimize db changes" do
@@ -69,23 +69,13 @@ module LicenseFinder
           # 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)
+          expect(first_run.dependency).to receive(:save).and_call_original
           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

data/spec/lib/license_finder/possible_license_file_spec.rb

@@ -7,11 +7,12 @@ module LicenseFinder
 
       context "ignoring text" do
         before do
-          subject.stub(:text).and_return('file text')
+          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
 
@@ -19,9 +20,9 @@ module LicenseFinder
 
     context "with a known license" do
       before do
-        subject.stub(:text).and_return('a known license')
+        allow(subject).to receive(:text).and_return('a known license')
 
-        License.stub(:find_by_text).with('a known license').and_return(License.find_by_name("MIT"))
+        allow(License).to receive(:find_by_text).with('a known license').and_return(License.find_by_name("MIT"))
       end
 
       its(:license) { should == License.find_by_name("MIT") }
@@ -29,7 +30,7 @@ module LicenseFinder
 
     context "with an unknown license" do
       before do
-        subject.stub(:text).and_return('')
+        allow(subject).to receive(:text).and_return('')
       end
 
       its(:license) { should be_nil }

data/spec/lib/license_finder/possible_license_files_spec.rb

@@ -7,36 +7,42 @@ module LicenseFinder
     end
 
     describe "#find" do
+      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')
-        subject.find.should == []
+        expect(subject.find).to eq([])
       end
 
       it "includes files with names like LICENSE, License or COPYING" do
         subject = described_class.new(fixture_path('license_names'))
 
-        subject.find.map(&:file_path).should =~
+        expect(subject.find.map(&:file_path)).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'))
 
-        subject.find.map(&:file_path).should =~ %w[vendor/LICENSE]
+        expect(subject.find.map(&:file_path)).to match_array(%w[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
 
-        found_license_files.map(&:file_path).should =~ %w[
+        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
           COPYING
           LICENSE/LICENSE
-        ]
+        ])
       end
 
       it "handles non UTF8 encodings" do

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

@@ -9,7 +9,7 @@ module LicenseFinder
           'version' => '1.0',
           'summary' => 'Summary',
           'description' => 'Description',
-          'license' => License.find_by_name('MIT')
+          'licenses' => [License.find_by_name('MIT')].to_set
         )
       end
 
@@ -19,14 +19,14 @@ module LicenseFinder
           'version' => '1.0',
           'summary' => 'Summary',
           'description' => 'Description',
-          'license' => License.find_by_name('MIT')
+          'licenses' => [License.find_by_name('MIT')].to_set
         )
       end
 
       subject { DetailedTextReport.new([dep2, dep1]).to_s }
 
       it 'should generate a text report with the name, version, license, summary and description of each dependency, sorted by name' do
-        should == "gem_a,1.0,MIT,Summary,Description\ngem_b,1.0,MIT,Summary,Description\n"
+        is_expected.to eq("gem_a,1.0,MIT,Summary,Description\ngem_b,1.0,MIT,Summary,Description\n")
       end
     end
   end

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

@@ -7,7 +7,7 @@ module LicenseFinder
       let(:dependency_name) { "the-name" }
       let(:dependency) do
         dep = Dependency.create name: dependency_name
-        dep.apply_better_license License.find_by_name("MIT")
+        dep.set_licenses [License.find_by_name("MIT")].to_set
         dep
       end
 
@@ -17,66 +17,66 @@ module LicenseFinder
         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"
+          is_expected.to have_selector ".approved"
+          is_expected.not_to have_selector ".action-items"
         end
 
         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"
+          expect(deps).to have_content "MIT"
+          expect(deps).to have_content "the-approver"
+          expect(deps).to have_content "the-approval-note"
+          expect(deps).to have_selector "time"
         end
       end
 
       context "when the dependency is whitelisted" do
-        before { dependency.stub(whitelisted?: true) }
+        before { allow(dependency).to receive_messages(whitelisted?: true) }
 
         it "should show approved dependencies without action items" do
-          should have_selector ".approved"
-          should_not have_selector ".action-items"
+          is_expected.to have_selector ".approved"
+          is_expected.not_to have_selector ".action-items"
         end
 
         it "shows the license" do
           deps = subject.find ".dependencies"
-          deps.should have_content "MIT"
+          expect(deps).to have_content "MIT"
         end
       end
 
       context "when the dependency is not approved" do
         before {
-          dependency.license = License.find_by_name('GPL')
+          dependency.licenses = [License.find_by_name('GPL')].to_set
           dependency.manual_approval = nil
         }
 
         it "should show unapproved dependencies with action items" do
-          should have_selector ".unapproved"
-          should have_selector ".action-items li"
+          is_expected.to have_selector ".unapproved"
+          is_expected.to have_selector ".action-items li"
         end
       end
 
       context "when the gem has many relationships" do
         before do
-          dependency.stub(bundler_groups: [double(name: "foo group")],
+          allow(dependency).to receive_messages(bundler_groups: [double(name: "foo group")],
                           parents: [double(name: "foo parent")],
                           children: [double(name: "foo child")])
         end
 
         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"
+          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 child"
         end
       end
 
       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:"
+          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:"
         end
       end
     end