license_finder 1.2 → 2.0.0.rc2

data/spec/lib/license_finder/cli/project_name_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+module LicenseFinder
+  module CLI
+    describe ProjectName do
+      let(:decisions) { Decisions.new }
+
+      before do
+        allow(Decisions).to receive(:saved!) { decisions }
+      end
+
+      describe "show" do
+        it "shows the configured project name" do
+          decisions.name_project("test")
+
+          expect(capture_stdout { subject.show }).to match /test/
+        end
+      end
+
+      describe "add" do
+        it "sets the project name" do
+          silence_stdout do
+            subject.add("test")
+          end
+          expect(subject.decisions.project_name).to eq "test"
+        end
+      end
+
+      describe "remove" do
+        it "removes the project name" do
+          silence_stdout do
+            subject.add("test")
+            subject.remove
+          end
+          expect(subject.decisions.project_name).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/lib/license_finder/cli/whitelist_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+module LicenseFinder
+  module CLI
+    describe Whitelist do
+      let(:decisions) { Decisions.new }
+
+      before do
+        allow(Decisions).to receive(:saved!) { decisions }
+      end
+
+      describe "list" do
+        it "shows the whitelist of licenses" do
+          decisions.whitelist("MIT")
+
+          expect(capture_stdout { subject.list }).to match /MIT/
+        end
+      end
+
+      describe "add" do
+        it "adds the specified license to the whitelist" do
+          silence_stdout do
+            subject.add("test")
+          end
+          expect(subject.decisions.whitelisted).to eq [License.find_by_name("test")].to_set
+        end
+
+        it "adds multiple licenses to the whitelist" do
+          silence_stdout do
+            subject.add("test", "rest")
+          end
+          expect(subject.decisions.whitelisted).to eq [
+            License.find_by_name("test"),
+            License.find_by_name("rest")
+          ].to_set
+        end
+      end
+
+      describe "remove" do
+        it "removes the specified license from the whitelist" do
+          silence_stdout do
+            subject.add("test")
+            subject.remove("test")
+          end
+          expect(subject.decisions.whitelisted).to be_empty
+        end
+
+        it "removes multiple licenses from the whitelist" do
+          silence_stdout do
+            subject.add("test", "rest")
+            subject.remove("test", "rest")
+          end
+          expect(subject.decisions.whitelisted).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/lib/license_finder/configuration_spec.rb

@@ -2,209 +2,64 @@ require "spec_helper"
 
 module LicenseFinder
   describe Configuration do
-    describe ".ensure_default" do
+    describe ".with_optional_saved_config" do
       it "should init and use saved config" do
-        expect(Configuration::Persistence).to receive(:init)
-        allow(Configuration::Persistence).to receive(:get).and_return('whitelist' => ['Saved License'])
+        fake_project_dir = Pathname.new(__FILE__).dirname.join('..', '..', 'fixtures')
 
-        expect(described_class.ensure_default.whitelist).to eq(['Saved License'])
+        subject = described_class.with_optional_saved_config({}, fake_project_dir)
+        expect(subject.gradle_command).to eq('gradlew')
       end
     end
 
-    describe "#last_modified" do
-      let(:time) { double :time }
-      before do
-        allow(Configuration::Persistence).to receive(:last_modified) { time }
+    describe "gradle_command" do
+      it "prefers primary value" do
+        subject = described_class.new(
+          {gradle_command: "primary"},
+          {"gradle_command" => "secondary"}
+        )
+        expect(subject.gradle_command).to eq "primary"
       end
 
-      it 'returns the last modified date of the config file' do
-        expect(LicenseFinder::Configuration.new({}).last_modified).to eq time
+      it "accepts saved value" do
+        subject = described_class.new(
+          {gradle_command: nil},
+          {"gradle_command" => "secondary"}
+        )
+        expect(subject.gradle_command).to eq "secondary"
       end
