license_finder 1.0.0.0-java → 1.1.1-java

data/spec/lib/license_finder/license/definitions_spec.rb

@@ -1,32 +1,48 @@
 require 'spec_helper'
 
+describe LicenseFinder::License::Definitions do
+  it "should create unrecognized licenses" do
+    license = described_class.build_unrecognized("foo", [])
+    license.name.should == "foo"
+    license.url.should be_nil
+    license.should be_matches_name("foo")
+    license.should_not be_matches_text("foo")
+    license.should_not be_whitelisted
+  end
+
+  it "should whitelist unrecognized licenses" do
+    license = described_class.build_unrecognized("foo", ["foo"])
+    license.should be_whitelisted
+  end
+end
+
 describe LicenseFinder::License, "Apache2" do
-  it "should be findable" do |e|
-    described_class.find_by_name("Apache2").should be
+  it "should be recognized" do |e|
+    described_class.find_by_name("Apache2").url.should be
   end
 end
 
 describe LicenseFinder::License, "BSD" do
-  it "should be findable" do |e|
-    described_class.find_by_name("BSD").should be
+  it "should be recognized" do |e|
+    described_class.find_by_name("BSD").url.should be
   end
 end
 
 describe LicenseFinder::License, "GPLv2" do
-  it "should be findable" do
-    described_class.find_by_name("GPLv2").should be
+  it "should be recognized" do
+    described_class.find_by_name("GPLv2").url.should be
   end
 end
 
 describe LicenseFinder::License, "ISC" do
-  it "should be findable" do
-    described_class.find_by_name("ISC").should be
+  it "should be recognized" do
+    described_class.find_by_name("ISC").url.should be
   end
 end
 
 describe LicenseFinder::License, "LGPL" do
-  it "should be findable" do
-    described_class.find_by_name("LGPL").should be
+  it "should be recognized" do
+    described_class.find_by_name("LGPL").url.should be
   end
 end
 
@@ -119,8 +135,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 end
 
 describe LicenseFinder::License, "Python" do
-  it "should be findable" do
-    described_class.find_by_name("Python").should be
+  it "should be recognized" do
+    described_class.find_by_name("Python").url.should be
   end
 end
 
@@ -143,7 +159,7 @@ describe LicenseFinder::License, "Ruby" do
 end
 
 describe LicenseFinder::License, "SimplifiedBSD" do
-  it "should be findable" do
-    described_class.find_by_name("SimplifiedBSD").should be
+  it "should be recognized" do
+    described_class.find_by_name("SimplifiedBSD").url.should be
   end
 end

data/spec/lib/license_finder/license_spec.rb

@@ -7,12 +7,30 @@ module LicenseFinder
         License.find_by_name("Apache2").should be_a License
       end
 
-      context "when license not found" do
-        it "should return UnknownLicense with the name" do
-          license = License.find_by_name("New License")
+      it "should make an unrecognized license" do
+        license = License.find_by_name("not a known license")
 
-          expect(license).to be_a UnknownLicense
-          expect(license.pretty_name).to eq "New License"
+        expect(license).to be_a License
+        expect(license.name).to eq "not a known license"
+      end
+
+      context "making the default license" do
+        it "set the name to 'other'" do
+          License.find_by_name(nil).name.should == "other"
+        end
+
+        it "does not equal other uses of the default license" do
+          License.find_by_name(nil).should_not == License.find_by_name(nil)
+        end
+
+        context "when there is a whitelist" do
+          before do
+            LicenseFinder.config.stub(:whitelist).and_return(["not empty"])
+          end
+
+          it "does not blow up" do
+            License.find_by_name(nil).name.should == "other"
+          end
         end
       end
     end
@@ -22,20 +40,39 @@ module LicenseFinder
         License.find_by_text('This gem is released under the MIT license').should be_a License
       end
 
-      it "returns UnknownLicense with nil name if not found" do
+      it "returns nil if not found" do
         license = License.find_by_text("foo")
 
-        expect(license).to be_a UnknownLicense
-        expect(license.pretty_name).to be_nil
+        expect(license).to be_nil
       end
     end
 
     def make_license(settings = {})
