license_finder 2.0.4 → 2.1.0.rc1

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

@@ -8,6 +8,7 @@ module LicenseFinder
       Gem::Specification.new do |s|
         s.name = 'spec_name'
         s.version = '2.1.3'
+        s.authors = ['first', 'second']
         s.summary = 'summary'
         s.description = 'description'
         s.homepage = 'homepage'
@@ -17,14 +18,15 @@ module LicenseFinder
       end
     end
 
-    let(:bundler_dependency) { double(:dependency, groups: [1, 2, 3]) }
+    let(:bundler_dependency) { double(:dependency, groups: [:staging, :assets]) }
 
     its(:name) { should == 'spec_name' }
     its(:version) { should == '2.1.3' }
+    its(:authors) { should == 'first, second' }
     its(:summary) { should == "summary" }
     its(:description) { should == "description" }
     its(:homepage) { should == "homepage" }
-    its(:groups) { should == [1, 2, 3] }
+    its(:groups) { should == %w[staging assets] }
     its(:children) { should == ['foo'] }
     its(:license_names_from_spec) { should eq ['MIT', 'GPL'] }
     its(:install_path) { should =~ /spec_name-2\.1\.3\z/ }

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

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe GoDep do
+    subject { GoDep.new(project_path: Pathname('/fake/path')) }
+
+    it_behaves_like 'a PackageManager'
+
+    describe '#current_packages' do
+      let(:content) do
+        '{
+          "ImportPath": "github.com/pivotal/foo",
+          "GoVersion": "go1.4.2",
+          "Deps": [
+            {
+              "ImportPath": "github.com/pivotal/foo",
+              "Rev": "61164e49940b423ba1f12ddbdf01632ac793e5e9"
+            },
+            {
+              "ImportPath": "github.com/pivotal/bar",
+              "Rev": "3245708abcdef234589450649872346783298736"
+            }
+          ]
+        }'
+      end
+
+      before do
+        allow(IO).to receive(:read).with('/fake/path/Godeps/Godeps.json').and_return(content.to_s)
+      end
+
+      context 'when dependencies are vendored' do
+        before do
+          allow(FileTest).to receive(:exist?).with('/fake/path/Godeps/_workspace').and_return(true)
+        end
+
+        it 'should return an array of packages' do
+          packages = subject.current_packages
+          expect(packages.map(&:name)).to include('github.com/pivotal/foo', 'github.com/pivotal/bar')
+          expect(packages.map(&:version)).to include('61164e4', '3245708')
+        end
+
+        it 'should set the install_path to the vendored directory' do
+          packages = subject.current_packages
+          expect(packages[0].install_path).to eq('/fake/path/Godeps/_workspace/src/github.com/pivotal/foo')
+          expect(packages[1].install_path).to eq('/fake/path/Godeps/_workspace/src/github.com/pivotal/bar')
+        end
+      end
+
+      context 'when dependencies are not vendored' do
+        before do
+          ENV['GOPATH'] = '/fake/go/path'
+        end
+
+        after do
+          ENV['GOPATH'] = nil
+        end
+
+        it 'should return an array of packages' do
+          packages = subject.current_packages
+          expect(packages.map(&:name)).to include('github.com/pivotal/foo', 'github.com/pivotal/bar')
+          expect(packages.map(&:version)).to include('61164e4', '3245708')
+        end
+
+        it 'should set the install_path to the GOPATH' do
+          packages = subject.current_packages
+          expect(packages[0].install_path).to eq('/fake/go/path/src/github.com/pivotal/foo')
+          expect(packages[1].install_path).to eq('/fake/go/path/src/github.com/pivotal/bar')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe GoWorkspace do
+    let(:logger) { double(:logger, active: nil) }
+    subject { GoWorkspace.new(project_path: Pathname('/Users/pivotal/workspace/loggregator'), logger: logger) }
+
+    describe '#current_packages' do
+      let(:content) {
+        '_/Users/pivotal/workspace/loggregator/src/bitbucket.org/kardianos/osext
+         _/Users/pivotal/workspace/loggregator/src/deaagent
+         _/Users/pivotal/workspace/loggregator/src/deaagent/deaagent
+         _/Users/pivotal/workspace/loggregator/src/deaagent/domain
+         _/Users/pivotal/workspace/loggregator/src/doppler
+         _/Users/pivotal/workspace/loggregator/src/doppler/config
+         _/Users/pivotal/workspace/loggregator/src/doppler/groupedsinks
+         _/Users/pivotal/workspace/loggregator/src/doppler/groupedsinks/firehose_group
+         _/Users/pivotal/workspace/loggregator/src/doppler/groupedsinks/sink_wrapper'
+      }
+
+      before do
+        allow(Dir).to receive(:chdir).with(Pathname('/Users/pivotal/workspace/loggregator')) { |&block| block.call }
+        allow(subject).to receive(:capture).with('go list -f "{{.ImportPath}} " ./...').and_return([content.to_s, true])
+      end
+
+      describe 'should return an array of go packages' do
+        it 'provides package names' do
+          packages = subject.current_packages
+          first_package = packages.first
+          expect(first_package.name).to eq 'bitbucket.org/kardianos/osext'
+          expect(first_package.version).to eq 'unknown'
+          expect(first_package.install_path).to eq '/Users/pivotal/workspace/loggregator/src/bitbucket.org/kardianos/osext'
+        end
+      end
+    end
+
+    describe '#package_path' do
+      it 'returns the package_path' do
+        expect(subject.package_path).to eq Pathname('/Users/pivotal/workspace/loggregator/.envrc')
+      end
+    end
+
+    describe '#active?' do
+      let(:envrc)   { '/Users/pivotal/workspace/loggregator/.envrc' }
+
+      it 'returns true when .envrc contains GOPATH' do
+        allow(FileTest).to receive(:exist?).with(envrc).and_return(true)
+        allow(IO).to receive(:read).with(Pathname(envrc)).and_return('export GOPATH=/foo/bar')
+        expect(subject.active?).to eq(true)
+      end
+
+      it 'returns false when .envrc does not contain GOPATH' do
+        allow(FileTest).to receive(:exist?).with(envrc).and_return(true)
+        allow(IO).to receive(:read).with(Pathname(envrc)).and_return('this is not an envrc file')
+        expect(subject.active?).to eq(false)
+      end
+
+      it 'returns false when .envrc does not exist' do
+        allow(FileTest).to receive(:exist?).with(envrc).and_return(false)
+        expect(subject.active?).to eq(false)
+      end
+
+      it 'logs the active state' do
+        expect(logger).to receive(:active)
+        subject.active?
+      end
+    end
+  end
+end

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

