license_finder 0.9.5.1-java → 1.0.0.0-java

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

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+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"
+          }]
+        }
+      )
+    end
+
+    it_behaves_like "it conforms to interface required by PackageSaver"
+
+    its(:name) { should == "hamcrest-core" }
+    its(:version) { should == "4.11" }
+    its(:description) { should == "" }
+    its(:licenses_from_spec) { should == ["Common Public License Version 1.0"] }
+
+    describe "#license" do
+      it "returns the license if found" do
+        subject.license.should == "Common Public License Version 1.0"
+      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
+
+        it "returns 'other'" do
+          subject.license.should == 'other'
+        end
+      end
+
+      context "when the license is not found" do
+        subject do
+          described_class.new(
+            {
+              "groupId" => "org.hamcrest",
+              "artifactId" => "hamcrest-core",
+              "licenses" => {}
+             }
+          )
+        end
+
+        it "returns 'other' otherwise" do
+          subject.license.should == "other"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe Maven do
+    def license_xml(xml)
+      <<-resp
+        <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+        <licenseSummary>
+          <dependencies>
+            #{xml}
+          </dependencies>
+        </licenseSummary>
+      resp
+    end
+
+    describe '.current_packages' do
+      before do
+        expect(described_class).to receive(:`).with(/mvn/)
+      end
+
+      it 'lists all the current packages' do
+        license_xml = license_xml("""
+          <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.11</version>
+            <licenses>
+              <license>
+                <name>Common Public License Version 1.0</name>
+                <url>http://www.opensource.org/licenses/cpl1.0.txt</url>
+              </license>
+            </licenses>
+          </dependency>
+          <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-core</artifactId>
+            <version>1.3</version>
+            <licenses>
+              <license>
+                <name>New BSD License</name>
+                <url>http://www.opensource.org/licenses/bsd-license.php</url>
+                <distribution>repo</distribution>
+              </license>
+            </licenses>
+           </dependency>
+        """)
+        allow(File).to receive(:read).with("target/generated-resources/licenses.xml").and_return(license_xml)
+
+        current_packages = Maven.current_packages
+
+        expect(current_packages.size).to eq(2)
+        expect(current_packages.first).to be_a(Package)
+      end
+
+      it "handles multiple licenses" do
+        license_xml = license_xml("""
+          <dependency>
+            <licenses>
+              <license>
+                <name>License 1</name>
+              </license>
+              <license>
+                <name>License 2</name>
+              </license>
+            </licenses>
+          </dependency>
+        """)
+
+        allow(File).to receive(:read).with("target/generated-resources/licenses.xml").and_return(license_xml)
+
+        MavenPackage.should_receive(:new).with("licenses" => [{"name" => "License 1"}, {"name" => "License 2"}])
+        Maven.current_packages
+      end
+
+      it "handles no licenses" do
+        license_xml = license_xml("""
+          <dependency>
+            <licenses>
+            <!-- comment -->
+            </licenses>
+          </dependency>
+        """)
+
+        allow(File).to receive(:read).with("target/generated-resources/licenses.xml").and_return(license_xml)
+
+        MavenPackage.should_receive(:new).with("licenses" => {})
+        Maven.current_packages
+      end
+    end
+
+    describe '.active?' do
+      let(:package) { Pathname.new('pom.xml').expand_path }
+
+      context 'with a pom.xml file' do
+        before :each do
+          allow(File).to receive(:exists?).with(package).and_return(true)
+        end
+
+        it 'returns true' do
+          expect(Maven.active?).to eq(true)
+        end
+      end
+
+      context 'without a pom.xml file' do
+        before :each do
+          allow(File).to receive(:exists?).with(package).and_return(false)
+        end
+
+        it 'returns false' do
+          expect(Maven.active?).to eq(false)
+        end
+      end
+    end
+  end
+end

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

@@ -28,14 +28,16 @@ module LicenseFinder
         PossibleLicenseFiles.stub(:find).with("some/node/package/path").and_return(license_files)
       end
 
-      let(:node_module1) { {"license" => "MIT"} }
-      let(:node_module2) { {"licenses" => [{"type" => "BSD"}]} }
-      let(:node_module3) { {"license" => {"type" => "PSF"}} }
+      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"} }
 
       it 'finds the license for both license structures' do
         NpmPackage.new(node_module1).license.should eq("MIT")
         NpmPackage.new(node_module2).license.should eq("BSD")
         NpmPackage.new(node_module3).license.should eq("PSF")
+        NpmPackage.new(node_module4).license.should eq("MIT")
       end
 
       it "returns a license in a file if detected" do
@@ -44,6 +46,18 @@ module LicenseFinder
         subject.license.should == "Detected License"
       end
 
+      it "returns other if there's more than one license" do
+        package = NpmPackage.new({ "licenses" => ["MIT", "BSD"], "path" => "/some/path" })
+        expect(package.license).to eq("other")
+      end
+
+      it "returns other if the license from spec and license from files are different" do
+        stub_license_files [double(:file, license: 'Detected License')]
+        package = NpmPackage.new({ "licenses" => ["MIT"], "path" => "some/node/package/path" })
+
+        expect(package.license).to eq("other")
+      end
+
       it "returns 'other' otherwise" do
         stub_license_files []
 

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

@@ -50,7 +50,7 @@ module LicenseFinder
     end
 
     describe '#license' do
-      describe "with pypi license" 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' ] }
 
@@ -59,15 +59,37 @@ module LicenseFinder
           expect(subject.license).to eq('MIT')
         end
 
-        it "returns the first license from the 'classifiers' if no 'license' exists" do
-          data = { "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
+        context "when there's no explicit license" do
+          it "returns the license from the 'classifiers' if there is only one" do
+            data = { "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License' ] }
 
-          subject = make_package(data)
+            subject = make_package(data)
+
+            expect(subject.license).to eq('Apache 2.0 License')
+          end
+
+          it "returns 'other' if there is are multiple licenses in 'classifiers'" do
+            data = { "classifiers" => [ 'License :: OSI Approved :: Apache 2.0 License', 'License :: OSI Approved :: GPL' ] }
+
+            subject = make_package(data)
+
+            expect(subject.license).to eq('other')
+          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' ] }
 
-          expect(subject.license).to eq('Apache 2.0 License')
+            subject = make_package(data)
+
+            expect(subject.license).to eq('Apache 2.0 License')
+          end
         end
       end
 
+
       describe "without pypi license" do
         def stub_license_files(license_files)
           PossibleLicenseFiles.stub(:find).with("jasmine/install/path").and_return(license_files)

data/spec/lib/license_finder/possible_license_file_spec.rb

@@ -10,7 +10,7 @@ describe LicenseFinder::PossibleLicenseFile do
       end
 
       its(:file_path) { should == 'nested/path' }
-      its(:text) { should == 'file text' }
+      its(:text) { should == 'file text' } # this is a terrible test, considering the stubbing
     end
   end
 
@@ -20,7 +20,7 @@ describe LicenseFinder::PossibleLicenseFile do
     before do
       subject.stub(:text).and_return('a known license')
 
-      LicenseFinder::License::MIT.stub(:new).with('a known license').and_return(double('MIT license', :matches? => true))
+      LicenseFinder::License.stub(:find_by_text).with('a known license').and_return(LicenseFinder::License.find_by_name("MIT"))
     end
 
     its(:license) { should == "MIT" }

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe Reporter do
+    describe "#write_reports" do
+      subject { Reporter.write_reports }
+
+      before do
+        Dependency.stub(:all) { [double(:dep)] }
+
+        MarkdownReport.stub(:of) { 'markdown report' }
+        DetailedTextReport.stub(:of) { 'detailed csv report' }
+        TextReport.stub(:of) { 'csv report' }
+        HtmlReport.stub(:of) { 'html report' }
+      end
+
+      it "writes an html file" do
+        subject
+        LicenseFinder.config.artifacts.text_file.read.should == "csv report\n"
+        LicenseFinder.config.artifacts.detailed_text_file.read.should == "detailed csv report\n"
+        LicenseFinder.config.artifacts.markdown_file.read.should == "markdown report\n"
+        LicenseFinder.config.artifacts.html_file.read.should == "html report\n"
+      end
+
+      it "deletes old dependencies.txt file" do
+        fake_file =  double(:fake_file, :exist? => true)
+        LicenseFinder.config.artifacts.stub(:legacy_text_file) { fake_file }
+        fake_file.should_receive(:delete)
+        subject
+      end
+    end
+  end
+end

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

@@ -3,11 +3,10 @@ require 'spec_helper'
 module LicenseFinder
   describe Dependency do
     describe '.unapproved' do
-      let(:config) { Configuration.new }
+      let(:config) { Configuration.new('whitelist' => ['MIT', 'other']) }
 
       before do
         LicenseFinder.stub(:config).and_return config
-        config.whitelist = ["MIT", "other"]
       end
 
       it "should return all unapproved dependencies" do

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

@@ -11,11 +11,10 @@ module LicenseFinder
     end
 
     describe "#whitelisted?" do
-      let(:config) { Configuration.new }
+      let(:config) { Configuration.new('whitelist' => ['MIT', 'other']) }
 
       before do
         LicenseFinder.stub(:config).and_return config
-        config.whitelist = ["MIT", "other"]
       end
 
       it "should return true when the license is whitelisted" do

data/spec/lib/license_finder/yml_to_sql_spec.rb

@@ -20,31 +20,30 @@ describe LicenseFinder::YmlToSql do
       'license_files' => ['/Users/pivotal/foo/lic1', '/Users/pivotal/bar/lic2'],
     }
   end
-  let(:config) { LicenseFinder::Configuration.new }
   let(:source) { nil }
 
-  before do
-    LicenseFinder.stub(:config) { config }
-  end
-
   describe ".needs_conversion?" do
     it "is true if the yml still exists" do
-      config.stub(dependencies_dir: 'path/to')
-      File.should_receive(:exists?).with('path/to/dependencies.yml') { true }
+      yaml_file = double(:yaml_file, :exist? => true)
+      LicenseFinder.config.artifacts.stub(legacy_yaml_file: yaml_file)
+
       described_class.needs_conversion?.should be_true
     end
 
     it "is false otherwise" do
-      config.stub(dependencies_dir: 'path/to')
-      File.should_receive(:exists?).with('path/to/dependencies.yml') { false }
+      yaml_file = double(:yaml_file, :exist? => false)
+      LicenseFinder.config.artifacts.stub(legacy_yaml_file: yaml_file)
+
       described_class.needs_conversion?.should be_false
     end
   end
 
   describe ".remove_yml" do
     it "removes the yml file" do
-      config.stub(dependencies_dir: 'path/to')
-      File.should_receive(:delete).with('path/to/dependencies.yml')
+      yaml_file = double(:yaml_file)
+      LicenseFinder.config.artifacts.stub(legacy_yaml_file: yaml_file)
+
+      yaml_file.should_receive(:delete)
       described_class.remove_yml
     end
   end

data/spec/lib/license_finder_spec.rb

@@ -2,81 +2,15 @@ require 'spec_helper'
 
 describe LicenseFinder do
   describe ".config" do
-    let(:config) do
-      {
-        'whitelist' => %w(MIT Apache),
-        'ignore_groups' => %w(test development)
-      }
-    end
-
-    before do
-      LicenseFinder.instance_variable_set(:@config, nil)
-      File.stub(:exists?).with('./config/license_finder.yml').and_return(true)
-      File.stub(:read).with('./config/license_finder.yml').and_return(config.to_yaml)
-    end
-
-    after do
-      LicenseFinder.instance_variable_set(:@config, nil)
-    end
-
-    it "should handle a missing configuration file" do
-      File.stub(:exists?).with('./config/license_finder.yml').and_return(false)
-      File.should_not_receive(:open).with('./config/license_finder.yml')
-
-      LicenseFinder.config.whitelist.should == []
-      LicenseFinder.config.ignore_groups.should == []
-      LicenseFinder.config.dependencies_dir.should == './doc/'
-    end
-
     it "should load the configuration exactly once" do
-      File.should_receive(:read).with('./config/license_finder.yml').once.and_return(config.to_yaml)
-
-      LicenseFinder.config.whitelist
-      LicenseFinder.config.whitelist
-    end
-
-    describe "#whitelist" do
-      it "should load a whitelist from license_finder.yml" do
-        LicenseFinder.config.whitelist.should =~ %w(MIT Apache)
-      end
-
-      it "should load an empty whitelist from license_finder.yml when there are no whitelist items" do
-        File.stub(:read).with('./config/license_finder.yml').and_return(config.merge('whitelist' => nil).to_yaml)
-
-        LicenseFinder.config.whitelist.should =~ []
-      end
-    end
-
-    describe "#ignore_groups" do
-      it "should load a ignore_groups list from license_finder.yml" do
-        LicenseFinder.config.ignore_groups.should == ["test", "development"]
-      end
-
-      it "should load an empty ignore_groups list from license_finder.yml when there are no ignore groups" do
-        File.stub(:read).with('./config/license_finder.yml').and_return(config.merge('ignore_groups' => nil).to_yaml)
-
-        LicenseFinder.config.ignore_groups.should == []
-      end
-    end
+      LicenseFinder.instance_variable_set(:@config, nil)
 
-    describe "#dependencies_dir" do
-      it 'should allow the dependencies file directory to be configured' do
-        File.stub(:read).with('./config/license_finder.yml').and_return(config.merge('dependencies_file_dir' => './elsewhere').to_yaml)
+      LicenseFinder::Configuration.should_receive(:ensure_default).once.and_return(double(:config))
 
-        config = LicenseFinder.config
-        config.dependencies_dir.should == './elsewhere'
-        config.dependencies_yaml.should == './elsewhere/dependencies.yml'
-        config.dependencies_text.should == './elsewhere/dependencies.csv'
-        config.dependencies_html.should == './elsewhere/dependencies.html'
-      end
+      LicenseFinder.config
+      LicenseFinder.config
 
-      it 'should default the dependency files when the directory is not provided' do
-        config = LicenseFinder.config
-        config.dependencies_dir.should == './doc/'
-        config.dependencies_yaml.should == './doc/dependencies.yml'
-        config.dependencies_text.should == './doc/dependencies.csv'
-        config.dependencies_html.should == './doc/dependencies.html'
-      end
+      LicenseFinder.instance_variable_set(:@config, nil)
     end
   end
 end