license_finder 3.0.4 → 3.1.1

data/spec/lib/license_finder/core_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-module LicenseFinder
-  describe Core do
-    let(:options) { {} }
-    let(:license_finder) { described_class.new(options) }
-    let(:logger) { Logger.new(options[:logger]) }
-    let(:configuration) { LicenseFinder::Configuration.new(options, {})}
-    let(:pathname) { Pathname.pwd + Pathname(options[:project_path]) }
-
-    before do
-      allow(Logger).to receive(:new).and_return(logger)
-    end
-
-    describe "#unapproved" do
-      let(:options) {
-        {
-          logger: {},
-          project_path: 'other_directory',
-          gradle_command: 'just_do_it',
-          rebar_command: 'do_it',
-          rebar_deps_dir: 'nowhere/deps'
-        }
-      }
-      let(:package_options) {
-        {
-          logger: logger,
-          project_path: configuration.project_path,
-          ignored_groups: Set.new,
-          go_full_version: nil,
-          gradle_command: configuration.gradle_command,
-          gradle_include_groups: nil,
-          maven_include_groups: nil,
-          maven_options: nil,
-          pip_requirements_path: nil,
-          rebar_command: configuration.rebar_command,
-          rebar_deps_dir: configuration.rebar_deps_dir
-        }
-      }
-
-      it "delegates to the decision_applier" do
-        decision_applier =  double(:decision_applier)
-        allow(license_finder).to receive(:decision_applier).and_return(decision_applier)
-        expect(decision_applier).to receive(:unapproved)
-        license_finder.unapproved
-      end
-
-      it "passes through options when fetching current packages" do
-        expect(PackageManager).to receive(:current_packages).with(package_options).and_return([])
-        license_finder.unapproved
-      end
-    end
-  end
-end

data/spec/lib/license_finder/decision_applier_spec.rb

