license_finder 1.1.1-java → 1.2-java

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

@@ -7,7 +7,7 @@ module LicenseFinder
     end
     let(:license_text) { nil }
 
-    it_behaves_like "it conforms to interface required by PackageSaver"
+    it_behaves_like "a Package"
 
     its(:name) { should == "Name" }
     its(:version) { should == "1.0.0" }
@@ -17,7 +17,7 @@ module LicenseFinder
     its(:groups) { should == [] }
     its(:children) { should == [] }
 
-    describe '#license' do
+    describe '#licenses' do
       context "when there's a license" do
         let(:license_text) { "LicenseText" }
 
@@ -25,18 +25,21 @@ module LicenseFinder
           license = double(:license, name: "LicenseName")
           allow(License).to receive(:find_by_text).with(license_text).and_return(license)
 
-          expect(subject.license.name).to eq "LicenseName"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "LicenseName"
         end
 
         it "returns other if the license can't be found by text" do
           allow(License).to receive(:find_by_text).with(license_text).and_return(nil)
 
-          expect(subject.license.name).to eq "other"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "other"
         end
       end
 
       it "returns other when there's no license" do
-        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/cocoa_pods_spec.rb

@@ -2,19 +2,20 @@ require 'spec_helper'
 
 module LicenseFinder
   describe CocoaPods do
+    let(:cocoa_pods) { CocoaPods.new }
+    it_behaves_like "a PackageManager"
+
     def stub_acknowledgments(hash = {})
-      plist_json = %{
-        {
-          "PreferenceSpecifiers": [
-            {
-              "FooterText": "#{hash[:license]}",
-              "Title": "#{hash[:name]}"
-            }
-          ]
-        }
+      plist = {
+        "PreferenceSpecifiers" => [
+          {
+            "FooterText" => hash[:license],
+            "Title" => hash[:name]
+          }
+        ]
       }
 
-      expect(described_class).to receive(:`).with(/plutil/).and_return(plist_json)
+      expect(cocoa_pods).to receive(:read_plist).and_return(plist)
     end
 
     def stub_lockfile(pods)
@@ -34,7 +35,7 @@ module LicenseFinder
         expect(CocoaPodsPackage).to receive(:new).with("JSONKit", "1.5pre", anything)
         expect(CocoaPodsPackage).to receive(:new).with("OpenUDID", "1.0.0", anything)
 
-        current_packages = CocoaPods.current_packages
+        current_packages = cocoa_pods.current_packages
 
         expect(current_packages.size).to eq(3)
       end
@@ -45,7 +46,7 @@ module LicenseFinder
 
         expect(CocoaPodsPackage).to receive(:new).with("Dependency Name", "1.0", "License Text")
 
-        CocoaPods.current_packages
+        cocoa_pods.current_packages
       end
 
       it "handles no licenses" do
@@ -54,25 +55,22 @@ module LicenseFinder
 
         expect(CocoaPodsPackage).to receive(:new).with("Dependency Name", "1.0", nil)
 
-        CocoaPods.current_packages
+        cocoa_pods.current_packages
       end
     end
 
     describe '.active?' do
-      let(:package) { double(:package_file) }
-
-      before do
-        CocoaPods.stub(package_path: package)
-      end
+      let(:package_path) { double(:package_file) }
+      let(:cocoa_pods) { CocoaPods.new package_path: package_path }
 
       it 'is true with a Podfile file' do
-        package.stub(:exist? => true)
-        expect(CocoaPods).to be_active
+        allow(package_path).to receive_messages(:exist? => true)
+        expect(cocoa_pods).to be_active
       end
 
       it 'is false without a Podfile file' do
-        package.stub(:exist? => false)
-        expect(CocoaPods).to_not be_active
+        allow(package_path).to receive_messages(:exist? => false)
+        expect(cocoa_pods).to_not be_active
       end
     end
   end

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

@@ -14,15 +14,16 @@ module LicenseFinder
       )
     end
 
-    it_behaves_like "it conforms to interface required by PackageSaver"
+    it_behaves_like "a Package"
 
     its(:name) { should == "logback-classic" }
     its(:version) { should == "1.1.1" }
     its(:description) { should == "" }
 
-    describe "#license" do
+    describe "#licenses" do
       it "returns the license if found" do
-        subject.license.name.should == "Eclipse Public License - v 1.0"
+        expect(subject.licenses.length).to eq 1
+        expect(subject.licenses.first.name).to eq "Eclipse Public License - v 1.0"
       end
 
       context "when there are multiple licenses" do
@@ -40,7 +41,8 @@ module LicenseFinder
         end
 
         it "returns 'multiple licenses'" do
-          subject.license.name.should == 'multiple licenses: Eclipse Public License - v 1.0, GNU Lesser General Public License'
+          expect(subject.licenses.length).to eq 2
+          expect(subject.licenses.map(&:name)).to eq ['Eclipse Public License - v 1.0', 'GNU Lesser General Public License']
         end
       end
 
@@ -56,7 +58,8 @@ module LicenseFinder
         end
 
         it "returns 'other' otherwise" do
-          subject.license.name.should == "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/gradle_spec.rb

@@ -2,6 +2,9 @@ require 'spec_helper'
 
 module LicenseFinder
   describe Gradle do
+    let(:gradle) { Gradle.new }
+    it_behaves_like "a PackageManager"
+
     def license_xml(xml)
       <<-resp
         <dependencies>
@@ -13,7 +16,7 @@ module LicenseFinder
     describe '.current_packages' do
       before do
         allow(LicenseFinder.config).to receive(:gradle_command) { 'gradlefoo' }
-        expect(described_class).to receive(:`).with(/gradlefoo downloadLicenses/)
+        expect(gradle).to receive('`').with(/gradlefoo downloadLicenses/)
       end
 
       it 'lists all the current packages' do
@@ -28,9 +31,9 @@ module LicenseFinder
           </dependency>
         """)
         fake_file = double(:license_report, read: license_xml)
-        allow(Gradle).to receive(:license_report).and_return(fake_file)
+        allow(gradle).to receive(:license_report).and_return(fake_file)
 
-        current_packages = described_class.current_packages
+        current_packages = gradle.current_packages
 
         expect(current_packages.size).to eq(2)
         expect(current_packages.first).to be_a(Package)
@@ -45,10 +48,10 @@ module LicenseFinder
         """)
 
         fake_file = double(:license_report, read: license_xml)
