license_finder 1.1.1 → 1.2

data/spec/lib/license_finder/configuration_spec.rb

@@ -4,10 +4,10 @@ module LicenseFinder
   describe Configuration do
     describe ".ensure_default" do
       it "should init and use saved config" do
-        Configuration::Persistence.should_receive(:init)
-        Configuration::Persistence.stub(:get).and_return('whitelist' => ['Saved License'])
+        expect(Configuration::Persistence).to receive(:init)
+        allow(Configuration::Persistence).to receive(:get).and_return('whitelist' => ['Saved License'])
 
-        described_class.ensure_default.whitelist.should == ['Saved License']
+        expect(described_class.ensure_default.whitelist).to eq(['Saved License'])
       end
     end
 
@@ -25,11 +25,11 @@ module LicenseFinder
     describe '.new' do
       it "should default missing attributes" do
         subject = described_class.new({})
-        subject.whitelist.should == []
-        subject.ignore_groups.should == []
-        subject.ignore_dependencies.should == []
-        subject.artifacts.dir.should == Pathname('./doc/')
-        subject.gradle_command.should == 'gradle'
+        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
@@ -42,12 +42,12 @@ module LicenseFinder
           "gradle_command" => nil
         }
         subject = described_class.new(attributes)
-        subject.whitelist.should == []
-        subject.ignore_groups.should == []
-        subject.ignore_dependencies.should == []
-        subject.artifacts.dir.should == Pathname('./doc/')
-        subject.project_name.should_not be_nil
-        subject.gradle_command.should == 'gradle'
+        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
@@ -60,36 +60,36 @@ module LicenseFinder
           "gradle_command" => "./gradlew"
         }
         subject = described_class.new(attributes)
-        subject.whitelist.should == %w{a whitelist}
-        subject.ignore_groups.should == %w{test development}
-        subject.ignore_dependencies.should == %w{bundler}
-        subject.artifacts.dir.should == Pathname("some/path")
-        subject.project_name.should == "my_app"
-        subject.gradle_command.should == "./gradlew"
+        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
-        artifacts.dir.should == Pathname('./elsewhere')
-        artifacts.legacy_yaml_file.should == Pathname('./elsewhere/dependencies.yml')
-        artifacts.text_file.should == Pathname('./elsewhere/dependencies.csv')
-        artifacts.html_file.should == Pathname('./elsewhere/dependencies.html')
+        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
-        artifacts.database_uri.should =~ %r{test%20path/dependencies\.db$}
+        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
-        Dir.stub(:getwd).and_return("/path/to/a_project")
-        described_class.new({}).project_name.should == "a_project"
+        allow(Dir).to receive(:getwd).and_return("/path/to/a_project")
+        expect(described_class.new({}).project_name).to eq("a_project")
       end
     end
 
@@ -106,7 +106,7 @@ module LicenseFinder
       end
 
       it "persists the configuration attributes" do
-        Configuration::Persistence.should_receive(:set).with(attributes)
+        expect(Configuration::Persistence).to receive(:set).with(attributes)
         described_class.new(attributes).save
       end
 
@@ -116,7 +116,7 @@ module LicenseFinder
         config.ignore_groups << 'test'
         config.ignore_dependencies << 'bundler'
 
-        Configuration::Persistence.should_receive(:set).with(attributes)
+        expect(Configuration::Persistence).to receive(:set).with(attributes)
         config.save
       end
     end
@@ -131,11 +131,11 @@ module LicenseFinder
       let(:markdown_modified_time) { 5 }
 
       before do
-        allow(File).to receive(:mtime).with(Pathname('./doc/dependencies.db')) { database_modified_time }
-        allow(File).to receive(:mtime).with(Pathname('./doc/dependencies.csv')) { text_modified_time }
-        allow(File).to receive(:mtime).with(Pathname('./doc/dependencies_detailed.csv')) { detailed_text_modified_time }
-        allow(File).to receive(:mtime).with(Pathname('./doc/dependencies.html')) { html_modified_time }
-        allow(File).to receive(:mtime).with(Pathname('./doc/dependencies.md')) { markdown_modified_time }
+        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
@@ -150,17 +150,17 @@ module LicenseFinder
         file = double(:file,
                       :exist? => true,
                       :read => {'some' => 'config'}.to_yaml)
-        described_class.stub(:file).and_return(file)
+        allow(described_class).to receive(:file).and_return(file)
 
-        described_class.get.should == {'some' => 'config'}
+        expect(described_class.get).to eq({'some' => 'config'})
       end
 
       it "should not mind if config is not saved" do
         file = double(:file, :exist? => false)