@@ -1,219 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe DecisionApplier do
-    it "reports nothing found" do
-      decision_applier = described_class.new(
-        decisions: Decisions.new,
-        packages: []
-      )
-      expect(decision_applier.any_packages?).to be false
-    end
-
-    describe "#acknowledged" do
-      it "combines manual and system packages" do
-        decision_applier = described_class.new(
-          decisions: Decisions.new.add_package("manual", nil),
-          packages: [Package.new("system")]
-        )
-        expect(decision_applier.acknowledged.map(&:name)).to match_array ["manual", "system"]
-      end
-
-      it "applies decided licenses" do
-        decisions = Decisions.new
-          .add_package("manual", nil)
-          .license("manual", "MIT")
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        expect(decision_applier.acknowledged.last.licenses).to eq Set.new([License.find_by_name("MIT")])
-      end
-
-      it "ignores specific packages" do
-        decisions = Decisions.new
-          .add_package("manual", nil)
-          .ignore("manual")
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        expect(decision_applier.acknowledged).to be_empty
-      end
-
-      it "ignores packages in certain groups" do
-        decisions = Decisions.new
-          .ignore_group("development")
-        dev_dep = Package.new("dep", nil, groups: ["development"])
-        decision_applier = described_class.new(
-          decisions: decisions,
-          packages: [dev_dep]
-        )
-        expect(decision_applier.acknowledged).to be_empty
-      end
-
-      it "does not ignore packages if some of their groups are not ignored" do
-        decisions = Decisions.new
-                      .ignore_group("development")
-        dev_and_prod_dep = Package.new("dev_and_prod_dep", nil, groups: ["development", "production"])
-        decision_applier = described_class.new(
-          decisions: decisions,
-          packages: [dev_and_prod_dep]
-        )
-        expect(decision_applier.acknowledged).to eq [dev_and_prod_dep]
-      end
-
-      it "does not ignore packages if they have no groups" do
-        decisions = Decisions.new
-                      .ignore_group("development")
-        dep_with_no_group = Package.new("dep_with_no_group", nil, groups: [])
-        decision_applier = described_class.new(
-          decisions: decisions,
-          packages: [dep_with_no_group]
-        )
-        expect(decision_applier.acknowledged).to eq [dep_with_no_group]
-      end
-
-
-      it "adds manual approvals to packages" do
-        decisions = Decisions.new
-          .add_package("manual", nil)
-          .approve("manual", who: "Approver", why: "Because")
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to be_approved
-        expect(dep).to be_approved_manually
-        expect(dep.manual_approval.who).to eq "Approver"
-        expect(dep.manual_approval.why).to eq "Because"
-      end
-
-      it "adds whitelist approvals to packages" do
-        decisions = Decisions.new
-          .add_package("manual", nil)
-          .license("manual", "MIT")
-          .whitelist("MIT")
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to be_approved
-        expect(dep).to be_whitelisted
-      end
-
-      it "forbids approval of packages with only blacklisted license" do
-        decisions = Decisions.new
-          .add_package("manual", nil)
-          .license("manual", "ABC")
-          .whitelist("ABC")
-          .approve("manual")
-          .blacklist("ABC")
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).not_to be_approved
-      end
-
-      it "allows approval of packages if not all licenses are blacklisted" do
-        decisions = Decisions.new
-          .add_package("manual", nil)
-          .license("manual", "ABC")
-          .license("manual", "DEF")
-          .whitelist("ABC")
-          .blacklist("DEF")
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to be_approved
-        expect(dep).to be_whitelisted
-
-        decisions = Decisions.new
-          .add_package("manual", nil)
-          .license("manual", "ABC")
-          .license("manual", "DEF")
-          .approve("manual")
-          .blacklist("DEF")
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to be_approved
-        expect(dep).to be_approved_manually
-      end
-
-      it 'does not return an approval for a package without a version if all approvals have an explicit version' do
-        decisions = Decisions.new
-                        .add_package('spring-boot', nil)
-                        .approve('spring-boot', versions: ['1.3.0.RELEASE'], who: 'Approver', why: 'Because')
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to_not be_approved
-      end
-
-      it 'does not return an approval if the package has the wrong version' do
-        decisions = Decisions.new
-                        .add_package('spring-boot', '1.3.1.RELEASE')
-                        .approve('spring-boot', versions: ['1.3.0.RELEASE'], who: 'Approver', why: 'Because')
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to_not be_approved
-      end
-
-      it 'returns an approval if the requested package has an approved version' do
-        decisions = Decisions.new
-                        .add_package('spring-boot', '1.3.0.RELEASE')
-                        .approve('spring-boot', versions: ['1.3.0.RELEASE'], who: 'Approver', why: 'Because')
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to be_approved
-        expect(dep).to be_approved_manually
-      end
-
-      it 'returns an approval if the requested package has been approved, but no version was specified' do
-        decisions = Decisions.new
-                        .add_package('spring-boot', '1.3.0.RELEASE')
-                        .approve('spring-boot', versions: [], who: 'Approver', why: 'Because')
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to be_approved
-        expect(dep).to be_approved_manually
-      end
-
-      it 'does not return an approval if no dependencies have been approved' do
-        decisions = Decisions.new
-                        .add_package('spring-boot', '1.3.0.RELEASE')
-        decision_applier = described_class.new(decisions: decisions, packages: [])
-        dep = decision_applier.acknowledged.last
-        expect(dep).to_not be_approved
-      end
-    end
-
-    describe '#unapproved' do
-      it 'returns all acknowledged packages that are not approved' do
-        packages = [
-          Package.new('foo', '0.0.1', spec_licenses: ['whitelist']),
-          Package.new('bar', '0.0.1', spec_licenses: ['blacklist'])
-        ]
-        decisions = Decisions.new
-          .add_package('baz', '0.0.1')
-          .whitelist('whitelist')
-          .blacklist('blacklist')
-        decision_applier = described_class.new(decisions: decisions, packages: packages)
-
-        expect(decision_applier.unapproved.map(&:name)).to include('baz')
-        expect(decision_applier.unapproved.map(&:name)).to include('bar')
-        expect(decision_applier.unapproved.map(&:name)).not_to include('foo')
-      end
-    end
-
-    describe '#blacklisted' do
-      it 'returns all packages that have blacklisted licenses' do
-        decision_applier = described_class.new(
-          decisions: Decisions.new.blacklist('GPLv3'),
-          packages: [Package.new('foo', '1.0', spec_licenses: ['GPLv3'])]
-        )
-
-        expect(decision_applier.blacklisted.map(&:name)).to eq(['foo'])
-      end
-
-      it 'does not report ignored packages' do
-        dev_dep = Package.new("dev_dep", nil, spec_licenses: ['GPLv3'], groups: ["development"])
-        decisions = Decisions.new
-          .ignore_group("development")
-          .add_package("manual", nil)
-          .ignore("manual")
-          .blacklist('GPLv3')
-        decision_applier = described_class.new(decisions: decisions, packages: [dev_dep])
-
-        expect(decision_applier.blacklisted).to be_empty
-      end
-    end
-  end
-end

