license_finder 0.7.3 → 0.8.0

data/spec/lib/license_finder/gem_saver_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe GemSaver do
+    let(:gemspec) do
+      Gem::Specification.new do |s|
+        s.name = 'spec_name'
+        s.version = '2.1.3'
+        s.summary = 'summary'
+        s.description = 'description'
+        s.homepage = 'homepage'
+
+        s.add_dependency 'foo'
+      end
+    end
+
+    describe "#save" do
+      let(:bundled_gem) { BundledGem.new(gemspec) }
+      subject { described_class.find_or_initialize_by_name('spec_name', bundled_gem).save }
+
+      context "when the dependency is new" do
+        it "persists gem data" do
+          subject.id.should be
+          subject.name.should == "spec_name"
+          subject.version.should == "2.1.3"
+          subject.summary.should == "summary"
+          subject.description.should == "description"
+          subject.homepage.should == "homepage"
+        end
+
+        it "associates children" do
+          subject.children.map(&:name).should == ['foo']
+        end
+
+        it "marks depenency as unapproved by default" do
+          subject.approval.state.should == nil
+        end
+
+        context "with a bundler dependency" do
+          let(:bundled_gem) { BundledGem.new(gemspec, stub(:bundler_dependency, groups: %w[1 2 3]))}
+
+          it "saves the bundler groups" do
+            subject.bundler_groups.map(&:name).should =~ %w[1 2 3]
+          end
+        end
+      end
+
+      context "when the dependency already existed" do
+        let!(:old_copy) do
+          Dependency.create(
+            name: 'spec_name',
+            version: '0.1.2',
+            summary: 'old summary',
+            description: 'old desription',
+            homepage: 'old homepage'
+          )
+        end
+
+        it "merges in the latest data" do
+          subject.id.should == old_copy.id
+          subject.name.should == old_copy.name
+          subject.version.should == "2.1.3"
+          subject.summary.should == "summary"
+          subject.description.should == "description"
+          subject.homepage.should == "homepage"
+        end
+
+        it "keeps a manually assigned license" do
+          old_copy.license = LicenseAlias.create(name: 'foo', manual: true)
+          old_copy.save
+          subject.license.name.should == 'foo'
+        end
+
+        it "keeps approval" do
+          old_copy.approval = Approval.create(state: true)
+          old_copy.save
+          subject.approval.state.should == true
+        end
+
+        it "ensures correct children are associated" do
+          old_copy.add_child Dependency.new(name: 'bob')
+          old_copy.add_child Dependency.new(name: 'joe')
+          old_copy.children.each(&:save)
+          subject.children.map(&:name).should =~ ['foo']
+        end
+
+        context "with a bundler dependency" do
+          let(:bundled_gem) { BundledGem.new(gemspec, stub(:bundler_dependency, groups: %w[1 2 3]))}
+
+          before do
+            old_copy.add_bundler_group BundlerGroup.find_or_create(name: 'a')
+            old_copy.add_bundler_group BundlerGroup.find_or_create(name: 'b')
+          end
+
+          it "ensures the correct bundler groups are associated" do
+            subject.bundler_groups.map(&:name).should =~ %w[1 2 3]
+          end
+        end
+
+        context "license changes to something other than 'other'" do
+          before do
+            old_copy.license = LicenseAlias.create(name: 'other')
+            old_copy.save
+            gemspec.license = "new license"
+          end
+
+          context "new license is whitelisted" do
+            before { LicenseFinder.config.stub(:whitelist).and_return [gemspec.license] }
+
+            it "should set the approval to true" do
+              subject.should be_approved
+            end
+          end
+
+          context "new license is not whitelisted" do
+            it "should set the approval to false" do
+              subject.should_not be_approved
+            end
+          end
+        end
+
+        context "license changes to unknown (i.e., 'other')" do
+          before do
+            old_copy.license = LicenseAlias.create(name: 'MIT')
+            old_copy.approval = Approval.create(state: false)
+            old_copy.save
+            gemspec.license = "other"
+          end
+
+          it "should not change the license" do
+            subject.license.name.should == 'MIT'
+          end
+
+          it "should not change the approval" do
+            subject.should_not be_approved
+          end
+        end
+
+        context "license does not change" do
+          before do
+            old_copy.license = LicenseAlias.create(name: 'MIT')
+            old_copy.approval = Approval.create(state: false)
+            old_copy.save
+            gemspec.license = "MIT"
+          end
+
+          it "should not change the license or approval" do
+            subject.should_not be_approved
+            subject.license.name.should == "MIT"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/license_finder/html_report_spec.rb

@@ -1,65 +1,82 @@
 require "spec_helper"
+require "capybara"
 
 module LicenseFinder
   describe HtmlReport do
     describe "#to_s" do
-      let(:dependency) { Dependency.new 'approved' => true }
-      subject { HtmlReport.new([dependency]).to_s }
+      let(:dependency) do
+        dep = Dependency.new name: "the-name"
+        dep.license = LicenseAlias.create name: 'MIT'
+        dep.approval = Approval.create state: true
+        dep
+      end
+
+      subject { Capybara.string(HtmlReport.new([dependency]).to_s) }
 
       context "when the dependency is approved" do
         it "should add an approved class to dependency's container" do
-          should include %{class="approved"}
+          should have_selector ".approved"
+        end
+
+        it "does not list the dependency in the action items" do
+          should_not have_selector ".action-items"
         end
       end
 
       context "when the dependency is not approved" do
-        before { dependency.approved = false }
+        before { dependency.approval.state = false }
 
         it "should not add an approved class to he dependency's container" do
-          should include %{class="unapproved"}
+          should have_selector ".unapproved"
+        end
+
+        it "lists the dependency in the action items" do
+          should have_selector ".action-items li"
         end
       end
 
       context "when the gem has at least one bundler group" do
-        before { dependency.bundler_groups = ["group"] }
+        before { dependency.stub(bundler_groups: [stub(name: "group")]) }
         it "should show the bundler group(s) in parens" do
-          should include "(group)"
+          should have_text "(group)"
         end
       end
 
       context "when the gem has no bundler groups" do
-        before { dependency.bundler_groups = [] }
+        before { dependency.stub(bundler_groups: []) }
 
         it "should not show any parens or bundler group info" do
-          should_not include "()"
+          should_not have_text "()"
         end
 
       end
 
       context "when the gem has at least one parent" do
-        before { dependency.parents = [OpenStruct.new(:name => "foo parent")] }
+        before { dependency.stub(parents: [stub(:name => "foo parent")]) }
         it "should include a parents section" do
-          should include "Parents"
+          should have_text "Parents"
+          should have_text "foo parent"
         end
       end
 
       context "when the gem has no parents" do
         it "should not include any parents section in the output" do
-          should_not include "Parents"
+          should_not have_text "Parents"
         end
       end
 
       context "when the gem has at least one child" do
-        before { dependency.children = [OpenStruct.new(:name => "foo child")] }
+        before { dependency.stub(children: [stub(:name => "foo child")]) }
 
         it "should include a Children section" do
-          should include "Children"
+          should have_text "Children"
+          should have_text "foo child"
         end
       end
 
       context "when the gem has no children" do
         it "should not include any Children section in the output" do
-          should_not include "Children"
+          should_not have_text "Children"
         end
       end
     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/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