-        allow(Gradle).to receive(:license_report).and_return(fake_file)
+        allow(gradle).to receive(:license_report).and_return(fake_file)
 
-        GradlePackage.should_receive(:new).with("license" => [{"name" => "License 1"}, {"name" => "License 2"}])
-        Gradle.current_packages
+        expect(GradlePackage).to receive(:new).with({"license" => [{"name" => "License 1"}, {"name" => "License 2"}]}, anything)
+        gradle.current_packages
       end
 
       it "handles no licenses" do
@@ -59,36 +62,33 @@ module LicenseFinder
         """)
 
         fake_file = double(:license_report, read: license_xml)
-        allow(Gradle).to receive(:license_report).and_return(fake_file)
+        allow(gradle).to receive(:license_report).and_return(fake_file)
 
-        GradlePackage.should_receive(:new).with("license" => [])
-        Gradle.current_packages
+        expect(GradlePackage).to receive(:new).with({"license" => []}, anything)
+        gradle.current_packages
       end
 
       it "handles an empty list of licenses" do
         license_xml = license_xml("")
 
         fake_file = double(:license_report, read: license_xml)
-        allow(Gradle).to receive(:license_report).and_return(fake_file)
-        Gradle.current_packages
+        allow(gradle).to receive(:license_report).and_return(fake_file)
+        gradle.current_packages
       end
     end
 
     describe '.active?' do
-      let(:package) { double(:package_file) }
-
-      before do
-        Gradle.stub(package_path: package)
-      end
+      let(:package_path) { double(:package_file) }
+      let(:gradle) { Gradle.new package_path: package_path }
 
       it 'is true with a build.gradle file' do
-        package.stub(:exist? => true)
-        expect(Gradle).to be_active
+        allow(package_path).to receive_messages(:exist? => true)
+        expect(gradle).to be_active
       end
 
       it 'is false without a build.gradle file' do
-        package.stub(:exist? => false)
-        expect(Gradle).to_not be_active
+        allow(package_path).to receive_messages(:exist? => false)
+        expect(gradle).to_not be_active
       end
     end
   end

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

@@ -16,15 +16,16 @@ module LicenseFinder
       )
     end
 
-    it_behaves_like "it conforms to interface required by PackageSaver"
+    it_behaves_like "a Package"
 
     its(:name) { should == "hamcrest-core" }
     its(:version) { should == "4.11" }
     its(:description) { should == "" }
 
-    describe "#license" do
+    describe "#licenses" do
       it "returns the license if found" do
-        subject.license.name.should == "Common Public License Version 1.0"
+        expect(subject.licenses.length).to eq 1
+        expect(subject.licenses.first.name).to eq "Common Public License Version 1.0"
       end
 
       context "when there are multiple licenses" do
@@ -46,7 +47,8 @@ module LicenseFinder
         end
 
         it "returns 'multiple licenses'" do
-          subject.license.name.should == 'multiple licenses: Common Public License Version 1.0, Apache 2'
+          expect(subject.licenses.length).to eq 2
+          expect(subject.licenses.map(&:name)).to eq ['Common Public License Version 1.0', 'Apache 2']
         end
       end
 
@@ -62,7 +64,8 @@ module LicenseFinder
         end
 
         it "returns 'other' otherwise" do
-          subject.license.name.should == "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/maven_spec.rb

@@ -2,6 +2,9 @@ require 'spec_helper'
 
 module LicenseFinder
   describe Maven do
+    let(:maven) { Maven.new }
+    it_behaves_like "a PackageManager"
+
     def license_xml(xml)
       <<-resp
         <?xml version="1.0" encoding="UTF-8" standalone="no"?>
@@ -15,7 +18,7 @@ module LicenseFinder
 
     describe '.current_packages' do
       before do
-        expect(described_class).to receive(:`).with(/mvn/)
+        expect(maven).to receive('`').with(/mvn/)
       end
 
       it 'lists all the current packages' do
@@ -45,9 +48,9 @@ module LicenseFinder
            </dependency>
         """)
         fake_file = double(:license_report, read: license_xml)