data/spec/lib/license_finder/decisions_spec.rb

@@ -1,408 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Decisions do
-    describe ".add_package" do
-      it "adds to list of packages" do
-        packages = subject.add_package("dep", nil).packages
-        expect(packages.map(&:name)).to eq ["dep"]
-      end
-
-      it "includes optional version" do
-        packages = subject.add_package("dep", "0.2.0").packages
-        expect(packages.first.version).to eq "0.2.0"
-      end
-    end
-
-    describe ".remove_package" do
-      it "drops a package" do
-        packages = subject
-          .add_package("dep", nil)
-          .remove_package("dep")
-          .packages
-        expect(packages.size).to eq 0
-      end
-
-      it "does nothing if package was never added" do
-        packages = subject
-          .remove_package("dep")
-          .packages
-        expect(packages.size).to eq 0
-      end
-    end
-
-    describe ".license" do
-      it "will report license for a dependency" do
-        license = subject
-          .license("dep", "MIT")
-          .licenses_of("dep")
-          .first
-        expect(license).to eq License.find_by_name("MIT")
-      end
-
-      it "will report multiple licenses" do
-        licenses = subject
-          .license("dep", "MIT")
-          .license("dep", "GPL")
-          .licenses_of("dep")
-        expect(licenses).to eq [
-          License.find_by_name("MIT"),
-          License.find_by_name("GPL"),
-        ].to_set
-      end
-
-      it "adapts names" do
-        license = subject
-          .license("dep", "Expat")
-          .licenses_of("dep")
-          .first
-        expect(license).to eq License.find_by_name("MIT")
-      end
-    end
-
-    describe ".unlicense" do
-      it "will not report the given dependency as licensed" do
-        licenses = subject
-          .license("dep", "MIT")
-          .unlicense("dep", "MIT")
-          .licenses_of("dep")
-        expect(licenses).to be_empty
-      end
-
-      it "will only remove the specified license" do
-        licenses = subject
-          .license("dep", "MIT")
-          .license("dep", "GPL")
-          .unlicense("dep", "MIT")
-          .licenses_of("dep")
-        expect(licenses).to eq [License.find_by_name("GPL")].to_set
-      end
-
-      it "is cumulative" do
-        license = subject
-          .license("dep", "MIT")
-          .unlicense("dep", "MIT")
-          .license("dep", "MIT")
-          .licenses_of("dep")
-          .first
-        expect(license).to eq License.find_by_name("MIT")
-      end
-    end
-
-    describe ".approve" do
-      it "will report a dependency as approved" do
-        decisions = subject.approve("dep")
-        expect(decisions).to be_approved("dep")
-      end
-
-      it "will not report a dependency as approved by default" do
-        expect(subject).not_to be_approved("dep")
-      end
-    end
-
-    describe ".unapprove" do
-      it "will not report the given dependency as approved" do
-        decisions = subject
-          .approve("dep")
-          .unapprove("dep")
-        expect(subject).not_to be_approved("dep")
-      end
-
-      it "is cumulative" do
-        decisions = subject
-          .approve("dep")
-          .unapprove("dep")
-          .approve("dep")
-        expect(subject).to be_approved("dep")
-      end
-    end
-
-    describe ".whitelist" do
-      it "will report the given license as approved" do
-        decisions = subject.whitelist("MIT")
-        expect(decisions).to be_whitelisted(License.find_by_name("MIT"))
-      end
-
-      it "adapts names" do
-        decisions = subject.whitelist("Expat")
-        expect(decisions).to be_whitelisted(License.find_by_name("MIT"))
-      end
-
-      it "adds to list" do
-        decisions = subject.whitelist("MIT")
-        expect(decisions.whitelisted).to eq(Set.new([License.find_by_name("MIT")]))
-      end
-    end
-
-    describe ".unwhitelist" do
-      it "will not report the given license as approved" do
-        decisions = subject
-          .whitelist("MIT")
-          .unwhitelist("MIT")
-        expect(decisions).not_to be_whitelisted(License.find_by_name("MIT"))
-      end
-
-      it "is cumulative" do
-        decisions = subject
-          .whitelist("MIT")
-          .unwhitelist("MIT")
-          .whitelist("MIT")
-        expect(decisions).to be_whitelisted(License.find_by_name("MIT"))
-      end
-
-      it "adapts names" do
-        decisions = subject
-          .whitelist("MIT")
-          .unwhitelist("Expat")
-        expect(decisions).not_to be_whitelisted(License.find_by_name("MIT"))
-      end
-    end
-
-    describe ".blacklist" do
-      it "will report the given license as blacklisted" do
-        decisions = subject.blacklist("MIT")
-        expect(decisions).to be_blacklisted(License.find_by_name("MIT"))
-      end
-
-      it "adapts names" do
-        decisions = subject.blacklist("Expat")
-        expect(decisions).to be_blacklisted(License.find_by_name("MIT"))
-      end
-
-      it "adds to list" do
-        decisions = subject.blacklist("MIT")
-        expect(decisions.blacklisted).to eq(Set.new([License.find_by_name("MIT")]))
-      end
-    end
-
-    describe ".unblacklist" do
-      it "will not report the given license as blacklisted" do
-        decisions = subject
-          .blacklist("MIT")
-          .unblacklist("MIT")
-        expect(decisions).not_to be_blacklisted(License.find_by_name("MIT"))
-      end
-
-      it "is cumulative" do
-        decisions = subject
-          .blacklist("MIT")
-          .unblacklist("MIT")
-          .blacklist("MIT")
-        expect(decisions).to be_blacklisted(License.find_by_name("MIT"))
-      end
-
-      it "adapts names" do
-        decisions = subject
-          .blacklist("MIT")
-          .unblacklist("Expat")
-        expect(decisions).not_to be_blacklisted(License.find_by_name("MIT"))
-      end
-    end
-
-    describe ".ignore" do
-      it "will report ignored dependencies" do
-        decisions = subject.ignore("dep")
-        expect(decisions).to be_ignored("dep")
-      end
-    end
-
-    describe ".heed" do
-      it "will not report heeded dependencies" do
-        decisions = subject
-          .ignore("dep")
-          .heed("dep")
-        expect(decisions).not_to be_ignored("dep")
-      end
-
-      it "is cumulative" do
-        decisions = subject
-          .ignore("dep")
-          .heed("dep")
-          .ignore("dep")
-        expect(decisions).to be_ignored("dep")
-      end
-    end
-
-    describe ".ignore_group" do
-      it "will report ignored groups" do
-        decisions = subject.ignore_group("development")
-        expect(decisions).to be_ignored_group("development")
-      end
-    end
-
-    describe ".heed_group" do
-      it "will not report heeded groups" do
-        decisions = subject
-          .ignore_group("development")
-          .heed_group("development")
-        expect(decisions).not_to be_ignored_group("development")
-      end
-
-      it "is cumulative" do
-        decisions = subject
-          .ignore_group("development")
-          .heed_group("development")
-          .ignore_group("development")
-        expect(decisions).to be_ignored_group("development")
-      end
-    end
-
-    describe ".name_project" do
-      it "reports project name" do
-        decisions = subject.name_project("proj")
-        expect(decisions.project_name).to eq "proj"
-      end
-    end
-
-    describe ".unname_project" do
-      it "reports project name" do
-        decisions = subject
-          .name_project("proj")
-          .unname_project
-        expect(decisions.project_name).to be_nil
-      end
-    end
-
-    describe "persistence" do
-      def roundtrip(decisions)
-        described_class.restore(decisions.persist)
-      end
-
-      it "can restore added packages" do
-        decisions = roundtrip(
-          subject.add_package("dep", "0.2.0")
-        )
-        packages = decisions.packages
-        expect(packages.map(&:name)).to eq ["dep"]
-      end
-
-      it "can restore removed packages" do
-        decisions = roundtrip(
-          subject
-            .add_package("dep", nil)
-            .remove_package("dep")
-        )
-        expect(decisions.packages.size).to eq 0
-      end
-
-      it "can restore licenses" do
-        license = roundtrip(
-          subject.license("dep", "MIT")
-        ).licenses_of("dep").first
-        expect(license).to eq License.find_by_name("MIT")
-      end
-
-      it "can restore unlicenses" do
-        licenses = roundtrip(
-          subject
-            .license("dep", "MIT")
-            .license("dep", "GPL")
-            .unlicense("dep", "MIT")
-        ).licenses_of("dep")
-        expect(licenses).to eq [License.find_by_name("GPL")].to_set
-      end
-
-      it "can restore approvals" do
-        time = Time.now.getutc
-        decisions = roundtrip(subject.approve("dep", who: "Somebody", why: "Some reason", when: time))
-        expect(decisions).to be_approved("dep")
-        approval = decisions.approval_of("dep")
-        expect(approval.who).to eq "Somebody"
-        expect(approval.why).to eq "Some reason"
-        expect(approval.safe_when).to eq time
-      end
-
-      it "can restore unapprovals" do
-        decisions = roundtrip(
-          subject
-            .approve("dep")
-            .unapprove("dep")
-        )
-        expect(decisions).not_to be_approved("dep")
-      end
-
-      it "can restore whitelists" do
-        decisions = roundtrip(
-          subject.whitelist("MIT")
-        )
-        expect(decisions).to be_whitelisted(License.find_by_name("MIT"))
-      end
-
-      it "can restore un-whitelists" do
-        decisions = roundtrip(
-          subject
-            .whitelist("MIT")
-            .unwhitelist("MIT")
-        )
-        expect(decisions).not_to be_whitelisted(License.find_by_name("MIT"))
-      end
-
-      it "can restore blacklists" do
-        decisions = roundtrip(
-          subject.blacklist("MIT")
-        )
-        expect(decisions).to be_blacklisted(License.find_by_name("MIT"))
-      end
-
-      it "can restore un-blacklists" do
-        decisions = roundtrip(
-          subject
-            .blacklist("MIT")
-            .unblacklist("MIT")
-        )
-        expect(decisions).not_to be_blacklisted(License.find_by_name("MIT"))
-      end
-
-      it "can restore ignorals" do
-        decisions = roundtrip(subject.ignore("dep"))
-        expect(decisions).to be_ignored("dep")
-      end
-
-      it "can restore heeds" do
-        decisions = roundtrip(
-          subject
-            .ignore("dep")
-            .heed("dep")
-        )
-        expect(decisions).not_to be_ignored("dep")
-      end
-
-      it "can restore ignored groups" do
-        decisions = roundtrip(
-          subject.ignore_group("development")
-        )
-        expect(decisions).to be_ignored_group("development")
-      end
-
-      it "can restore heeded groups" do
-        decisions = roundtrip(
-          subject
-            .ignore_group("development")
-            .heed_group("development")
-        )
-        expect(decisions).not_to be_ignored_group("development")
-      end
-
-      it "can restore project names" do
-        decisions = roundtrip(
-          subject.name_project("an-app")
-        )
-        expect(decisions.project_name).to eq "an-app"
-      end
-
-      it "can restore project unnames" do
-        decisions = roundtrip(
-          subject
-            .name_project("an-app")
-            .unname_project
-        )
-        expect(decisions.project_name).to be_nil
-      end
-
-      it "ignores empty or missing persisted decisions" do
-        described_class.restore('')
-        described_class.restore(nil)
-      end
-    end
-  end
-end