license_finder 0.8.0-java

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe LicenseFinder::License::NewBSD do
+  subject { LicenseFinder::License::NewBSD.new("") }
+
+  it_behaves_like "a license matcher"
+
+  it "should match regardless of organization or copyright holder names" do
+    license = LicenseFinder::License::NewBSD.new <<-LICENSE
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Johnny %$#!.43298432, Guitar INC! nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Johnny %$#!.43298432, Guitar BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+    LICENSE
+
+    license.should be_matches
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe LicenseFinder::License::Ruby do
+  subject { LicenseFinder::License::Ruby.new("") }
+
+  it_behaves_like "a license matcher"
+
+  describe "#matches?" do
+    it "should return true when the Ruby license URL is present" do
+      subject.text = "This gem is available under the following license:\nhttp://www.ruby-lang.org/en/LICENSE.txt\nOkay?"
+      should be_matches
+    end
+
+    it "should return false when the Ruby License URL is not present" do
+      subject.text = "This gem is available under the following license:\nhttp://www.example.com\nOkay?"
+      should_not be_matches
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe LicenseFinder::License::SimplifiedBSD do
+  subject { LicenseFinder::License::SimplifiedBSD.new("") }
+
+  it_behaves_like "a license matcher"
+end

data/spec/lib/license_finder/license_files_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe LicenseFiles do
+    def fixture_path(fixture)
+      Pathname.new(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec', 'fixtures', fixture)).realpath.to_s
+    end
+
+    describe "#files" do
+      it "is empty if there aren't any license files" do
+        subject = described_class.new('/not/a/dir')
+        subject.files.should == []
+      end
+
+      it "includes files with names like LICENSE, License or COPYING" do
+        subject = described_class.new(fixture_path('license_names'))
+
+        subject.files.map(&:file_name).should =~
+        %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.files.map { |f| [f.file_name, f.file_path] }.should =~ [
+          %w[LICENSE 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.files
+
+        found_license_files.map { |f| [f.file_name, f.file_path] }.should =~ [
+          %w[BSD-2-Clause.txt LICENSE/BSD-2-Clause.txt],
+          %w[GPL-2.0.txt LICENSE/GPL-2.0.txt],
+          %w[MIT.txt LICENSE/MIT.txt],
+          %w[RUBY.txt LICENSE/RUBY.txt],
+          %w[COPYING COPYING],
+          %w[LICENSE LICENSE/LICENSE]
+        ]
+      end
+
+      it "handles non UTF8 encodings" do
+        subject = described_class.new(fixture_path('utf8_gem'))
+        expect { subject.files }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/lib/license_finder/license_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class FooLicense < LicenseFinder::License::Base
+  self.alternative_names = ["the foo license"]
+  self.license_url = "http://foo.license.com"
+
+  def self.pretty_name
+    "Ye Ole Foo License"
+  end
+end
+
+module LicenseFinder
+  describe License do
+    describe ".find_by_name" do
+      it "should match on demodulized names" do
+        License.find_by_name("FooLicense").should == FooLicense
+      end
+
+      it "should match on pretty names" do
+        License.find_by_name("Ye Ole Foo License").should == FooLicense
+      end
+
+      it "should match on alternative names" do
+        License.find_by_name("the foo license").should == FooLicense
+      end
+
+      it "should return nil if no match" do
+        License.find_by_name(:unknown).should be_nil
+      end
+    end
+  end
+end
+
+describe LicenseFinder::License::Base do
+  describe ".names" do
+    subject do
+      Class.new(LicenseFinder::License::Base) do
+        def self.demodulized_name; "FooLicense"; end
+        self.alternative_names = ["foo license"]
+      end.names
+    end
+
+    it { should =~ ["FooLicense", "foo license"] }
+  end
+end

data/spec/lib/license_finder/license_url_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+class FooLicense < LicenseFinder::License::Base
+  self.alternative_names = ["the foo license"]
+  self.license_url = "http://foo.license.com"
+end
+
+describe LicenseFinder::LicenseUrl do
+  describe ".find_by_name" do
+    subject { LicenseFinder::LicenseUrl }
+
+    specify { subject.find_by_name("FooLicense").should      == "http://foo.license.com" }
+    specify { subject.find_by_name("fOolICENse").should      == "http://foo.license.com" }
+    specify { subject.find_by_name("the foo license").should == "http://foo.license.com" }
+
+    specify { subject.find_by_name(nil).should be_nil }
+    specify { subject.find_by_name("").should be_nil }
+    specify { subject.find_by_name("unknown license").should be_nil }
+  end
+end

data/spec/lib/license_finder/possible_license_file_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe LicenseFinder::PossibleLicenseFile do
+  context "file parsing" do
+    subject { LicenseFinder::PossibleLicenseFile.new('root', 'root/nested/path') }
+
+    context "ignoring text" do
+      before do
+        subject.stub(:text).and_return('file text')
+      end
+
+      its(:file_path) { should == 'nested/path' }
+      its(:file_name) { should == 'path' }
+      its(:text) { should == 'file text' }
+    end
+  end
+
+  subject { LicenseFinder::PossibleLicenseFile.new('gem', 'gem/license/path') }
+
+  context "with a known license" 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))
+    end
+
+    its(:license) { should == "MIT" }
+  end
+
+  context "with an unknown license" do
+    before do
+      subject.stub(:text).and_return('')
+    end
+
+    its(:license) { should be_nil }
+  end
+end

data/spec/lib/license_finder/reporter_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe LicenseFinder::Reporter do
+end

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

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe Dependency do
+    let(:attributes) do
+      {
+        'name' => "spec_name",
+        'version' => "2.1.3",
+        'license' => "GPLv2",
+        'approved' => false,
+        'notes' => 'some notes',
+        'homepage' => 'homepage',
+        'license_files' => ['/Users/pivotal/foo/lic1', '/Users/pivotal/bar/lic2'],
+        'bundler_groups' => ["test"]
+      }
+    end
+
+    let(:config) { Configuration.new }
+
+    before do
+      LicenseFinder.stub(:config).and_return config
+      config.whitelist = ["MIT", "other"]
+    end
+
+    describe ".destroy_obsolete" do
+      it "destroys every dependency except for the ones provided as 'current'" do
+        cur1 = Dependency.create(name: "current dependency 1")
+        cur2 = Dependency.create(name: "current dependency 2")
+        Dependency.create(name: "old dependency 1")
+        Dependency.create(name: "old dependency 2")
+
+        Dependency.destroy_obsolete([cur1, cur2])
+        Dependency.all.should =~ [cur1, cur2]
+      end
+    end
+
+    describe '.unapproved' do
+      it "should return all unapproved dependencies" do
+        dependency = Dependency.create(name: "unapproved dependency", version: '0.0.1')
+        dependency.approval = Approval.create(state: false)
+        dependency.save
+        approved = Dependency.create(name: "approved dependency", version: '0.0.1')
+        approved.approval = Approval.create(state: true)
+        approved.save
+        whitelisted = Dependency.create(name: "approved dependency", version: '0.0.1')
+        whitelisted.license = LicenseAlias.create(name: 'MIT')
+        whitelisted.approval = Approval.create(state: false)
+        whitelisted.save
+
+        unapproved = Dependency.unapproved
+        unapproved.count.should == 1
+        unapproved.should_not be_any(&:approved?)
+      end
+    end
+
+    describe '#approve!' do
+      it "should update the database to show the dependency is approved" do
+        dependency = Dependency.create(name: "foo", version: '0.0.1')
+        dependency.approval = Approval.create(state: false)
+        dependency.save
+        dependency.approve!
+        dependency.reload.should be_approved
+      end
+    end
+
+    describe "#approved?" do
+      let(:dependency) { Dependency.create(name: 'some gem') }
+
+      it "is true if its license is whitelisted" do
+        dependency.stub_chain(:license, whitelisted?: true)
+        dependency.should be_approved
+      end
+
+      it "is true if it has been approved" do
+        dependency.stub_chain(:license, whitelisted?: false)
+        dependency.stub_chain(:approval, state: true)
+        dependency.should be_approved
+      end
+
+      it "is false otherwise" do
+        dependency.stub_chain(:license, whitelisted?: false)
+        dependency.stub_chain(:approval, state: false)
+        dependency.should_not be_approved
+      end
+    end
+
+    describe "#set_license_manually" do
+      let(:gem) do
+        dependency = Dependency.new(name: "bob", version: '0.0.1')
+        dependency.license = LicenseAlias.create(name: 'Original')
+        dependency.save
+        dependency
+      end
+
+      it "delegates to the license" do
+        gem.license.should_receive(:set_manually).with('Updated')
+        gem.set_license_manually('Updated')
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe LicenseAlias do
+    describe 'initializes' do
+      it "delegates to LicenseUrl.find_by_name for the url" do
+        LicenseUrl.stub(:find_by_name).with("MIT").and_return "http://license-url.com"
+        license = described_class.new(name: 'MIT')
+        license.url.should == "http://license-url.com"
+      end
+    end
+
+    describe "#set_manually" do
+      subject do
+        described_class.create(name: 'Original')
+      end
+
+      it "modifies the license" do
+        subject.set_manually('Updated')
+        subject.reload.name.should == 'Updated'
+      end
+
+      it "marks the approval as manual" do
+        subject.set_manually('Updated')
+        subject.reload.manual.should be_true
+      end
+    end
+
+    describe "#whitelisted?" do
+      let(:config) { Configuration.new }
+
+      before do
+        LicenseFinder.stub(:config).and_return config
+        config.whitelist = ["MIT", "other"]
+      end
+
+      it "should return true when the license is whitelisted" do
+        described_class.new(name: 'MIT').should be_whitelisted
+      end
+
+      it "should return true when the license is an alternative name of a whitelisted license" do
+        described_class.new(name: 'Expat').should be_whitelisted
+      end
+
+      it "should return true when the license has no matching license class, but is whitelisted anyways" do
+        described_class.new(name: 'other').should be_whitelisted
+      end
+
+      it "should return false when the license is not whitelisted" do
+        described_class.new(name: 'GPL').should_not be_whitelisted
+      end
+    end
+  end
+end

data/spec/lib/license_finder/text_report_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+module LicenseFinder
+  describe TextReport do
+    describe '#to_s' do
+      let(:dep1) do
+        dependency = Dependency.new(
+          'name' => 'gem_a',
+          'version' => '1.0',
+        )
+        dependency.license = LicenseFinder::LicenseAlias.create(name: 'MIT')
+        dependency
+      end
+
+      let(:dep2) do
+        dependency = Dependency.new(
+          'name' => 'gem_b',
+          'version' => '1.0',
+        )
+        dependency.license = LicenseFinder::LicenseAlias.create(name: 'MIT')
+        dependency
+      end
+
+      subject { TextReport.new([dep2, dep1]).to_s }
+
+      it 'should generate a text report with the name, version, and license of each dependency, sorted by name' do
+        should == "gem_a, 1.0, MIT\ngem_b, 1.0, MIT"
+      end
+    end
+  end
+end

data/spec/lib/license_finder/yml_to_sql_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+describe LicenseFinder::YmlToSql do
+  let(:legacy_attributes) do
+    {
+      'name' => "spec_name",
+      'version' => "2.1.3",
+      'license' => "GPLv2",
+      'license_url' => "www.license_url.org",
+      'approved' => true,
+      'manual' => true,
+      'summary' => "some summary",
+      'description' => "some description",
+      'homepage' => 'www.homepage.com',
+      'children' => ["child1_name"],
+      'parents' => ["parent1_name"],
+      'bundler_groups' => [:test],
+
+      'notes' => 'some notes',
+      'license_files' => ['/Users/pivotal/foo/lic1', '/Users/pivotal/bar/lic2'],
+    }
+  end
+  let(:config) { LicenseFinder::Configuration.new }
+
+  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 }
+      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 }
+      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')
+      described_class.remove_yml
+    end
+  end
+
+  describe '.convert_all' do
+    before do
+      (DB.tables - [:schema_migrations]).each { |table| DB[table].truncate }
+    end
+
+    it "persists all of the dependency's attributes" do
+      described_class.convert_all([legacy_attributes])
+
+      described_class::Sql::Dependency.count.should == 1
+      saved_dep = described_class::Sql::Dependency.first
+      saved_dep.name.should == "spec_name"
+      saved_dep.version.should == "2.1.3"
+      saved_dep.summary.should == "some summary"
+      saved_dep.description.should == "some description"
+      saved_dep.homepage.should == "www.homepage.com"
+    end
+
+    it "associates the license to the dependency" do
+      described_class.convert_all([legacy_attributes])
+
+      saved_dep = described_class::Sql::Dependency.first
+      saved_dep.license.name.should == "GPLv2"
+      saved_dep.license.url.should == "www.license_url.org"
+      saved_dep.license.manual.should == true
+    end
+
+    it "associates bundler groups" do
+      described_class.convert_all([legacy_attributes])
+
+      saved_dep = described_class::Sql::Dependency.first
+      saved_dep.bundler_groups.count.should == 1
+      saved_dep.bundler_groups.first.name.should == 'test'
+    end
+
+    it "associates children" do
+      child_attrs = {
+        'name' => 'child1_name',
+        'version' => '0.0.1',
+        'license' => 'other'
+      }
+      described_class.convert_all([legacy_attributes, child_attrs])
+
+      described_class::Sql::Dependency.count.should == 2
+      saved_dep = described_class::Sql::Dependency.first(name: 'spec_name')
+      saved_dep.children.count.should == 1
+      saved_dep.children.first.name.should == 'child1_name'
+    end
+  end
+end