license_finder 1.2 → 2.0.0.rc2

data/spec/lib/license_finder/dependency_manager_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe DependencyManager do
-    let(:config) { Configuration.new('whitelist' => ['MIT', 'other']) }
-    let(:dependency_manager) { DependencyManager.new }
-
-    before do
-      allow(LicenseFinder).to receive(:config).and_return config
-      allow(Reporter).to receive(:write_reports)
-    end
-
-    describe "#sync" do
-      let(:gem1) { double(:package) }
-      let(:gem2) { double(:package) }
-      let!(:bundler) { Bundler.new }
-
-      before { allow(Bundler).to receive(:new) { bundler } }
-
-      it "destroys every dependency except for the ones Bundler reports as 'current' or are marked as 'added_manually'" do
-        cur1 = Dependency.create(name: "current dependency 1")
-        cur2 = Dependency.create(name: "current dependency 2")
-        man1 = Dependency.create(name: "manual dependency", added_manually: true)
-        Dependency.create(name: "old dependency 1")
-        Dependency.create(name: "old dependency 2")
-
-        current_packages = [gem1, gem2]
-        allow(bundler).to receive(:current_packages) { current_packages }
-        expect(PackageSaver).to receive(:save_all).with(current_packages).and_return([cur1, cur2])
-
-        dependency_manager.sync_with_package_managers
-        expect(Dependency.all.map(&:name)).to match_array([cur1, cur2, man1].map(&:name))
-      end
-    end
-
-    describe ".manually_add" do
-      it "should add a Dependency" do
-        expect do
-          dependency_manager.manually_add("MIT", "js_dep", "0.0.0")
-        end.to change(Dependency, :count).by(1)
-      end
-
-      it "should mark the dependency as manual" do
-        expect(dependency_manager.manually_add("MIT", "js_dep", "0.0.0"))
-          .to be_added_manually
-      end
-
-      it "should set the appropriate values" do
-        dep = dependency_manager.manually_add("GPL", "js_dep", "0.0.0")
-        expect(dep.name).to eq("js_dep")
-        expect(dep.version).to eq("0.0.0")
-        expect(dep.licenses.first.name).to eq("GPL")
-        expect(dep).not_to be_approved
-      end
-
-      it "should complain if the dependency already exists" do
-        Dependency.create(name: "current dependency 1")
-        expect { dependency_manager.manually_add("GPL", "current dependency 1", "0.0.0") }
-          .to raise_error(Error)
-      end
-    end
-
-    describe ".manually_remove" do
-      it "should remove a manually managed Dependency" do
-        dependency_manager.manually_add("GPL", "a manually managed dep", nil)
-        expect do
-          dependency_manager.manually_remove("a manually managed dep")
-        end.to change(Dependency, :count).by(-1)
-      end
-
-      it "should not remove a bundler Dependency" do
-        Dependency.create(name: "a bundler dep")
-        expect do
-          expect do
-            dependency_manager.manually_remove("a bundler dep")
-          end.to raise_error(Error)
-        end.to_not change(Dependency, :count)
-      end
-    end
-
-    describe ".approve!" do
-      it "approves the dependency" do
-        dep = Dependency.named("current dependency")
-        dep.licenses = [License.find_by_name('not approved')].to_set
-        dep.save
-        expect(dep.reload).not_to be_approved
-        dependency_manager.approve!("current dependency")
-        expect(dep.reload).to be_approved
-      end
-
-      it "optionally adds approver and approval notes" do
-        dep = Dependency.named("current dependency")
-        dependency_manager.approve!("current dependency", "Julian", "We really need this")
-        approval = dep.reload.manual_approval
-        expect(approval.approver).to eq "Julian"
-        expect(approval.notes).to eq "We really need this"
-      end
-
-      it "should raise an error if it can't find the dependency" do
-        expect { dependency_manager.approve!("non-existent dependency") }
-          .to raise_error(Error)
-      end
-    end
-
-    describe ".license!" do
-      let(:dependency) { double(:dependency) }
-
-      it "adds a license for the dependency" do
-        allow(dependency_manager).to receive(:find_by_name).with("dependency").and_return(dependency)
-        expect(dependency).to receive(:set_license_manually!).with(License.find_by_name "MIT")
-        dependency_manager.license!("dependency", "MIT")
-      end
-
-      it "should raise an error if it can't find the dependency" do
-        expect { dependency_manager.license!("non-existent dependency", "a license") }
-          .to raise_error(Error)
-      end
-    end
-
-    describe ".modifying" do
-      let(:file_exists) { double(:file, :exist? => true) }
-      let(:file_does_not_exist) { double(:file, :exist? => false) }
-
-      context "when the database doesn't exist" do
-        before do
-          allow(config.artifacts).to receive(:database_file).and_return(file_does_not_exist)
-        end
-
-        it "writes reports" do
-          expect(Reporter).to receive(:write_reports)
-          dependency_manager.modifying {}
-        end
-      end
-
-      context "when the database exists" do
-        before do
-          allow(config.artifacts).to receive(:database_file).and_return(file_exists)
-        end
-
-        context "when the database has changed" do
-          before do
-            i = 0
-            allow(Digest::SHA2).to receive_message_chain(:file, :hexdigest) { i += 1 }
-          end
-
-          it "writes reports" do
-            expect(Reporter).to receive(:write_reports)
-            dependency_manager.modifying {}
-          end
-        end
-
-        context "when the database has not changed" do
-          before do
-            allow(Digest::SHA2).to receive_message_chain(:file, :hexdigest) { 5 }
-            allow(config).to receive(:last_modified) { config_last_update }
-            allow(config.artifacts).to receive(:last_refreshed) { artifacts_last_update }
-          end
-
-          context "and the reports do not exist" do
-            before do
-              allow(config.artifacts).to receive(:html_file).and_return(file_does_not_exist)
-            end
-
-            it "writes reports" do
-              expect(Reporter).to receive(:write_reports)
-              dependency_manager.modifying {}
-            end
-          end
-
-          context "and the reports exist" do
-            before do
-              allow(config.artifacts).to receive(:html_file).and_return(file_exists)
-            end
-
-            context "and configs are newer than the reports" do
-              let(:config_last_update) { 4 }
-              let(:artifacts_last_update) { 1 }
-              it "writes reports" do
-                expect(Reporter).to receive(:write_reports)
-                dependency_manager.modifying {}
-              end
-            end
-
-            context "and configs are older than the reports" do
-              let(:config_last_update) { 4 }
-              let(:artifacts_last_update) { 6 }
-
-              it "does not write reports" do
-                expect(Reporter).not_to receive(:write_reports)
-                dependency_manager.modifying {}
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/license_finder/package_saver_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe PackageSaver do
-    let(:package) do
-      double(
-        :package,
-        licenses: [License.find_by_name('license')].to_set,
-        children: ['child'],
-        groups: [:group],
-        summary: 'summary',
-        description: 'description',
-        name: 'spec_name',
-        version: '1.2.3',
-        homepage: 'http://example.com'
-      )
-    end
-
-    describe ".save_all" do
-      let(:dependency) { double(:dependency).as_null_object }
-
-      it "find and updates relevant dependencies" do
-        expect(Dependency).to receive(:named).with('spec_name').and_return(dependency)
-        expect(dependency).to receive(:save_changes)
-        described_class.save_all([package])
-      end
-    end
-
-    describe "#save" do
-      it "persists changes" do
-        dep = Dependency.create(
-          name: 'spec_name',
-          version: '0.1.2',
-          summary: 'old summary',
-          description: 'old desription',
-          homepage: 'old homepage',
-          license_names: ["old license"].to_json
-        )
-        dep.add_bundler_group BundlerGroup.named("old group")
-        dep.add_child Dependency.named("old child")
-
-        saver = described_class.new(dep, package)
-        subject = saver.save
-
-        expect(subject.id).to be
-        expect(subject.name).to eq("spec_name")
-        expect(subject.version).to eq("1.2.3")
-        expect(subject.summary).to eq("summary")
-        expect(subject.description).to eq("description")
-        expect(subject.homepage).to eq("http://example.com")
-        expect(subject.bundler_groups.map(&:name)).to eq(['group'])
-        expect(subject.children.map(&:name)).to eq(['child'])
-        expect(subject.licenses.first.name).to eq('license')
-      end
-
-      it "keeps approval" do
-        dep = Dependency.create(
-          name: 'spec_name',
-        )
-        dep.approve!
-        saver = described_class.new(dep, package)
-        subject = saver.save
-
-        expect(subject).to be_approved
-      end
-
-      context "to minimize db changes" do
-        it "does not re-save unchanged dependencies" do
-          # See note in PackageSaver#save
-
-          first_run = described_class.find_or_create_by_name(package)
-          expect(first_run.dependency).to receive(:save).and_call_original
-          first_run.save
-
-          second_run = described_class.find_or_create_by_name(package)
-          expect(second_run.dependency).to_not receive(:save)
-          second_run.save
-        end
-      end
-    end
-  end
-end