-        allow(Maven).to receive(:license_report).and_return(fake_file)
+        allow(maven).to receive(:license_report).and_return(fake_file)
 
-        current_packages = Maven.current_packages
+        current_packages = maven.current_packages
 
         expect(current_packages.size).to eq(2)
         expect(current_packages.first).to be_a(Package)
@@ -68,10 +71,10 @@ module LicenseFinder
         """)
 
         fake_file = double(:license_report, read: license_xml)
-        allow(Maven).to receive(:license_report).and_return(fake_file)
+        allow(maven).to receive(:license_report).and_return(fake_file)
 
-        MavenPackage.should_receive(:new).with("licenses" => [{"name" => "License 1"}, {"name" => "License 2"}])
-        Maven.current_packages
+        expect(MavenPackage).to receive(:new).with({"licenses" => [{"name" => "License 1"}, {"name" => "License 2"}]}, anything)
+        maven.current_packages
       end
 
       it "handles no licenses" do
@@ -84,28 +87,25 @@ module LicenseFinder
         """)
 
         fake_file = double(:license_report, read: license_xml)
-        allow(Maven).to receive(:license_report).and_return(fake_file)
+        allow(maven).to receive(:license_report).and_return(fake_file)
 
-        MavenPackage.should_receive(:new).with("licenses" => {})
-        Maven.current_packages
+        expect(MavenPackage).to receive(:new).with({"licenses" => {}}, anything)
+        maven.current_packages
       end
     end
 
     describe '.active?' do
-      let(:package) { double(:package_file) }
-
-      before do
-        allow(Maven).to receive(:package_path).and_return(package)
-      end
+      let(:package_path) { double(:package_file) }
+      let(:maven) { Maven.new package_path: package_path }
 
       it 'is true with a pom.xml file' do
-        allow(package).to receive(:exist?).and_return(true)
-        expect(Maven.active?).to eq(true)
+        allow(package_path).to receive(:exist?).and_return(true)
+        expect(maven.active?).to eq(true)
       end
 
       it 'is false without a pom.xml file' do
