license_finder 1.2 → 2.0.0.rc2

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

@@ -13,14 +13,26 @@ module LicenseFinder
       resp
     end
 
+    def stub_license_report(dependencies, package_manager = gradle)
+      license_xml = license_xml(dependencies)
+      fake_file = double(:license_report, read: license_xml)
+      allow(package_manager).to receive(:license_report).and_return(fake_file)
+    end
+
     describe '.current_packages' do
       before do
-        allow(LicenseFinder.config).to receive(:gradle_command) { 'gradlefoo' }
+        allow(gradle).to receive('`').with(/gradle downloadLicenses/)
+      end
+
+      it "uses custom gradle command, if provided" do
+        gradle = Gradle.new(gradle_command: "gradlefoo")
+        stub_license_report("", gradle)
         expect(gradle).to receive('`').with(/gradlefoo downloadLicenses/)
+        gradle.current_packages
       end
 
       it 'lists all the current packages' do
-        license_xml = license_xml("""
+        stub_license_report("""
           <dependency name='org.springframework:spring-aop:4.0.1.RELEASE'>
             <file>spring-aop-4.0.1.RELEASE.jar</file>
             <license name='The Apache Software License, Version 2.0' url='http://www.apache.org/licenses/LICENSE-2.0.txt' />
@@ -30,8 +42,6 @@ module LicenseFinder
             <license name='The Apache Software License, Version 2.0' url='http://www.apache.org/licenses/LICENSE-2.0.txt' />
           </dependency>
         """)
-        fake_file = double(:license_report, read: license_xml)
-        allow(gradle).to receive(:license_report).and_return(fake_file)
 
         current_packages = gradle.current_packages
 
@@ -40,39 +50,24 @@ module LicenseFinder
       end
 
       it "handles multiple licenses" do
-        license_xml = license_xml("""
+        stub_license_report("""
           <dependency>
             <license name='License 1'/>
             <license name='License 2'/>
           </dependency>
         """)
 
-        fake_file = double(:license_report, read: license_xml)
-        allow(gradle).to receive(:license_report).and_return(fake_file)
-
         expect(GradlePackage).to receive(:new).with({"license" => [{"name" => "License 1"}, {"name" => "License 2"}]}, anything)
         gradle.current_packages
       end
 
-      it "handles no licenses" do
-        license_xml = license_xml("""
+      it "handles an empty list of licenses" do
+        stub_license_report("""
           <dependency>
-            <license name='No license found' />
           </dependency>
         """)
+        expect(GradlePackage).to receive(:new).with({}, anything)
 
-        fake_file = double(:license_report, read: license_xml)
-        allow(gradle).to receive(:license_report).and_return(fake_file)
-
-        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
       end
     end

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

@@ -4,15 +4,9 @@ module LicenseFinder
   describe MavenPackage do
     subject do
       described_class.new(
-        {
-          "groupId" => "org.hamcrest",
-          "artifactId" => "hamcrest-core",
-          "version" => "4.11",
-          "licenses" => [{
-              "name" => "Common Public License Version 1.0",
-              "url" => "http://www.opensource.org/licenses/cpl1.0.txt"
-          }]
-        }
+        "artifactId" => "hamcrest-core",
+        "version" => "4.11",
+        "licenses" => [{ "name" => "MIT" }]
       )
     end
 
@@ -20,52 +14,35 @@ module LicenseFinder
 
     its(:name) { should == "hamcrest-core" }
     its(:version) { should == "4.11" }
+    its(:summary) { should == "" }
     its(:description) { should == "" }
-
-    describe "#licenses" do
-      it "returns the license if found" do
-        expect(subject.licenses.length).to eq 1
-        expect(subject.licenses.first.name).to eq "Common Public License Version 1.0"
+    its(:homepage) { should == "" }
+    its(:groups) { should == [] } # no way to get groups from maven?
+    its(:children) { should == [] } # no way to get children from maven?
+    its(:install_path) { should be_nil }
+
+    describe "#license_names_from_spec" do
+      it "returns the license" do
+        expect(subject.license_names_from_spec).to eq ["MIT"]
       end
 
-      context "when there are multiple licenses" do
-        subject do
-          described_class.new(
-            {
-              "groupId" => "org.hamcrest",
-              "artifactId" => "hamcrest-core",
-              "licenses" => [{
-                "name" => "Common Public License Version 1.0",
-                "url" => "http://www.opensource.org/licenses/cpl1.0.txt"
-              },
-              {
-                "name" => "Apache 2",
-                "url" => "http://www.apache.org/licenses/LICENSE-2.0.txt"
-              }]
-            }
-          )
-        end
+      context "when there are no licenses" do
+        subject { described_class.new({}) }
 
-        it "returns 'multiple licenses'" do
-          expect(subject.licenses.length).to eq 2
-          expect(subject.licenses.map(&:name)).to eq ['Common Public License Version 1.0', 'Apache 2']
+        it "is empty" do
+          expect(subject.license_names_from_spec).to be_empty
         end
       end
 
-      context "when the license is not found" do
+      context "when there are multiple licenses" do
         subject do
           described_class.new(
-            {
-              "groupId" => "org.hamcrest",
-              "artifactId" => "hamcrest-core",
-              "licenses" => {}
-             }
+            "licenses" => [{ "name" => "1" }, { "name" => "2" }]
           )
         end
 
-        it "returns 'other' otherwise" do
-          expect(subject.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq "other"
+        it "returns multiple licenses" do
+          expect(subject.license_names_from_spec).to eq ['1', '2']
         end
       end
     end

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

@@ -9,7 +9,12 @@ module LicenseFinder
         "description" => "a description",
         "readme" => "a readme",
         "path" => "some/node/package/path",
-        "homepage" => "a homepage"
+        "homepage" => "a homepage",
+        "dependencies" => {
+          "coffee-script" => {
+            "name" => "coffee-script",
+          }
+        }
       )
     end
 
@@ -17,92 +22,36 @@ module LicenseFinder
 
     its(:name) { should == "jasmine-node" }
     its(:version) { should == "1.3.1" }
-    its(:summary) { should == "a description" }
-    its(:description) { should == "a readme" }
+    its(:summary) { should eq "" }
+    its(:description) { should == "a description" }
     its(:homepage) { should == "a homepage" }
-    its(:groups) { should == [] }
-    its(:children) { should == [] }
-
-    describe '#licenses' do
-      def stub_license_files(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"} }
-      let(:node_module2) { {"licenses" => [{"type" => "BSD"}], "path" => "/some/path"} }
-      let(:node_module3) { {"license" => {"type" => "PSF"}, "path" => "/some/path"} }
-      let(:node_module4) { {"licenses" => ["MIT"], "path" => "/some/path"} }
+    its(:groups) { should == [] } # TODO: put devDependencies in 'dev' group?
+    its(:children) { should == ["coffee-script"] }
+    its(:install_path) { should eq "some/node/package/path" }
+
+    describe '#license_names_from_spec' do
+      let(:node_module1) { {"license" => "MIT"} }
+      let(:node_module2) { {"licenses" => [{"type" => "BSD"}]} }
+      let(:node_module3) { {"license" => {"type" => "PSF"}} }
+      let(:node_module4) { {"licenses" => ["MIT"]} }
       let(:misdeclared_node_module) { {"licenses" => {"type" => "MIT"}} }
 
       it 'finds the license for both license structures' do
         package = NpmPackage.new(node_module1)
-        expect(package.licenses.length).to eq 1
-        expect(package.licenses.first.name).to eq("MIT")
+        expect(package.license_names_from_spec).to eq ["MIT"]
 
         package = NpmPackage.new(node_module2)
-        expect(package.licenses.length).to eq 1
-        expect(package.licenses.first.name).to eq("BSD")
+        expect(package.license_names_from_spec).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")
+        expect(package.license_names_from_spec).to eq ["PSF"]
 
         package = NpmPackage.new(node_module4)
-        expect(package.licenses.length).to eq 1
-        expect(package.licenses.first.name).to eq("MIT")
+        expect(package.license_names_from_spec).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
-        before do
-          stub_license_files [double(:file, license: License.find_by_name('Detected License'))]
-        end
-
-        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.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.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'), path: "/"),
-            double(:second_file, license: License.find_by_name('Expat'), path: "/")
-          ])
-
-          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 []
-
-          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'), path: "/"),
-            double(:second_file, license: License.find_by_name('Second Detected License'), path: "/")
-          ])
-
-          expect(subject.licenses.length).to eq 2
-          expect(subject.licenses.map(&:name)).to eq ["First Detected License", "Second Detected License"]
-        end
+        expect(package.license_names_from_spec).to eq ["MIT"]
       end
     end
   end
 end
-

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

@@ -17,14 +17,29 @@ module LicenseFinder
                 "version": "1.3.3.7",
                 "description": "description",
                 "readme": "readme",
-                "path": "/path/to/thing"
+                "path": "/path/to/thing",
+                "dependencies": {
+                  "dependency1-1.js": {
+                    "name": "dep1-1js"
+                  }
+                }
               },
               "dependency2.js": {
                 "name": "dep2js",
                 "version": "4.2",
                 "description": "description2",
                 "readme": "readme2",
-                "path": "/path/to/thing2"
+                "path": "/path/to/thing2",
+                "dependencies": {
+                  "dependency2-1.js": {
+                    "name": "dep2-1js",
+                    "dependencies": {
+                      "dependency1-1.js": {
+                        "name": "dep1-1js"
+                      }
+                    }
+                  }
+                }
               }
             },
             "devDependencies": {
@@ -36,24 +51,6 @@ module LicenseFinder
                 "path": "/path/to/thing3"
               }
             },
-            "bundledDependencies": {
-              "dependency4.js": {
-                "name": "dep4js",
-                "version": "4.2",
-                "description": "description4",
-                "readme": "readme4",
-                "path": "/path/to/thing4"
-              }
-            },
-            "bundleDependencies": {
-              "dependency5.js": {
-                "name": "dep5js",
-                "version": "4.2",
-                "description": "description5",
-                "readme": "readme5",
-                "path": "/path/to/thing5"
-              }
-            },
             "notADependency": {
               "dependency6.js": {
                 "name": "dep6js",
@@ -69,7 +66,7 @@ module LicenseFinder
 
         current_packages = npm.current_packages
 
-        expect(current_packages.map(&:name)).to eq(["depjs", "dep2js", "dep3js", "dep5js", "dep4js"])
+        expect(current_packages.map(&:name)).to eq(["depjs", "dep1-1js", "dep2js", "dep2-1js", "dep3js"])
         expect(current_packages.first).to be_a(Package)
         expect(current_packages.first.name).to eq("depjs")
       end

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

@@ -2,7 +2,13 @@ require 'spec_helper'
 
 module LicenseFinder
   describe PipPackage do
-    subject { make_package({}) }
+    subject do
+      make_package({
+        "summary" => "summary",
+        "description" => "description",
+        "home_page" => "homepage"
+      })
+    end
 
     it_behaves_like "a Package"
 
@@ -12,52 +18,30 @@ module LicenseFinder
 
     its(:name) { should == "jasmine" }
     its(:version) { should == "1.3.1" }
-    its(:homepage) { should == nil }
-    its(:groups) { should == [] }
-    its(:children) { should == [] }
-
-    describe "#summary" do
-      it "delegates to pypi def" do
-        subject = make_package("summary" => "A summary")
-        expect(subject.summary).to eq("A summary")
-      end
+    its(:summary) { should == "summary" }
+    its(:description) { should == "description" }
+    its(:homepage) { should == "homepage" }
+    its(:groups) { should == [] } # TODO: any way to extract install_requires and tests_require from `pip list` or `pip show`?
+    its(:children) { should == [] } # TODO: use pipdeptree or something like it
+    its(:install_path) { should eq "jasmine/install/path" }
 
-      it "falls back to nothing" do
-        expect(subject.summary).to eq("")
-      end
-    end
 
-    describe "#description" do
-      it "delegates to pypi def" do
-        subject = make_package("description" => "A description")
-        expect(subject.description).to eq("A description")
-      end
+    describe '#license_names_from_spec' do
+      describe "with no pypi info" do
+        it "is empty" do
+          subject = make_package({})
 
-      it "falls back to nothing" do
-        expect(subject.description).to eq("")
-      end
-    end
-
-    describe "#homepage" do
-      it "delegates to pypi def" do
-        subject = make_package("home_page" => "A homepage")
-        expect(subject.homepage).to eq("A homepage")
+          expect(subject.license_names_from_spec).to be_empty
+        end
       end
 
-      it "falls back to nothing" do
-        expect(subject.homepage).to be_nil
-      end
-    end
-
-    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.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq('MIT')
+          expect(subject.license_names_from_spec).to eq ['MIT']
         end
 
         context "when there's no explicit license" do
@@ -66,51 +50,28 @@ module LicenseFinder
 
             subject = make_package(data)
 
-            expect(subject.licenses.length).to eq 1
-            expect(subject.licenses.first.name).to eq('Apache 2.0 License')
+            expect(subject.license_names_from_spec).to eq ['Apache 2.0 License']
           end
 
-          it "returns 'multiple licenses' if there are multiple licenses in 'classifiers'" do
+          it "returns multiple licenses if there are many in 'classifiers'" do
             data = { "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License', 'License :: OSI Approved :: GPL' ] }
 
             subject = make_package(data)
 
-            expect(subject.licenses.length).to eq 2
-            expect(subject.licenses.map(&:name)).to eq ['Apache 2.0 License', 'GPL']
+            expect(subject.license_names_from_spec).to eq ['Apache 2.0 License', 'GPL']
           end
         end
 
-
         context "with UNKNOWN license" do
           it "returns the license from the classifier if it exists" do
             data = { "license" => "UNKNOWN", "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
 
             subject = make_package(data)
 
-            expect(subject.licenses.length).to eq 1
-            expect(subject.licenses.first.name).to eq('Apache 2.0 License')
+            expect(subject.license_names_from_spec).to eq ['Apache 2.0 License']
           end
         end
       end
-
-
-      describe "without pypi license" do
-        def stub_license_files(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'), 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.licenses.length).to eq 1
-          expect(subject.licenses.first.name).to eq('other')
-        end
-      end
     end
   end
 end