@@ -11,6 +11,7 @@ module LicenseFinder
 
     its(:name) { should == "logback-classic" }
     its(:version) { should == "1.1.1" }
+    its(:authors) { should == "" }
     its(:summary) { should == "" }
     its(:description) { should == "" }
     its(:homepage) { should == "" }
@@ -18,6 +19,14 @@ module LicenseFinder
     its(:children) { should == [] } # no way to get children from gradle?
     its(:install_path) { should be_nil }
 
+    describe "when file name has a funny format, possibly because it is a jar saved in the project" do
+      it "uses a reasonable name and default version" do
+        subject = described_class.new("name" => "data.json-0.2.3.jar")
+        expect(subject.name).to eq "data.json-0.2.3.jar"
+        expect(subject.version).to eq "unknown"
+      end
+    end
+
     describe "#license_names_from_spec" do
       it "returns the license" do
         expect(subject.license_names_from_spec).to eq ["MIT"]

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

@@ -2,64 +2,114 @@ require 'spec_helper'
 
 module LicenseFinder
   describe Gradle do
-    let(:gradle) { Gradle.new }
-    it_behaves_like "a PackageManager"
+    subject { Gradle.new(project_path: Pathname('/fake/path')) }
+    
+    let(:content) { [] }
 
-    def license_xml(xml)
-      <<-resp
-        <dependencies>
-          #{xml}
-        </dependencies>
-      resp
-    end
-
-    def stub_license_report(dependencies, package_manager = gradle)
-      license_xml = license_xml(dependencies)
-      fake_file = double(:license_report, read: license_xml)
-      allow(package_manager).to receive(:license_report).and_return(fake_file)
-    end
+    it_behaves_like 'a PackageManager'
 
-    describe '.current_packages' do
+    describe '#current_packages' do
       before do