-        allow(package).to receive(:exist?).and_return(false)
-        expect(Maven.active?).to eq(false)
+        allow(package_path).to receive(:exist?).and_return(false)
+        expect(maven.active?).to eq(false)
       end
     end
   end

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

@@ -13,7 +13,7 @@ module LicenseFinder
       )
     end
 
-    it_behaves_like "it conforms to interface required by PackageSaver"
+    it_behaves_like "a Package"
 
     its(:name) { should == "jasmine-node" }
     its(:version) { should == "1.3.1" }
@@ -23,9 +23,9 @@ module LicenseFinder
     its(:groups) { should == [] }
     its(:children) { should == [] }
 
-    describe '#license' do
+    describe '#licenses' do
       def stub_license_files(license_files)
-        PossibleLicenseFiles.stub(:find).with("some/node/package/path").and_return(license_files)
+        allow(PossibleLicenseFiles).to receive(:find).with("some/node/package/path").and_return(license_files)
       end
 
       let(:node_module1) { {"license" => "MIT", "path" => "/some/path"} }
@@ -35,11 +35,25 @@ module LicenseFinder
       let(:misdeclared_node_module) { {"licenses" => {"type" => "MIT"}} }
 
       it 'finds the license for both license structures' do
-        NpmPackage.new(node_module1).license.name.should eq("MIT")
-        NpmPackage.new(node_module2).license.name.should eq("BSD")
-        NpmPackage.new(node_module3).license.name.should eq("Python Software Foundation License")
-        NpmPackage.new(node_module4).license.name.should eq("MIT")
-        NpmPackage.new(misdeclared_node_module).license.name.should eq("MIT")
+        package = NpmPackage.new(node_module1)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("MIT")
+
+        package = NpmPackage.new(node_module2)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("BSD")
+
+        package = NpmPackage.new(node_module3)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("Python Software Foundation License")
+
+        package = NpmPackage.new(node_module4)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("MIT")
+
+        package = NpmPackage.new(misdeclared_node_module)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("MIT")
       end
 
       context "regardless of whether there are licenses in files" do
@@ -49,38 +63,43 @@ module LicenseFinder
 
         it "returns the license from the spec if there is only one unique license" do
           package = NpmPackage.new({ "licenses" => ["MIT", "Expat"], "path" => "/path/to/thing" })
-          expect(package.license.name).to eq("MIT")
+          expect(package.licenses.length).to eq 1
+          expect(package.licenses.first.name).to eq("MIT")
         end
 
         it "returns 'multiple licenses' if there's more than one license" do
           package = NpmPackage.new({ "licenses" => ["MIT", "BSD"], "path" => "/some/path" })
-          expect(package.license.name).to eq("multiple licenses: MIT, BSD")
+          expect(package.licenses.length).to eq 2
+          expect(package.licenses.map(&:name)).to eq %w(MIT BSD)
         end
       end
 
       context "when there is nothing in the spec" do
         it "returns a license in a file if only one unique license detected" do
           stub_license_files([
-            double(:first_file, license: License.find_by_name('MIT')),
-            double(:second_file, license: License.find_by_name('Expat'))
+            double(:first_file, license: License.find_by_name('MIT'), path: "/"),
+            double(:second_file, license: License.find_by_name('Expat'), path: "/")
           ])
 
-          subject.license.name.should == "MIT"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "MIT"
         end
 
         it "returns 'other' if there are no licenses in files" do
           stub_license_files []
 
-          subject.license.name.should == "other"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "other"
         end
 
         it "returns 'other' if there are many licenses in files" do
           stub_license_files([
-            double(:first_file, license: License.find_by_name('First Detected License')),
-            double(:second_file, license: License.find_by_name('Second Detected License'))
+            double(:first_file, license: License.find_by_name('First Detected License'), path: "/"),
+            double(:second_file, license: License.find_by_name('Second Detected License'), path: "/")
           ])
 
-          subject.license.name.should == "multiple licenses: First Detected License, Second Detected License"
+          expect(subject.licenses.length).to eq 2
+          expect(subject.licenses.map(&:name)).to eq ["First Detected License", "Second Detected License"]
         end
       end
     end