-      described_class.new({
+      defaults = {
         short_name: "Default Short Name",
         url: "http://example.com/license",
+        whitelisted: false,
         matcher: License::Matcher.from_text('Default Matcher')
-      }.merge(settings))
+      }
+
+      License.new(defaults.merge(settings))
+    end
+
+    describe "#whitelisted?" do
+      it "is true if the settings say it is" do
+        make_license.should_not be_whitelisted
+        make_license(whitelisted: true).should be_whitelisted
+      end
+
+      it "can be made true (without mutating original)" do
+        original = make_license
+        license = original.whitelist
+        license.should_not == original
+        license.should be_whitelisted
+        license.url.should == "http://example.com/license"
+        license.should be_matches_name "Default Short Name"
+        license.should be_matches_text "Default Matcher"
+      end
     end
 
     describe "#matches_name?" do
@@ -65,7 +102,7 @@ module LicenseFinder
 
     describe ".matches_text?" do
       it "should match on text" do
-        license = make_license(matcher: License::Matcher.new(/The license text/))
+        license = make_license(matcher: License::Matcher.from_regex(/The license text/))
         license.should be_matches_text "The license text"
         license.should_not be_matches_text "Some other text"
       end
@@ -82,10 +119,16 @@ module LicenseFinder
           shall not be held "responsible" for `anything`.
         FILE
       end
+
+      it "should match even if whitespace at beginning and end don't match" do
+        template = License::Template.new("\nThe license text")
+        license = make_license(matcher: License::Matcher.from_template(template))
+        license.should be_matches_text "The license text\n"
+      end
     end
 
     it "should default pretty_name to short_name" do
-      make_license.pretty_name.should == "Default Short Name"
+      make_license.name.should == "Default Short Name"
     end
   end
 end

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

@@ -37,34 +37,53 @@ module LicenseFinder
       let(:package4) { { "pkgMeta" => {"licenses" => ["MIT"]}, "canonicalDir" => "/some/path" } }
 
       it 'finds the license for both license  structures' do
-        BowerPackage.new(package1).license.should eq("MIT")
-        BowerPackage.new(package2).license.should eq("BSD")
-        BowerPackage.new(package3).license.should eq("PSF")
-        BowerPackage.new(package4).license.should eq("MIT")
+        BowerPackage.new(package1).license.name.should eq("MIT")
+        BowerPackage.new(package2).license.name.should eq("BSD")
+        BowerPackage.new(package3).license.name.should eq("Python Software Foundation License")
+        BowerPackage.new(package4).license.name.should eq("MIT")
       end
 
-      it "returns a license in a file if detected" do
-        stub_license_files [double(:file, license: 'Detected License')]
 
-        subject.license.should == "Detected License"
-      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 = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "Expat"]}, "canonicalDir" => "/path/to/thing" })
+          expect(package.license.name).to eq("MIT")
+        end
 
-      it "returns other if there's more than one license" do
-        package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "BSD"]}, "canonicalDir" => "/some/path" })
-        expect(package.license).to eq("other")
+        it "returns 'multiple licenses' if there's more than one license" do
+          package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "BSD"]}, "canonicalDir" => "/some/path" })
+          expect(package.license.name).to eq("multiple licenses: MIT, BSD")
+        end
       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 = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT"]}, "canonicalDir" => "/path/to/thing" })
+      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'))
+          ])
 
-        expect(package.license).to eq("other")
-      end
+          subject.license.name.should == "MIT"
+        end
+
+        it "returns 'other' if there are no licenses in files" do
+          stub_license_files []
+
+          subject.license.name.should == "other"
+        end
 
-      it "returns 'other' otherwise" do
-        stub_license_files []
+        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'))
+          ])
 
-        subject.license.should == "other"
+          subject.license.name.should == "multiple licenses: First Detected License, Second Detected License"
+        end
       end
     end
   end

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

@@ -38,26 +38,20 @@ module LicenseFinder
     end
 
     describe '.active?' do
-      let(:package) { Pathname.new('bower.json').expand_path }
+      let(:package) { double(:package_file) }
 
-      context 'with a bower.json file' do
-        before :each do
-          allow(File).to receive(:exists?).with(package).and_return(true)
-        end
-
-        it 'returns true' do
-          expect(Bower.active?).to eq(true)
-        end
+      before do
+        Bower.stub(package_path: package)
       end
 
-      context 'without a bower.json file' do
-        before :each do
-          allow(File).to receive(:exists?).with(package).and_return(false)
-        end
+      it 'is true with a bower.json file' do
+        package.stub(:exist? => true)
+        expect(Bower).to be_active
+      end
 