-        allow(gradle).to receive('`').with(/gradle downloadLicenses/)
+        allow(Dir).to receive(:chdir).with(Pathname('/fake/path')).and_return(['', true])
+        dependencies = double(:subject_dependency_file, dependencies: content)
+        expect(GradleDependencyFinder).to receive(:new).and_return(dependencies)
+      end
+
+      it 'uses custom subject command, if provided' do
+        subject = Gradle.new(gradle_command: 'subjectfoo', project_path: Pathname('/fake/path'))
+        expect(Dir).to receive(:chdir).with(Pathname('/fake/path')) { |&block| block.call }
+        expect(subject).to receive(:capture).with('subjectfoo downloadLicenses').and_return(['', true])
+        subject.current_packages
       end
 
-      it "uses custom gradle command, if provided" do
-        gradle = Gradle.new(gradle_command: "gradlefoo")
-        stub_license_report("", gradle)
-        expect(gradle).to receive('`').with(/gradlefoo downloadLicenses/)
-        gradle.current_packages
+      it 'sets the working directory to project_path, if provided' do
+        subject = Gradle.new(project_path: Pathname('/Users/foo/bar'))
+        expect(Dir).to receive(:chdir).with(Pathname('/Users/foo/bar')) { |&block| block.call }
+        expect(subject).to receive(:capture).with('gradle downloadLicenses').and_return(['', true])
+        subject.current_packages
       end
 