-    end
-
-    describe '.new' do
-      it "should default missing attributes" do
-        subject = described_class.new({})
-        expect(subject.whitelist).to eq([])
-        expect(subject.ignore_groups).to eq([])
-        expect(subject.ignore_dependencies).to eq([])
-        expect(subject.artifacts.dir).to eq(Pathname('./doc/'))
-        expect(subject.gradle_command).to eq('gradle')
-      end
-
-      it "should default missing attributes even if they are saved as nils in the YAML file" do
-        attributes = {
-          "whitelist" => nil,
-          "ignore_groups" => nil,
-          "ignore_dependencies" => nil,
-          "dependencies_file_dir" => nil,
-          "project_name" => nil,
-          "gradle_command" => nil
-        }
-        subject = described_class.new(attributes)
-        expect(subject.whitelist).to eq([])
-        expect(subject.ignore_groups).to eq([])
-        expect(subject.ignore_dependencies).to eq([])
-        expect(subject.artifacts.dir).to eq(Pathname('./doc/'))
-        expect(subject.project_name).not_to be_nil
-        expect(subject.gradle_command).to eq('gradle')
-      end
-
-      it "should set the all of the attributes on the instance" do
-        attributes = {
-          "whitelist" => %w{a whitelist},
-          "ignore_groups" => %w{test development},
-          "ignore_dependencies" => %w{bundler},
-          "dependencies_file_dir" => "some/path",
-          "project_name" => "my_app",
-          "gradle_command" => "./gradlew"
-        }
-        subject = described_class.new(attributes)
-        expect(subject.whitelist).to eq(%w{a whitelist})
-        expect(subject.ignore_groups).to eq(%w{test development})
-        expect(subject.ignore_dependencies).to eq(%w{bundler})
-        expect(subject.artifacts.dir).to eq(Pathname("some/path"))
-        expect(subject.project_name).to eq("my_app")
-        expect(subject.gradle_command).to eq("./gradlew")
-      end
-    end
-
-    describe "file paths" do
-      it "should be relative to artifacts dir" do
-        artifacts = described_class.new('dependencies_file_dir' => './elsewhere').artifacts
-        expect(artifacts.dir).to eq(Pathname('./elsewhere'))
-        expect(artifacts.legacy_yaml_file).to eq(Pathname('./elsewhere/dependencies.yml'))
-        expect(artifacts.text_file).to eq(Pathname('./elsewhere/dependencies.csv'))
-        expect(artifacts.html_file).to eq(Pathname('./elsewhere/dependencies.html'))
-      end
-    end
-
-    describe "#database_uri" do
-      it "should URI escape absolute path to dependencies_file_dir, even with spaces" do
-        artifacts = described_class.new('dependencies_file_dir' => 'test path').artifacts
-        expect(artifacts.database_uri).to match(%r{test%20path/dependencies\.db$})
-      end
-    end
 
-    describe "#project_name" do
-      it "should default to the directory name" do
-        allow(Dir).to receive(:getwd).and_return("/path/to/a_project")
-        expect(described_class.new({}).project_name).to eq("a_project")
+      it "has default" do
+        subject = described_class.new(
+          {gradle_command: nil},
+          {"gradle_command" => nil}
+        )
+        expect(subject.gradle_command).to eq "gradle"
       end
     end
 