-        described_class.stub(:file).and_return(file)
+        allow(described_class).to receive(:file).and_return(file)
 
-        file.should_not_receive(:read)
-        described_class.get.should == {}
+        expect(file).not_to receive(:read)
+        expect(described_class.get).to eq({})
       end
     end
 
@@ -172,36 +172,35 @@ module LicenseFinder
       end
 
       it "writes the configuration attributes to the yaml file" do
-        described_class.stub(:file).and_return(Pathname.new(tmp_yml))
+        allow(described_class).to receive(:file).and_return(Pathname.new(tmp_yml))
 
         described_class.set('some' => 'config')
-        described_class.get.should == {'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)
-        described_class.stub(:file).and_return(file)
+        allow(described_class).to receive(:file).and_return(file)
 
-        FileUtils.should_receive(:cp).with(described_class.send(:file_template), 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)
-        described_class.stub(:file).and_return(file)
+        allow(described_class).to receive(:file).and_return(file)
 
-        FileUtils.should_not_receive(:cp)
+        expect(FileUtils).not_to receive(:cp)
         described_class.init
       end
     end
 
     describe ".last_modified" do
       let(:time) { double :time }
-      let(:config_path) { Pathname.new('.').join('config').join('license_finder.yml') }
       before do
-        allow(File).to receive(:mtime).with(config_path) { time }
+        allow(File).to receive(:mtime).with('config/license_finder.yml') { time }
       end
 
       it "returns the last time the yml file was modified" do

data/spec/lib/license_finder/dependency_manager_spec.rb

@@ -3,15 +3,19 @@ require 'spec_helper'
 module LicenseFinder
   describe DependencyManager do
     let(:config) { Configuration.new('whitelist' => ['MIT', 'other']) }
+    let(:dependency_manager) { DependencyManager.new }
 
     before do
-      LicenseFinder.stub(:config).and_return config
-      Reporter.stub(:write_reports)
+      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")
@@ -21,46 +25,46 @@ module LicenseFinder
         Dependency.create(name: "old dependency 2")
 
         current_packages = [gem1, gem2]
-        Bundler.stub(:current_packages) { current_packages }
-        PackageSaver.should_receive(:save_all).with(current_packages).and_return([cur1, cur2])
+        allow(bundler).to receive(:current_packages) { current_packages }
+        expect(PackageSaver).to receive(:save_all).with(current_packages).and_return([cur1, cur2])
 
-        described_class.sync_with_package_managers
-        Dependency.all.map(&:name).should =~ [cur1, cur2, man1].map(&:name)
+        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
-          described_class.manually_add("MIT", "js_dep", "0.0.0")
+          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
-        described_class.manually_add("MIT", "js_dep", "0.0.0")
-          .should be_added_manually
+        expect(dependency_manager.manually_add("MIT", "js_dep", "0.0.0"))
+          .to be_added_manually
       end
 
       it "should set the appropriate values" do
-        dep = described_class.manually_add("GPL", "js_dep", "0.0.0")
-        dep.name.should == "js_dep"
-        dep.version.should == "0.0.0"
-        dep.license.name.should == "GPL"
-        dep.should_not be_approved
+        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 { described_class.manually_add("GPL", "current dependency 1", "0.0.0") }
+        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
-        described_class.manually_add("GPL", "a manually managed dep", nil)
+        dependency_manager.manually_add("GPL", "a manually managed dep", nil)
         expect do
-          described_class.manually_remove("a manually managed dep")
+          dependency_manager.manually_remove("a manually managed dep")
         end.to change(Dependency, :count).by(-1)
       end
 
@@ -68,7 +72,7 @@ module LicenseFinder
         Dependency.create(name: "a bundler dep")
         expect do
           expect do
-            described_class.manually_remove("a bundler dep")
+            dependency_manager.manually_remove("a bundler dep")
           end.to raise_error(Error)
         end.to_not change(Dependency, :count)
       end
@@ -77,23 +81,23 @@ module LicenseFinder
     describe ".approve!" do
       it "approves the dependency" do
         dep = Dependency.named("current dependency")
-        dep.license = License.find_by_name('not approved')
+        dep.licenses = [License.find_by_name('not approved')].to_set
         dep.save
-        dep.reload.should_not be_approved
-        described_class.approve!("current dependency")
-        dep.reload.should be_approved
+        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")
-        described_class.approve!("current dependency", "Julian", "We really need this")
+        dependency_manager.approve!("current dependency", "Julian", "We really need this")
         approval = dep.reload.manual_approval
-        approval.approver.should eq "Julian"
-        approval.notes.should eq "We really need this"
+        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 { described_class.approve!("non-existent dependency") }
+        expect { dependency_manager.approve!("non-existent dependency") }
           .to raise_error(Error)
       end
     end
@@ -102,13 +106,13 @@ module LicenseFinder
       let(:dependency) { double(:dependency) }
 
       it "adds a license for the dependency" do
-        DependencyManager.stub(:find_by_name).with("dependency").and_return(dependency)
-        dependency.should_receive(:set_license_manually!).with(License.find_by_name "MIT")
-        described_class.license!("dependency", "MIT")
+        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 { described_class.license!("non-existent dependency", "a license") }
+        expect { dependency_manager.license!("non-existent dependency", "a license") }
           .to raise_error(Error)
       end
     end
@@ -119,53 +123,53 @@ module LicenseFinder
 
       context "when the database doesn't exist" do
         before do
-          config.artifacts.stub(:database_file).and_return(file_does_not_exist)
+          allow(config.artifacts).to receive(:database_file).and_return(file_does_not_exist)
         end
 
         it "writes reports" do
-          Reporter.should_receive(:write_reports)
-          DependencyManager.modifying {}
+          expect(Reporter).to receive(:write_reports)
+          dependency_manager.modifying {}
         end
       end
 
       context "when the database exists" do
         before do
-          config.artifacts.stub(:database_file).and_return(file_exists)
+          allow(config.artifacts).to receive(:database_file).and_return(file_exists)
         end
 
         context "when the database has changed" do
           before do
             i = 0
-            Digest::SHA2.stub_chain(:file, :hexdigest) { i += 1 }
+            allow(Digest::SHA2).to receive_message_chain(:file, :hexdigest) { i += 1 }
           end
 
           it "writes reports" do
-            Reporter.should_receive(:write_reports)
-            DependencyManager.modifying {}
+            expect(Reporter).to receive(:write_reports)
+            dependency_manager.modifying {}
           end
         end
 
         context "when the database has not changed" do
           before do
-            Digest::SHA2.stub_chain(:file, :hexdigest) { 5 }
+            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
-              config.artifacts.stub(:html_file).and_return(file_does_not_exist)
+              allow(config.artifacts).to receive(:html_file).and_return(file_does_not_exist)
             end
 
             it "writes reports" do
-              Reporter.should_receive(:write_reports)
-              DependencyManager.modifying {}
+              expect(Reporter).to receive(:write_reports)
+              dependency_manager.modifying {}
             end
           end
 
           context "and the reports exist" do
             before do
-              config.artifacts.stub(:html_file).and_return(file_exists)
+              allow(config.artifacts).to receive(:html_file).and_return(file_exists)
             end
 
             context "and configs are newer than the reports" do
@@ -173,7 +177,7 @@ module LicenseFinder
               let(:artifacts_last_update) { 1 }
               it "writes reports" do
                 expect(Reporter).to receive(:write_reports)
-                DependencyManager.modifying {}
+                dependency_manager.modifying {}
               end
             end
 
@@ -183,7 +187,7 @@ module LicenseFinder
 
               it "does not write reports" do
                 expect(Reporter).not_to receive(:write_reports)
-                DependencyManager.modifying {}
+                dependency_manager.modifying {}
               end
             end
           end

data/spec/lib/license_finder/license/definitions_spec.rb

@@ -3,46 +3,46 @@ require 'spec_helper'
 describe LicenseFinder::License::Definitions do
   it "should create unrecognized licenses" do
     license = described_class.build_unrecognized("foo", [])
-    license.name.should == "foo"
-    license.url.should be_nil
-    license.should be_matches_name("foo")
-    license.should_not be_matches_text("foo")
-    license.should_not be_whitelisted
+    expect(license.name).to eq("foo")
+    expect(license.url).to be_nil
+    expect(license).to be_matches_name("foo")
+    expect(license).not_to be_matches_text("foo")
+    expect(license).not_to be_whitelisted
   end
 
   it "should whitelist unrecognized licenses" do
     license = described_class.build_unrecognized("foo", ["foo"])
-    license.should be_whitelisted
+    expect(license).to be_whitelisted
   end
 end
 
 describe LicenseFinder::License, "Apache2" do
   it "should be recognized" do |e|
-    described_class.find_by_name("Apache2").url.should be
+    expect(described_class.find_by_name("Apache2").url).to be
   end
 end
 
 describe LicenseFinder::License, "BSD" do
   it "should be recognized" do |e|
-    described_class.find_by_name("BSD").url.should be
+    expect(described_class.find_by_name("BSD").url).to be
   end
 end
 
 describe LicenseFinder::License, "GPLv2" do
   it "should be recognized" do
-    described_class.find_by_name("GPLv2").url.should be
+    expect(described_class.find_by_name("GPLv2").url).to be
   end
 end
 
 describe LicenseFinder::License, "ISC" do
   it "should be recognized" do
-    described_class.find_by_name("ISC").url.should be
+    expect(described_class.find_by_name("ISC").url).to be
   end
 end
 
 describe LicenseFinder::License, "LGPL" do
   it "should be recognized" do
-    described_class.find_by_name("LGPL").url.should be
+    expect(described_class.find_by_name("LGPL").url).to be
   end
 end
 
@@ -51,25 +51,25 @@ describe LicenseFinder::License, "MIT" do
 
   describe "#matches_text?" do
     it "should return true if the text contains the MIT url" do
-      subject.should be_matches_text "MIT License is awesome http://opensource.org/licenses/mit-license"
+      expect(subject).to be_matches_text "MIT License is awesome http://opensource.org/licenses/mit-license"
 
-      subject.should be_matches_text "MIT Licence is awesome http://www.opensource.org/licenses/mit-license"
+      expect(subject).to be_matches_text "MIT Licence is awesome http://www.opensource.org/licenses/mit-license"
 
-      subject.should_not be_matches_text "MIT Licence is awesome http://www!opensource!org/licenses/mit-license"
+      expect(subject).not_to be_matches_text "MIT Licence is awesome http://www!opensource!org/licenses/mit-license"
     end
 
     it "should return true if the text begins with 'The MIT License'" do
-      subject.should be_matches_text "The MIT License"
+      expect(subject).to be_matches_text "The MIT License"
 
-      subject.should be_matches_text "The MIT Licence"
+      expect(subject).to be_matches_text "The MIT Licence"
 
-      subject.should_not be_matches_text "Something else\nThe MIT License"
+      expect(subject).not_to be_matches_text "Something else\nThe MIT License"
     end
 
     it "should return true if the text contains 'is released under the MIT license'" do
-      subject.should be_matches_text "is released under the MIT license"
+      expect(subject).to be_matches_text "is released under the MIT license"
 
-      subject.should be_matches_text "is released under the MIT licence"
+      expect(subject).to be_matches_text "is released under the MIT licence"
     end
   end
 end
@@ -102,7 +102,7 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     LICENSE
 
-    subject.should be_matches_text license
+    expect(subject).to be_matches_text license
   end
 
   it "should match with the alternate wording of third clause" do
@@ -130,13 +130,13 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     LICENSE
 
-    subject.should be_matches_text license
+    expect(subject).to be_matches_text license
   end
 end
 
 describe LicenseFinder::License, "Python" do
   it "should be recognized" do
-    described_class.find_by_name("Python").url.should be
+    expect(described_class.find_by_name("Python").url).to be
   end
 end
 
@@ -145,21 +145,21 @@ describe LicenseFinder::License, "Ruby" do
 
   describe "#matches?" do
     it "should return true when the Ruby license URL is present" do
-      subject.should be_matches_text "This gem is available under the following license:\nhttp://www.ruby-lang.org/en/LICENSE.txt\nOkay?"
+      expect(subject).to be_matches_text "This gem is available under the following license:\nhttp://www.ruby-lang.org/en/LICENSE.txt\nOkay?"
     end
 
     it "should return false when the Ruby License URL is not present" do
-      subject.should_not be_matches_text "This gem is available under the following license:\nhttp://www.example.com\nOkay?"
+      expect(subject).not_to be_matches_text "This gem is available under the following license:\nhttp://www.example.com\nOkay?"
     end
 
     it "should return false for pathological licenses" do
-      subject.should_not be_matches_text "This gem is available under the following license:\nhttp://wwwzruby-langzorg/en/LICENSEztxt\nOkay?"
+      expect(subject).not_to be_matches_text "This gem is available under the following license:\nhttp://wwwzruby-langzorg/en/LICENSEztxt\nOkay?"
     end
   end
 end
 
 describe LicenseFinder::License, "SimplifiedBSD" do
   it "should be recognized" do
-    described_class.find_by_name("SimplifiedBSD").url.should be
+    expect(described_class.find_by_name("SimplifiedBSD").url).to be
   end
 end