-        it 'returns false' do
-          expect(Bower.active?).to eq(false)
-        end
+      it 'is false without a bower.json file' do
+        package.stub(:exist? => false)
+        expect(Bower).to_not be_active
       end
     end
   end

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

@@ -31,28 +31,52 @@ module LicenseFinder
         PossibleLicenseFiles.stub(:find).and_return(license_files)
       end
 
-      it "returns the license from the gemspec if provided" do
-        gemspec.license = 'Gemspec License'
-
-        subject.license.should == "Gemspec License"
+      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
+
+        context 'if the gemspec provides two synonymous licenses' do
+          before { gemspec.licenses = ['MIT', 'Expat'] }
+
+          it 'returns the license only once' do
+            subject.license.name.should == "MIT"
+          end
+        end
+
+        context 'if the gemspec provides many licenses' do
+          before { gemspec.licenses = ['First Gemspec License', 'Second Gemspec License'] }
+
+          it "returns 'multiple licenses' with the names of the licenses from the gemspec (but not those from detected files)" do
+            subject.license.name.should == "multiple licenses: First Gemspec License, Second Gemspec License"
+          end
+        end
       end
 
-      it "returns 'other' if the gemspec provides many" do
-        gemspec.licenses = ['First Gemspec License', 'Second Gemspec License']
+      context "when there is nothing in the spec" do
+        it "returns a license in a file if there is 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'))
+          ])
 
-        subject.license.should == "other"
-      end
+          subject.license.name.should == "MIT"
+        end
 
-      it "returns a license in a file if detected" do
-        stub_license_files [double(:file, license: 'Detected License')]
+        it "returns 'other' if there are no licenses in files" do
+          stub_license_files []
 
-        subject.license.should == "Detected License"
-      end
+          subject.license.name.should == "other"
+        end
 
-      it "returns 'other' otherwise" do
-        stub_license_files []
+        it "returns 'multiple licenses' 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'))
+          ])
 
-        subject.license.should == "other"
+          subject.license.name.should == "multiple licenses: First Detected License, Second Detected License"
+        end
       end
     end
 

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

@@ -28,13 +28,7 @@ module LicenseFinder
 
     describe '.current_packages' do
       subject do
-        Bundler.current_packages(config)
-      end
-
-      let(:config) { double(:config, ignore_groups: ['dev', 'test']) }
-
-      before do
-        ::Bundler::Definition.stub(:build).and_return(definition)
+        Bundler.current_packages(['dev', 'test'], definition)
       end
 
       it "should have 2 dependencies" do
@@ -64,26 +58,20 @@ module LicenseFinder
     end
 
     describe '.active?' do
-      let(:gemfile) { Pathname.new('Gemfile').expand_path }
+      let(:gemfile) { double(:gemfile_file) }
 
-      before :each do
-        allow(File).to receive(:exists?).and_call_original
+      before do
+        Bundler.stub(gemfile_path: gemfile)
       end
 
-      context 'without a Gemfile' do
-        it 'returns false' do
-          allow(File).to receive(:exists?).with(gemfile).and_return(false)
-
-          Bundler.active?.should == false
-        end
+      it 'is true with a Gemfile file' do
+        gemfile.stub(:exist? => true)
+        expect(Bundler).to be_active
       end
 
-      context 'with a Gemfile' do
-        it 'returns true' do
-          allow(File).to receive(:exists?).with(gemfile).and_return(true)
-
-          Bundler.active?.should == true
-        end
+      it 'is false without a Gemfile file' do
+        gemfile.stub(:exist? => false)
+        expect(Bundler).to_not be_active
       end
     end
   end

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe CocoaPodsPackage do
+    subject do
+      described_class.new("Name", "1.0.0", license_text)
+    end
+    let(:license_text) { nil }
+
+    it_behaves_like "it conforms to interface required by PackageSaver"
+
+    its(:name) { should == "Name" }
+    its(:version) { should == "1.0.0" }
+    its(:summary) { should be_nil }
+    its(:description) { should be_nil }
+    its(:homepage) { should be_nil }
+    its(:groups) { should == [] }
+    its(:children) { should == [] }
+
+    describe '#license' do
+      context "when there's a license" do
+        let(:license_text) { "LicenseText" }
+
+        it "returns the name of the license if the license is found be text" do
+          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"
+        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"
+        end
+      end
+
+      it "returns other when there's no license" do
+        expect(subject.license.name).to eq "other"
+      end
+    end
+  end
+end
+