license_finder 1.1.1 → 1.2

data/spec/lib/license_finder/license_spec.rb

@@ -4,7 +4,7 @@ module LicenseFinder
   describe License do
     describe ".find_by_name" do
       it "should find a registered license" do
-        License.find_by_name("Apache2").should be_a License
+        expect(License.find_by_name("Apache2")).to be_a License
       end
 
       it "should make an unrecognized license" do
@@ -16,20 +16,20 @@ module LicenseFinder
 
       context "making the default license" do
         it "set the name to 'other'" do
-          License.find_by_name(nil).name.should == "other"
+          expect(License.find_by_name(nil).name).to eq("other")
         end
 
         it "does not equal other uses of the default license" do
-          License.find_by_name(nil).should_not == License.find_by_name(nil)
+          expect(License.find_by_name(nil)).not_to eq(License.find_by_name(nil))
         end
 
         context "when there is a whitelist" do
           before do
-            LicenseFinder.config.stub(:whitelist).and_return(["not empty"])
+            allow(LicenseFinder.config).to receive(:whitelist).and_return(["not empty"])
           end
 
           it "does not blow up" do
-            License.find_by_name(nil).name.should == "other"
+            expect(License.find_by_name(nil).name).to eq("other")
           end
         end
       end
@@ -37,7 +37,7 @@ module LicenseFinder
 
     describe ".find_by_text" do
       it "should find a registered license" do
-        License.find_by_text('This gem is released under the MIT license').should be_a License
+        expect(License.find_by_text('This gem is released under the MIT license')).to be_a License
       end
 
       it "returns nil if not found" do
@@ -60,51 +60,51 @@ module LicenseFinder
 
     describe "#whitelisted?" do
       it "is true if the settings say it is" do
-        make_license.should_not be_whitelisted
-        make_license(whitelisted: true).should be_whitelisted
+        expect(make_license).not_to be_whitelisted
+        expect(make_license(whitelisted: true)).to be_whitelisted
       end
 
       it "can be made true (without mutating original)" do
         original = make_license
         license = original.whitelist
-        license.should_not == original
-        license.should be_whitelisted
-        license.url.should == "http://example.com/license"
-        license.should be_matches_name "Default Short Name"
-        license.should be_matches_text "Default Matcher"
+        expect(license).not_to eq(original)
+        expect(license).to be_whitelisted
+        expect(license.url).to eq("http://example.com/license")
+        expect(license).to be_matches_name "Default Short Name"
+        expect(license).to be_matches_text "Default Matcher"
       end
     end
 
     describe "#matches_name?" do
       it "should match on short_name" do
-        make_license(short_name: "Foo").should be_matches_name "Foo"
+        expect(make_license(short_name: "Foo")).to be_matches_name "Foo"
       end
 
       it "should match on pretty name" do
-        make_license(pretty_name: "Foo").should be_matches_name "Foo"
+        expect(make_license(pretty_name: "Foo")).to be_matches_name "Foo"
       end
 
       it "should match on alternative names" do
         license = make_license(other_names: ["Foo", "Bar"])
-        license.should be_matches_name "Foo"
-        license.should be_matches_name "Bar"
+        expect(license).to be_matches_name "Foo"
+        expect(license).to be_matches_name "Bar"
       end
 
       it "should ignore case" do
-        make_license(pretty_name: "Foo").should be_matches_name "foo"
-        make_license(pretty_name: "foo").should be_matches_name "Foo"
+        expect(make_license(pretty_name: "Foo")).to be_matches_name "foo"
+        expect(make_license(pretty_name: "foo")).to be_matches_name "Foo"
       end
 
       it "should not fail if pretty_name or other_names are omitted" do
-        make_license.should be_matches_name "Default Short Name"
+        expect(make_license).to be_matches_name "Default Short Name"
       end
     end
 
     describe ".matches_text?" do
       it "should match on text" do
         license = make_license(matcher: License::Matcher.from_regex(/The license text/))
-        license.should be_matches_text "The license text"
-        license.should_not be_matches_text "Some other text"
+        expect(license).to be_matches_text "The license text"
+        expect(license).not_to be_matches_text "Some other text"
       end
 
       it "should match regardless of placeholder names, whitespace, or quotes" do
@@ -114,7 +114,7 @@ module LicenseFinder
         LICENSE
         license = make_license(matcher: License::Matcher.from_text(License::Text.normalize_punctuation(license_text)))
 