-    describe "#save" do
-      def attributes # can't be a let... the caching causes polution
-        {
-          'whitelist' => ['my_gem'],
-          'ignore_groups' => ['other_group', 'test'],
-          'ignore_dependencies' => ['bundler'],
-          'project_name' => "New Project Name",
-          'dependencies_file_dir' => "./deps",
-          'gradle_command' => './gradle'
-        }
-      end
-
-      it "persists the configuration attributes" do
-        expect(Configuration::Persistence).to receive(:set).with(attributes)
-        described_class.new(attributes).save
-      end
-
-      it "doesn't persist duplicate entries" do
-        config = described_class.new(attributes)
-        config.whitelist << 'my_gem'
-        config.ignore_groups << 'test'
-        config.ignore_dependencies << 'bundler'
-
-        expect(Configuration::Persistence).to receive(:set).with(attributes)
-        config.save
-      end
-    end
-  end
-
-  describe Configuration::Artifacts do
-    describe "#last_refreshed" do
-      let(:database_modified_time) { 1 }
-      let(:text_modified_time) { 2 }
-      let(:detailed_text_modified_time) { 3 }
-      let(:html_modified_time) { 4 }
-      let(:markdown_modified_time) { 5 }
-
-      before do
-        allow(File).to receive(:mtime).with('./doc/dependencies.db') { database_modified_time }
-        allow(File).to receive(:mtime).with('./doc/dependencies.csv') { text_modified_time }
-        allow(File).to receive(:mtime).with('./doc/dependencies_detailed.csv') { detailed_text_modified_time }
-        allow(File).to receive(:mtime).with('./doc/dependencies.html') { html_modified_time }
-        allow(File).to receive(:mtime).with('./doc/dependencies.md') { markdown_modified_time }
-      end
-
-      it 'returns the earliest modified date of the config file' do
-        expect(described_class.new(Pathname('./doc')).last_refreshed).to eq database_modified_time
-      end
-    end
-  end
-
-  describe Configuration::Persistence do
-    describe ".get" do
-      it "should use saved configuration" do
-        file = double(:file,
-                      :exist? => true,
-                      :read => {'some' => 'config'}.to_yaml)
-        allow(described_class).to receive(:file).and_return(file)
-
-        expect(described_class.get).to eq({'some' => 'config'})
-      end
-
-      it "should not mind if config is not saved" do
-        file = double(:file, :exist? => false)
-        allow(described_class).to receive(:file).and_return(file)
-
-        expect(file).not_to receive(:read)
-        expect(described_class.get).to eq({})
-      end
-    end
-
-    describe ".set" do
-      let(:tmp_yml) { '.tmp.configuration_spec.yml' }
-
-      after do
-        File.delete(tmp_yml)
-      end
-
-      it "writes the configuration attributes to the yaml file" do
-        allow(described_class).to receive(:file).and_return(Pathname.new(tmp_yml))
-
-        described_class.set('some' => 'config')
-        expect(described_class.get).to eq({'some' => 'config'})
-      end
-    end
-
-    describe ".init" do
-      it "initializes the config file" do
-        file = double(:file, :exist? => false)
-        allow(described_class).to receive(:file).and_return(file)
-
-        expect(FileUtils).to receive(:cp).with(described_class.send(:file_template), file)
-        described_class.init
-      end
-
-      it "does nothing if there is already a config file" do
-        file = double(:file, :exist? => true)
-        allow(described_class).to receive(:file).and_return(file)
-
-        expect(FileUtils).not_to receive(:cp)
-        described_class.init
-      end
-    end
-
-    describe ".last_modified" do
-      let(:time) { double :time }
-      before do
-        allow(File).to receive(:mtime).with('config/license_finder.yml') { time }
-      end
-
-      it "returns the last time the yml file was modified" do
-        expect(described_class.last_modified).to eq time
+    describe "decisions_file" do
+      it "prefers primary value" do
+        subject = described_class.new(
+          {decisions_file: "primary"},
+          {"decisions_file" => "secondary"}
+        )
+        expect(subject.decisions_file.to_s).to eq "primary"
+      end
+
+      it "accepts saved value" do
+        subject = described_class.new(
+          {decisions_file: nil},
+          {"decisions_file" => "secondary"}
+        )
+        expect(subject.decisions_file.to_s).to eq "secondary"
+      end
+
+      it "has default" do
+        subject = described_class.new(
+          {decisions_file: nil},
+          {"decisions_file" => nil}
+        )
+        expect(subject.decisions_file.to_s).to eq "doc/dependency_decisions.yml"
       end
     end
   end

data/spec/lib/license_finder/decision_applier_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module LicenseFinder
+  describe DecisionApplier do
+    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 "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
+    end
+  end
+end

data/spec/lib/license_finder/decisions_spec.rb

@@ -0,0 +1,347 @@
+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 ".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 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
+    end
+  end
+end