-      it 'lists all the current packages' do
-        stub_license_report("
-          <dependency name='org.springframework:spring-aop:4.0.1.RELEASE'>
-          </dependency>
-          <dependency name='org.springframework:spring-core:4.0.1.RELEASE'>
-          </dependency>
-        ")
+      context 'when dependencies are found' do
+        let(:content) do
+          [
+            "<dependencies>
+              <dependency name='org.springframework:spring-aop:4.0.1.RELEASE'></dependency>
+              <dependency name='org.springframework:spring-core:4.0.1.RELEASE'></dependency>
+            </dependencies>"
+          ]
+        end
 
-        expect(gradle.current_packages.map(&:name)).to eq ['spring-aop', 'spring-core']
+        it 'lists all dependencies' do
+          expect(subject.current_packages.map(&:name)).to eq ['spring-aop', 'spring-core']
+        end
       end
 
-      it "handles multiple licenses" do
-        stub_license_report("
-          <dependency name=''>
-            <license name='License 1'/>
-            <license name='License 2'/>
-          </dependency>
-        ")
+      context 'when multiple licenses exist' do
+        let(:content) do
+          [
+            "<dependencies>
+               <dependency name=''>
+                 <license name='License 1'/>
+                 <license name='License 2'/>
+               </dependency>
+            </dependencies>"
+          ]
+        end
 
-        expect(gradle.current_packages.first.licenses.map(&:name)).to eq ["License 1", "License 2"]
+        it 'lists all dependencies' do
+          expect(subject.current_packages.first.licenses.map(&:name)).to eq ['License 1', 'License 2']
+        end
       end
 
-      it "handles an empty list of licenses" do
-        stub_license_report("
-          <dependency name=''>
-          </dependency>
-        ")
+      context 'when no licenses exist' do
+        let(:content) do
+          [
+            "<dependencies>
+              <dependency name=''></dependency>
+            </dependencies>"
+          ]
+        end
+
+        it 'returns unknown' do
+          expect(subject.current_packages.first.licenses.map(&:name)).to eq ['unknown']
+        end
+      end
+
+      context 'when multiple license files exist' do
+        let(:content) do
+          [
+            "<dependencies>
+              <dependency name='junit:junit:4.12'></dependency>
+            </dependencies>",
+            "<dependencies>
+              <dependency name='org.mockito:mockito-core:1.9.5'></dependency>
+            </dependencies>"
+          ]
+        end
+
+        it 'lists all dependencies' do
+          expect(subject.current_packages.map(&:name)).to eq ['junit', 'mockito-core']
+        end
+
+        context 'and there are duplicate dependencies' do
+          let(:content) do
+            [
+              "<dependencies>
+                 <dependency name='junit:junit:4.12'></dependency>
+               </dependencies>",
+              "<dependencies>
+                 <dependency name='org.mockito:mockito-core:1.9.5'></dependency>
+               </dependencies>",
+              "<dependencies>
+                 <dependency name='org.mockito:mockito-core:1.9.5'></dependency>
+               </dependencies>"
+            ]
+          end
 
-        expect(gradle.current_packages.first.licenses.map(&:name)).to eq ['unknown']
+          it 'removes duplicates' do
+            expect(subject.current_packages.map(&:name)).to eq ['junit', 'mockito-core']
+          end
+        end
       end
     end
   end

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

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 module LicenseFinder
   describe Maven do
-    let(:maven) { Maven.new }
+    subject { Maven.new(project_path: Pathname('/fake/path')) }
+
     it_behaves_like "a PackageManager"
 
     def license_xml(xml)
@@ -18,12 +19,13 @@ module LicenseFinder
 
     describe '.current_packages' do
       before do
-        allow(maven).to receive('`').with(/mvn/)
+        allow(Dir).to receive(:chdir).with(Pathname('/fake/path')) { |&block| block.call }
+        allow(subject).to receive(:capture).with('mvn license:download-licenses').and_return(['', true])
       end
 
       def stub_license_report(deps)
         fake_file = double(:license_report, read: license_xml(deps))
-        allow(maven).to receive(:license_report).and_return(fake_file)
+        allow(subject).to receive(:license_report).and_return(fake_file)
       end
 
       it 'lists all the current packages' do
@@ -38,7 +40,7 @@ module LicenseFinder
            </dependency>
         ")
 
-        expect(maven.current_packages.map { |p| [p.name, p.version] }).to eq [
+        expect(subject.current_packages.map { |p| [p.name, p.version] }).to eq [
           ["junit", "4.11"],
           ["hamcrest-core", "1.3"]
         ]
@@ -58,7 +60,7 @@ module LicenseFinder
           </dependency>
         ")
 
-        expect(maven.current_packages.first.licenses.map(&:name)).to eq ['License 1', 'License 2']
+        expect(subject.current_packages.first.licenses.map(&:name)).to eq ['License 1', 'License 2']
       end
 
       it "handles no licenses" do
@@ -67,7 +69,7 @@ module LicenseFinder
           </dependency>
         ")
 
-        expect(maven.current_packages.first.licenses.map(&:name)).to eq ['unknown']
+        expect(subject.current_packages.first.licenses.map(&:name)).to eq ['unknown']
       end
     end
   end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe MergedPackage do
+    let(:package) { Package.new('foo', '1.0.0', spec_licenses: ['MIT']) }
+    let(:subproject_paths) { 'path/to/project/with/foo' }
+
+    subject { MergedPackage.new(package, [subproject_paths]) }
+
+    it 'returns the package name' do
+      expect(subject.name).to eq(package.name)
+    end
+
+    it 'returns the package version' do
+      expect(subject.version).to eq(package.version)
+    end
+
+    it 'returns the package licenses' do
+      expect(subject.licenses).to eq(package.licenses)
+    end
+
+    it 'returns the project path' do
+      expect(subject.subproject_paths.length).to eq(1)
+      expect(subject.subproject_paths[0]).to end_with(subproject_paths)
+    end
+
+    describe '#eql?' do
+      it 'returns true when the package names are equal' do
+        p1 = MergedPackage.new(Package.new('foo', '1.0.0'), ['/path/to/package1'])
+        p2 = MergedPackage.new(Package.new('foo', '2.0.0'), ['/path/to/package2'])
+        p3 = MergedPackage.new(Package.new('bar', '1.0.0'), ['/path/to/package3'])
+        expect(p1.eql?(p2)).to eq(true)
+        expect(p1.eql?(p3)).not_to eq(true)
+      end
+
+      it 'can handle merged packages that contain other merged packages' do
+        p1 = MergedPackage.new(Package.new('foo', '1.0.0'), ['/path/to/package1'])
+        p2 = MergedPackage.new(Package.new('foo', '2.0.0'), ['/path/to/package2'])
+        p3 = MergedPackage.new(p2, ['/path/to/package3', '/path/to/package2'])
+        expect(p1.eql?(p3)).to eq(true)
+      end
+    end
+
+    describe 'hash' do
+      it 'returns equal hash codes for packages that are equal' do
+        p1 = MergedPackage.new(Package.new('foo', '1.0.0'), ['/path/to/package1'])
+        p2 = MergedPackage.new(Package.new('foo', '2.0.0'), ['/path/to/package2'])
+        expect(p1.hash).to eq(p2.hash)
+      end
+    end
+  end
+end