data/spec/lib/license_finder/reports/detailed_text_report_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-module LicenseFinder
-  describe DetailedTextReport do
-    describe '#to_s' do
-      let(:dep1) do
-        Dependency.new(
-          'name' => 'gem_a',
-          'version' => '1.0',
-          'summary' => 'Summary',
-          'description' => 'Description',
-          'licenses' => [License.find_by_name('MIT')].to_set
-        )
-      end
-
-      let(:dep2) do
-        Dependency.new(
-          'name' => 'gem_b',
-          'version' => '1.0',
-          'summary' => 'Summary',
-          'description' => 'Description',
-          'licenses' => [License.find_by_name('MIT')].to_set
-        )
-      end
-
-      subject { DetailedTextReport.new([dep2, dep1]).to_s }
-
-      it 'should generate a text report with the name, version, license, summary and description of each dependency, sorted by name' do
-        is_expected.to eq("gem_a,1.0,MIT,Summary,Description\ngem_b,1.0,MIT,Summary,Description\n")
-      end
-    end
-  end
-end

data/spec/lib/license_finder/reports/reporter_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Reporter do
-    describe "#write_reports" do
-      subject { Reporter.write_reports }
-
-      before do
-        allow(Dependency).to receive(:acknowledged) { [double(:dep)] }
-
-        allow(MarkdownReport).to receive(:of) { 'markdown report' }
-        allow(DetailedTextReport).to receive(:of) { 'detailed csv report' }
-        allow(TextReport).to receive(:of) { 'csv report' }
-        allow(HtmlReport).to receive(:of) { 'html report' }
-      end
-
-      it "writes an html file" do
-        subject
-        expect(LicenseFinder.config.artifacts.text_file.read).to eq("csv report\n")
-        expect(LicenseFinder.config.artifacts.detailed_text_file.read).to eq("detailed csv report\n")
-        expect(LicenseFinder.config.artifacts.markdown_file.read).to eq("markdown report\n")
-        expect(LicenseFinder.config.artifacts.html_file.read).to eq("html report\n")
-      end
-
-      it "deletes old dependencies.txt file" do
-        fake_file =  double(:fake_file, :exist? => true)
-        allow(LicenseFinder.config.artifacts).to receive(:legacy_text_file) { fake_file }
-        expect(fake_file).to receive(:delete)
-        subject
-      end
-    end
-  end
-end