-        license.should be_matches_text <<-FILE
+        expect(license).to be_matches_text <<-FILE
           The ''company'' of foo bar *%*%*%*%
           shall not be held "responsible" for `anything`.
         FILE
@@ -123,12 +123,12 @@ module LicenseFinder
       it "should match even if whitespace at beginning and end don't match" do
         template = License::Template.new("\nThe license text")
         license = make_license(matcher: License::Matcher.from_template(template))
-        license.should be_matches_text "The license text\n"
+        expect(license).to be_matches_text "The license text\n"
       end
     end
 
     it "should default pretty_name to short_name" do
-      make_license.name.should == "Default Short Name"
+      expect(make_license.name).to eq("Default Short Name")
     end
   end
 end

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

@@ -16,7 +16,7 @@ module LicenseFinder
       )
     end
 
-    it_behaves_like "it conforms to interface required by PackageSaver"
+    it_behaves_like "a Package"
 
     its(:name) { should == "dependency-library" }
     its(:version) { should == "1.3.3.7" }
@@ -26,9 +26,9 @@ module LicenseFinder
     its(:groups) { should == [] }
     its(:children) { should == [] }
 
-    describe '#license' do
+    describe '#licenses' do
       def stub_license_files(license_files)
-        PossibleLicenseFiles.stub(:find).with("/path/to/thing").and_return(license_files)
+        allow(PossibleLicenseFiles).to receive(:find).with("/path/to/thing").and_return(license_files)
       end
 
       let(:package1) { { "pkgMeta" => {"license" => "MIT"}, "canonicalDir" => "/some/path" } }
@@ -37,52 +37,68 @@ module LicenseFinder
       let(:package4) { { "pkgMeta" => {"licenses" => ["MIT"]}, "canonicalDir" => "/some/path" } }
 
       it 'finds the license for both license  structures' do
-        BowerPackage.new(package1).license.name.should eq("MIT")
-        BowerPackage.new(package2).license.name.should eq("BSD")
-        BowerPackage.new(package3).license.name.should eq("Python Software Foundation License")
-        BowerPackage.new(package4).license.name.should eq("MIT")
+        package = BowerPackage.new(package1)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("MIT")
+
+        package = BowerPackage.new(package2)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("BSD")
+
+        package = BowerPackage.new(package3)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("Python Software Foundation License")
+
+        package = BowerPackage.new(package4)
+        expect(package.licenses.length).to eq 1
+        expect(package.licenses.first.name).to eq("MIT")
       end
 
 
       context "regardless of whether there are licenses in files" do
         before do
-          stub_license_files [double(:file, license: License.find_by_name('Detected License'))]
+          stub_license_files [double(:file, license: License.find_by_name('Detected License'), path: "/")]
         end
 
         it "returns the license from the spec if there is only one unique license" do
           package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "Expat"]}, "canonicalDir" => "/path/to/thing" })
-          expect(package.license.name).to eq("MIT")
+          expect(package.licenses.length).to eq 1
+          expect(package.licenses.first.name).to eq("MIT")
         end
 
         it "returns 'multiple licenses' if there's more than one license" do
           package = BowerPackage.new({ "pkgMeta" => {"licenses" => ["MIT", "BSD"]}, "canonicalDir" => "/some/path" })
-          expect(package.license.name).to eq("multiple licenses: MIT, BSD")
+          expect(package.licenses.length).to eq 2
+          expect(package.licenses.map(&:name)).to eq %w(MIT BSD)
         end
       end
 
       context "when there is nothing in the spec" do
         it "returns a license in a file if only one unique license detected" do
           stub_license_files([
-            double(:first_file, license: License.find_by_name('MIT')),
-            double(:second_file, license: License.find_by_name('Expat'))
+            double(:first_file, license: License.find_by_name('MIT'), path: "/"),
+            double(:second_file, license: License.find_by_name('Expat'), path: "/")
           ])
 
-          subject.license.name.should == "MIT"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "MIT"
         end
 
         it "returns 'other' if there are no licenses in files" do
           stub_license_files []
 
-          subject.license.name.should == "other"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "other"
         end
 
         it "returns 'other' if there are many licenses in files" do
           stub_license_files([
-            double(:first_file, license: License.find_by_name('First Detected License')),
-            double(:second_file, license: License.find_by_name('Second Detected License'))
+            double(:first_file, license: License.find_by_name('First Detected License'), path: "/"),
+            double(:second_file, license: License.find_by_name('Second Detected License'), path: "/")
           ])
 
