license_finder 0.9.4 → 0.9.5

data/spec/lib/license_finder/npm_package_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe NpmPackage do
+    subject do
+      described_class.new(
+        "name" => "jasmine-node",
+        "version" => "1.3.1",
+        "description" => "a description",
+        "readme" => "a readme",
+        "path" => "some/node/package/path"
+      )
+    end
+
+    it_behaves_like "it conforms to interface required by PackageSaver"
+
+    its(:name) { should == "jasmine-node" }
+    its(:version) { should == "1.3.1" }
+    its(:summary) { should == "a description" }
+    its(:description) { should == "a readme" }
+
+    describe '#license' do
+      def stub_license_files(license_files)
+        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"}} }
+
+      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")
+      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
+
+      it "returns 'other' otherwise" do
+        stub_license_files []
+
+        subject.license.should == "other"
+      end
+    end
+  end
+end
+

data/spec/lib/license_finder/npm_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 module LicenseFinder
   describe NPM do
-    describe '.current_modules' do
+    describe '.current_packages' do
       before { NPM.instance_variable_set(:@modules, nil) }
 
-      it 'lists all the current modules' do
+      it 'fetches data from npm' do
         json = <<-JSON
           {
             "dependencies": {
@@ -64,40 +64,40 @@ module LicenseFinder
         JSON
         allow(NPM).to receive(:capture).with(/npm/).and_return([json, true])
 
-        current_modules = NPM.current_modules
+        current_packages = NPM.current_packages
 
-        expect(current_modules.map(&:name)).to eq(["depjs 1.3.3.7", "dep2js 4.2", "dep3js 4.2", "dep5js 4.2", "dep4js 4.2"])
-        expect(current_modules.first).to be_a(Package)
+        expect(current_packages.map(&:name)).to eq(["depjs", "dep2js", "dep3js", "dep5js", "dep4js"])
+        expect(current_packages.first).to be_a(Package)
+        expect(current_packages.first.name).to eq("depjs")
       end
 
-      it 'memoizes the current_modules' do
-        allow(NPM).to receive(:capture).with(/npm/).and_return(['{}', true]).once
+      it "does not support name version string" do
+        json = <<-JSON
+          {
+            "devDependencies": {
+              "foo": "4.2"
+            }
+          }
+        JSON
+        allow(NPM).to receive(:capture).with(/npm/).and_return([json, true])
+
+        current_packages = NPM.current_packages
 
-        NPM.current_modules
-        NPM.current_modules
+        expect(current_packages.map(&:name)).to eq([])
       end
 
       it "fails when command fails" do
         allow(NPM).to receive(:capture).with(/npm/).and_return('Some error', false).once
-        expect { NPM.current_modules }.to raise_error(RuntimeError)
+        expect { NPM.current_packages }.to raise_error(RuntimeError)
       end
-    end
-
-    describe '.harvest_license' do
-      let(:node_module1) { {"license" => "MIT"} }
-      let(:node_module2) { {"licenses" => [{"type" => "BSD", "url" => "github.github/github"}]} }
-      let(:node_module3) { {"license" => {"type" => "PSF", "url" => "github.github/github"}} }
-      let(:node_module4) { {"licenses" => ["MIT"]} }
 
-      it 'finds the license for both license structures' do
-        NPM.harvest_license(node_module1).should eq("MIT")
-        NPM.harvest_license(node_module2).should eq("BSD")
-        NPM.harvest_license(node_module3).should eq("PSF")
-        NPM.harvest_license(node_module4).should eq("MIT")
+      it "does not fail when command fails but produces output" do
+        allow(NPM).to receive(:capture).with(/npm/).and_return('{"foo":"bar"}', false).once
+        NPM.current_packages
       end
     end
 
-    describe '.has_package?' do
+    describe '.active?' do
       let(:package) { Pathname.new('package.json').expand_path }
 
       context 'with a package.json file' do
@@ -106,7 +106,7 @@ module LicenseFinder
         end
 
         it 'returns true' do
-          expect(NPM.has_package?).to eq(true)
+          expect(NPM.active?).to eq(true)
         end
       end
 
@@ -116,7 +116,7 @@ module LicenseFinder
         end
 
         it 'returns false' do
-          expect(NPM.has_package?).to eq(false)
+          expect(NPM.active?).to eq(false)
         end
       end
     end

data/spec/lib/license_finder/package_saver_spec.rb

@@ -2,206 +2,66 @@ require 'spec_helper'
 
 module LicenseFinder
   describe PackageSaver 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
+    let(:package) do
+      double(
+        :package,
+        license: 'license',
+        children: ['child'],
+        groups: [:group],
+        summary: 'summary',
+        description: 'description',
+        name: 'spec_name',
+        version: '1.2.3',
+        homepage: 'http://example.com'
+      )
     end
 
-    describe ".save_gems" do
-      let(:packages) { [gem] }
-      let(:gem) { double(:package) }
+    describe ".save_all" do
+      let(:dependency) { double(:dependency).as_null_object }
 
-      it "calls find_or_create_by_name on all passed in gems" do
-        described_class.should_receive(:find_or_create_by_name).with(gem).and_return(gem)
-        gem.should_receive(:save)
-        described_class.save_packages(packages)
+      it "find and updates relevant dependencies" do
+        Dependency.should_receive(:named).with('spec_name').and_return(dependency)
+        dependency.should_receive(:save_changes)
+        described_class.save_all([package])
       end
     end
 
     describe "#save" do
-      let(:package) { Package.new(gemspec) }
-      subject { described_class.find_or_create_by_name(package).save }
-
-      before { package.children = ["foo"] }
-
-      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
-
-        describe "associating children" do
-          it "associates children" do
-            subject.children.map(&:name).should == ['foo']
-            subject.children.each { |child| child.id.should_not be_nil }
-          end
-        end
-
-        it "marks depenency as unapproved by default" do
-          subject.approval.state.should == nil
-        end
-
-        context "with a bundler dependency" do
-          let(:package) { Package.new(gemspec, double(: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
+      it "persists changes" do
+        dep = Dependency.create(
+          name: 'spec_name',
+          version: '0.1.2',
+          summary: 'old summary',
+          description: 'old desription',
+          homepage: 'old homepage',
+          license: LicenseAlias.named('old license')
+        )
+        dep.add_bundler_group BundlerGroup.named("old group")
+        dep.add_child Dependency.named("old child")
+
+        saver = described_class.new(dep, package)
+        subject = saver.save
+
+        subject.id.should be
+        subject.name.should == "spec_name"
+        subject.version.should == "1.2.3"
+        subject.summary.should == "summary"
+        subject.description.should == "description"
+        subject.homepage.should == "http://example.com"
+        subject.bundler_groups.map(&:name).should == ['group']
+        subject.children.map(&:name).should == ['child']
+        subject.license.name.should == 'license'
       end
 
-      context "when the dependency already existed" do
-        before { LicenseFinder.stub(:current_gems).and_return([double(:gemspec, name: "foo 0.0")]) }
-
-        context "the values have not changed" do
-          let!(:original_dependency) do
-            license = LicenseAlias.create(
-              name: 'other'
-            )
-            Dependency.create(
-              name: 'spec_name',
-              version: '2.1.3',
-              summary: 'summary',
-              description: 'description',
-              homepage: 'homepage',
-              license: license
-            )
-          end
-          let(:package_saver) { described_class.find_or_create_by_name(package) }
-
-          it "does not save the dependency" do
-            package_saver.dependency.should_not_receive(:save)
-            package_saver.save
-          end
-        end
-
-        context "the values have changed" do
-          let!(:old_copy) do
-            dep = Dependency.create(
-              name: 'spec_name',
-              version: '0.1.2',
-              summary: 'old summary',
-              description: 'old desription',
-              homepage: 'old homepage'
-            )
-            dep.approval = Approval.create
-            dep
-          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')
-            old_copy.license_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
-            if LicenseFinder::Platform.java?
-              subject.approval.state.should == 1
-            else
-              subject.approval.state.should == true
-            end
-          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(:package) { Package.new(gemspec, double(:bundler_dependency)) }
-
-            before do
-              package.stub(:groups) { [:group_1, :group_2, :b] }
-              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[group_1 group_2 b]
-            end
-          end
-
-          context "license has changed" 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
-
-            context "license already exists" do
-              it "uses the existing license" do
-                new_license = LicenseAlias.create(name: 'new license')
-                subject.license.should == new_license
-              end
-            end
-          end
-
-          context "license does not change" do
-            let(:package_saver) { described_class.find_or_create_by_name(package) }
-
-            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
-              dependency = package_saver.save
-              if LicenseFinder::Platform.java?
-                dependency.approved?.should_not == 1
-              else
-                dependency.should_not be_approved
-              end
-              dependency.license.name.should == "MIT"
-            end
+      it "keeps approval" do
+        dep = Dependency.create(
+          name: 'spec_name',
+          manually_approved: true
+        )
+        saver = described_class.new(dep, package)
+        subject = saver.save
 
-            it "should not save the license" do
-              package_saver.dependency.license.should_not_receive(:save)
-              package_saver.save
-            end
-          end
-        end
+        subject.should be_approved
       end
     end
   end

data/spec/lib/license_finder/pip_package_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe PipPackage do
+    subject { make_package({}) }
+
+    it_behaves_like "it conforms to interface required by PackageSaver"
+
+    def make_package(pypi_def)
+      described_class.new('jasmine', '1.3.1', "jasmine/install/path", pypi_def)
+    end
+
+    its(:name) { should == "jasmine" }
+    its(:version) { should == "1.3.1" }
+
+    describe "#summary" do
+      it "delegates to pypi def" do
+        subject = make_package("summary" => "A summary")
+        expect(subject.summary).to eq("A summary")
+      end
+
+      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
+
+      it "falls back to nothing" do
+        expect(subject.description).to eq("")
+      end
+    end
+
+    describe '#license' do
+      describe "with 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.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' ] }
+
+          subject = make_package(data)
+
+          expect(subject.license).to eq('Apache 2.0 License')
+        end
+      end
+
+      describe "without pypi license" do
+        def stub_license_files(license_files)
+          PossibleLicenseFiles.stub(:find).with("jasmine/install/path").and_return(license_files)
+        end
+
+        it 'returns license from file' do
+          stub_license_files [double(:license_file, license: 'License from file')]
+          expect(subject.license).to eq('License from file')
+        end
+
+        it 'returns other if no license can be found' do
+          stub_license_files []
+          expect(subject.license).to eq('other')
+        end
+      end
+    end
+  end
+end