data/spec/lib/license_finder/tables/dependency_spec.rb

@@ -1,196 +0,0 @@
-require 'spec_helper'
-
-module LicenseFinder
-  describe Dependency do
-    describe '.unapproved' do
-      before do
-        allow(License.find_by_name('MIT')).to receive_messages(:whitelisted? =>  true)
-        allow(LicenseFinder.config).to receive(:ignore_dependencies) { ['this ignored dependency', 'that ignored dependency'] }
-      end
-
-      it "should return all unapproved dependencies that are not ignored" do
-        dependency = Dependency.create(name: "unapproved dependency", version: '0.0.1')
-        approved = Dependency.create(name: "approved dependency", version: '0.0.1')
-        this_ignored = Dependency.create(name: "this ignored dependency", version: '0.0.1')
-        that_ignored = Dependency.create(name: "that ignored dependency", version: '0.0.1')
-        approved.approve!
-        whitelisted = Dependency.create(name: "approved dependency", version: '0.0.1')
-        whitelisted.licenses = [License.find_by_name('MIT')].to_set
-        whitelisted.save
-
-        unapproved = Dependency.unapproved
-        expect(unapproved.count).to eq(1)
-        expect(unapproved).not_to be_any(&:approved?)
-      end
-    end
-
-    describe ".named" do
-      it "creates a new dependency" do
-        dep = described_class.named("never_seen")
-        expect(dep.name).to eq("never_seen")
-        expect(dep).not_to be_new
-      end
-
-      it "returns an existing dependency" do
-        described_class.named("referenced_again")
-        dep = described_class.named("referenced_again")
-        expect(dep.name).to eq("referenced_again")
-        expect(dep).not_to be_new
-        expect(Dependency.count(name: "referenced_again")).to eq(1)
-      end
-    end
-
-    describe ".acknowledged" do
-      it "returns all dependencies that are not ignored" do
-        acknowledged_dependency = Dependency.create(name: "acknowledged dependency", version: '0.0.1')
-        ignored_dependency = Dependency.create(name: "ignored dependency", version: '0.0.1')
-        allow(LicenseFinder.config).to receive(:ignore_dependencies) { [ignored_dependency.name] }
-
-        expect(Dependency.acknowledged).to match_array [acknowledged_dependency]
-      end
-    end
-
-    describe '#approve!' do
-      it "should update the database to show the dependency is approved" do
-        dependency = Dependency.named("foo")
-        dependency.approve!
-        expect(dependency.reload).to be_approved
-      end
-
-      it "should record the approver and notes" do
-        dependency = Dependency.named("foo")
-        dependency.approve!("Julian", "We really need this")
-        approval = dependency.reload.manual_approval
-        expect(approval.approver).to eq "Julian"
-        expect(approval.notes).to eq "We really need this"
-      end
-    end
-
-    describe "#approved?" do
-      let(:not_approved_manually) { Dependency.create(name: 'some gem').reload }
-      let(:approved_manually) { Dependency.create(name: 'some gem').approve!.reload }
-
-      it "is true if its license is whitelisted" do
-        fake_license = double(:license, whitelisted?: true)
-        allow(not_approved_manually).to receive(:licenses).and_return [fake_license].to_set
-        expect(not_approved_manually).to be_approved
-      end
-
-      it "is true if one of its licenses is whitelisted" do
-        fake_licenses = [double(:license, whitelisted?: false), double(:license, whitelisted?: true)].to_set
-        allow(not_approved_manually).to receive(:licenses).and_return fake_licenses
-        expect(not_approved_manually).to be_approved
-      end
-
-      it "is true if it has been approved" do
-        allow(approved_manually).to receive_message_chain(:license, whitelisted?: false)
-        expect(approved_manually).to be_approved
-      end
-
-      it "is false otherwise" do
-        allow(not_approved_manually).to receive_message_chain(:license, whitelisted?: false)
-        expect(not_approved_manually).not_to be_approved
-      end
-    end
-
-    describe "#set_license_manually!" do
-      let(:dependency) { Dependency.create(name: 'foogem') }
-
-      it "sets manual license to true" do
-        expect(dependency).not_to be_license_assigned_manually
-        dependency.set_license_manually! License.find_by_name("Updated")
-        expect(dependency).to be_license_assigned_manually
-      end
-
-      it "modifies the license" do
-        dependency.set_license_manually! License.find_by_name("Updated")
-        expect(dependency.reload.licenses.first.name).to eq('Updated')
-      end
-    end
-
-    describe "#bundler_group_names=" do
-      let(:dependency) { Dependency.named('some gem') }
-
-      it "saves the bundler groups" do
-        dependency.bundler_group_names = %w[1 2 3]
-        expect(dependency.bundler_groups.map(&:name)).to match_array(%w[1 2 3])
-      end
-
-      it "removed outdated groups and adds new groups" do
-        dependency.add_bundler_group BundlerGroup.named('old')
-        dependency.add_bundler_group BundlerGroup.named('maintained')
-        dependency.bundler_group_names = %w[new maintained]
-        expect(dependency.bundler_groups.map(&:name)).to match_array(%w[new maintained])
-      end
-    end
-
-    describe "children_names=" do
-      let(:dependency) { Dependency.named('some gem') }
-
-      it "saves the children" do
-        dependency.children_names = %w[1 2 3]
-        expect(dependency.children.map(&:name)).to match_array(%w[1 2 3])
-      end
-
-      it "removes outdated children and adds new children" do
-        dependency.add_child Dependency.named('old')
-        dependency.add_child Dependency.named('maintained')
-        dependency.children_names = %w[new maintained]
-        expect(dependency.children.map(&:name)).to match_array(%w[new maintained])
-      end
-    end
-
-    describe "#set_licenses" do
-      let(:dependency) { Dependency.named('some gem') }
-
-      it "keeps a manually assigned license" do
-        dependency.set_license_manually! License.find_by_name("manual")
-        dependency.set_licenses [License.find_by_name("new")].to_set
-        expect(dependency.licenses.first.name).to eq "manual"
-      end
-
-      it "saves a new license" do
-        dependency.set_licenses [License.find_by_name("new license")].to_set
-        expect(dependency.licenses.first.name).to eq "new license"
-      end
-
-      it "updates the license's name" do
-        dependency.licenses = [License.find_by_name("old")].to_set
-
-        dependency.set_licenses [License.find_by_name("new license")].to_set
-        expect(dependency.licenses.first.name).to eq "new license"
-      end
-
-      it "won't update the database if the license isn't changing" do
-        # See note in PackageSaver#save
-        dependency.licenses = [License.find_by_name("same")].to_set
-        expect(dependency).to be_modified
-        dependency.save
-        expect(dependency).not_to be_modified
-
-        dependency.set_licenses [License.find_by_name("same")].to_set
-        expect(dependency).not_to be_modified
-      end
-
-      it "updates the database if an additional license is added" do
-        # See note in PackageSaver#save
-        dependency.licenses = [License.find_by_name("first")].to_set
-        expect(dependency).to be_modified
-        dependency.save
-        expect(dependency).not_to be_modified
-
-        dependency.set_licenses [License.find_by_name("first"), License.find_by_name("second")].to_set
-        expect(dependency).to be_modified
-      end
-
-      it "does not change the approval" do
-        dependency.licenses = [License.find_by_name("old")].to_set
-        dependency.approve!
-
-        dependency.set_licenses [License.find_by_name("new license")].to_set
-        expect(dependency).to be_approved
-      end
-    end
-  end
-end
-