-          subject.license.name.should == "multiple licenses: First Detected License, Second Detected License"
+          expect(subject.licenses.length).to eq 2
+          expect(subject.licenses.map(&:name)).to eq ["First Detected License", "Second Detected License"]
         end
       end
     end

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

@@ -2,35 +2,38 @@ require 'spec_helper'
 
 module LicenseFinder
   describe Bower do
+    let(:bower) { Bower.new }
+    it_behaves_like "a PackageManager"
+
     describe '.current_packages' do
       it 'lists all the current packages' do
-        json = <<-resp
-{
-  "dependencies": {
-    "dependency-library": {
-      "canonicalDir": "/path/to/thing",
-      "pkgMeta": {
-        "name": "dependency-library",
-        "description": "description",
-        "version": "1.3.3.7",
-        "main": "normalize.css"
-      }
-    },
-    "another-dependency": {
-      "canonicalDir": "/path/to/thing2",
-      "pkgMeta": {
-        "name": "another-dependency",
-        "description": "description2",
-        "version": "4.2",
-        "main": "denormalize.css"
-      }
-    }
-  }
-}
-        resp
-        allow(Bower).to receive(:`).with(/bower/).and_return(json)
+        json = <<-JSON
+          {
+            "dependencies": {
+              "dependency-library": {
+                "canonicalDir": "/path/to/thing",
+                "pkgMeta": {
+                  "name": "dependency-library",
+                  "description": "description",
+                  "version": "1.3.3.7",
+                  "main": "normalize.css"
+                }
+              },
+              "another-dependency": {
+                "canonicalDir": "/path/to/thing2",
+                "pkgMeta": {
+                  "name": "another-dependency",
+                  "description": "description2",
+                  "version": "4.2",
+                  "main": "denormalize.css"
+                }
+              }
+            }
+          }
+        JSON
+        allow(bower).to receive("`").with(/bower/).and_return(json)
 
-        current_packages = Bower.current_packages
+        current_packages = bower.current_packages
 
         expect(current_packages.size).to eq(2)
         expect(current_packages.first).to be_a(Package)
@@ -38,20 +41,17 @@ module LicenseFinder
     end
 
     describe '.active?' do
-      let(:package) { double(:package_file) }
-
-      before do
-        Bower.stub(package_path: package)
-      end
+      let(:package_path) { double(:package_file) }
+      let(:bower) { Bower.new package_path: package_path }
 
       it 'is true with a bower.json file' do
-        package.stub(:exist? => true)
-        expect(Bower).to be_active
+        allow(package_path).to receive_messages(:exist? => true)
+        expect(bower).to be_active
       end
 
       it 'is false without a bower.json file' do
-        package.stub(:exist? => false)
-        expect(Bower).to_not be_active
+        allow(package_path).to receive_messages(:exist? => false)
+        expect(bower).to_not be_active
       end
     end
   end

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

@@ -4,7 +4,7 @@ module LicenseFinder
   describe BundlerPackage do
     subject { described_class.new(gemspec, nil) }
 
-    it_behaves_like "it conforms to interface required by PackageSaver"
+    it_behaves_like "a Package"
 
     let(:gemspec) do
       Gem::Specification.new do |s|
@@ -24,23 +24,24 @@ module LicenseFinder
     its(:description) { should == "description" }
     its(:homepage) { should == "homepage" }
     its(:groups) { should == [] }
-    its(:children) { should == [] }
+    its(:children) { should == ['foo'] }
 
-    describe "#license" do
+    describe "#licenses" do
       def stub_license_files(license_files)
-        PossibleLicenseFiles.stub(:find).and_return(license_files)
+        allow(PossibleLicenseFiles).to receive(:find).and_return(license_files)
       end
 
       context "regardless of whether there are licenses in files" do
         before do
-          stub_license_files [double(:file, license: License.find_by_name('Detected License'))]
+          stub_license_files [double(:file, license: License.find_by_name('Detected License'), path: "/")]
         end
 
         context 'if the gemspec provides two synonymous licenses' do
           before { gemspec.licenses = ['MIT', 'Expat'] }
 
           it 'returns the license only once' do
-            subject.license.name.should == "MIT"
+            expect(subject.licenses.length).to eq 1
+            expect(subject.licenses.first.name).to eq "MIT"
           end
         end
 
@@ -48,7 +49,8 @@ module LicenseFinder
           before { gemspec.licenses = ['First Gemspec License', 'Second Gemspec License'] }
 
           it "returns 'multiple licenses' with the names of the licenses from the gemspec (but not those from detected files)" do
-            subject.license.name.should == "multiple licenses: First Gemspec License, Second Gemspec License"
+            expect(subject.licenses.length).to eq 2
+            expect(subject.licenses.map(&:name)).to eq ["First Gemspec License", "Second Gemspec License"]
           end
         end
       end
@@ -56,26 +58,29 @@ module LicenseFinder
       context "when there is nothing in the spec" do
         it "returns a license in a file if there is only one unique license detected" do
           stub_license_files([
-            double(:first_file, license: License.find_by_name('MIT')),
-            double(:second_file, license: License.find_by_name('Expat'))
+            double(:first_file, license: License.find_by_name('MIT'), path: "/"),
+            double(:second_file, license: License.find_by_name('Expat'), path: "/")
           ])
 
-          subject.license.name.should == "MIT"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "MIT"
         end
 
         it "returns 'other' if there are no licenses in files" do
           stub_license_files []
 
-          subject.license.name.should == "other"
+          expect(subject.licenses.length).to eq 1
+          expect(subject.licenses.first.name).to eq "other"
         end
 
         it "returns 'multiple licenses' if there are many licenses in files" do
           stub_license_files([
-            double(:first_file, license: License.find_by_name('First Detected License')),
-            double(:second_file, license: License.find_by_name('Second Detected License'))
+            double(:first_file, license: License.find_by_name('First Detected License'), path: "/"),
+            double(:second_file, license: License.find_by_name('Second Detected License'), path: "/")
           ])
 
-          subject.license.name.should == "multiple licenses: First Detected License, Second Detected License"
+          expect(subject.licenses.length).to eq 2
+          expect(subject.licenses.map(&:name)).to eq ["First Detected License", "Second Detected License"]
         end
       end
     end
@@ -86,7 +91,7 @@ module LicenseFinder
       let(:bundler_dependency) { double(:dependency, groups: [1, 2, 3]) }
 
       it "returns bundler dependency's groups" do
-        subject.groups.should == bundler_dependency.groups
+        expect(subject.groups).to eq(bundler_dependency.groups)
       end
     end
   end

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

@@ -2,6 +2,8 @@ require "spec_helper"
 
 module LicenseFinder
   describe Bundler do
+    it_behaves_like "a PackageManager"
+
     let(:definition) do
       double('definition', {
         :dependencies => [],
@@ -28,16 +30,16 @@ module LicenseFinder
 
     describe '.current_packages' do
       subject do
-        Bundler.current_packages(['dev', 'test'], definition)
+        Bundler.new(ignore_groups: ['dev', 'test'], definition: definition).current_packages
       end
 
       it "should have 2 dependencies" do
-        subject.size.should == 2
+        expect(subject.size).to eq(2)
       end
 
       context "when initialized with a parent and child gem" do
         before do
-          definition.stub(:specs_for).with([:production]).and_return([
+          allow(definition).to receive(:specs_for).with([:production]).and_return([
             build_gemspec('gem1', '1.2.3', 'gem2'),
             build_gemspec('gem2', '0.4.2', 'gem3')
           ])
@@ -46,32 +48,23 @@ module LicenseFinder
         it "should update the child dependency with its parent data" do
           gem1 = subject.first
 
-          gem1.children.should == ["gem2"]
-        end
-
-        it "should only include the children which are project dependencies" do
-          gem2 = subject[1]
-
-          gem2.children.should == []
+          expect(gem1.children).to eq(["gem2"])
         end
       end
     end
 
     describe '.active?' do
-      let(:gemfile) { double(:gemfile_file) }
-
-      before do
-        Bundler.stub(gemfile_path: gemfile)
-      end
+      let(:package_path) { double(:gemfile_file) }
+      let(:bundler) { Bundler.new package_path: package_path }
 
       it 'is true with a Gemfile file' do
-        gemfile.stub(:exist? => true)
-        expect(Bundler).to be_active
+        allow(package_path).to receive_messages(:exist? => true)
+        expect(bundler).to be_active
       end
 
       it 'is false without a Gemfile file' do
-        gemfile.stub(:exist? => false)
-        expect(Bundler).to_not be_active
+        allow(package_path).to receive_messages(:exist? => false)
+        expect(bundler).to_not be_active
       end
     end
   end