gem_spec.rb in polisher-0.10.1

- old
+ new

@@ -7,110 +7,210 @@
 
 require 'polisher/gem'
 
 module Polisher
   describe Gem do
+    describe "#file_name" do
+      it "returns name-version.gem" do
+        expected = 'rails-4.0.0.gem'
+        Polisher::Gem.new(:name => 'rails', :version => '4.0.0')
+                     .file_name.should == expected
+      end
+    end
+
     describe "#initialize" do
       it "sets gem attributes" do
-        gem = Polisher::Gem.new :name => 'rails',
-                                :version => '4.0.0',
-                                :deps => ['activesupport', 'activerecord'],
-                                :dev_deps => ['rake']
+        gem = described_class.new :name     => 'rails',
+                                  :version  => '4.0.0',
+                                  :deps     => %w(activesupport activerecord),
+                                  :dev_deps => ['rake']
         gem.name.should == 'rails'
         gem.version.should == '4.0.0'
         gem.deps.should == ['activesupport', 'activerecord']
         gem.dev_deps.should == ['rake']
       end
     end
 
     describe "#ignorable_file?" do
       context "args matches an ignorable file" do
         it "returns true" do
-          Polisher::Gem.ignorable_file?('foo.gemspec').should be_true
-          Polisher::Gem.ignorable_file?('Gemfile').should be_true
+          described_class.ignorable_file?('foo.gemspec').should be_true
+          described_class.ignorable_file?('Gemfile').should be_true
         end
       end
 
       context "args does not match an ignorable file" do
         it "returns false" do
-          Polisher::Gem.ignorable_file?('.rvmra').should be_false
-          Polisher::Gem.ignorable_file?('foo.gemspoc').should be_false
+          described_class.ignorable_file?('.rvmra').should be_false
+          described_class.ignorable_file?('foo.gemspoc').should be_false
         end
       end
     end
 
+    describe "#doc_file?" do
+      context "file is on doc file list" do
+        it "returns true" do
+          described_class.doc_file?('CHANGELOG').should be_true
+        end
+      end
+
+      context "file is not on doc file list" do
+        it "returns false" do
+          described_class.doc_file?('foobar.rb').should be_false
+        end
+      end
+    end
+
     describe "#local_versions_for" do
-      it "returns versions of specified gem in local db"
-      it "invokes cb with versions retrieved"
+      before(:each) do
+        # XXX clear the cached version of the gem specification db
+        described_class.instance_variable_set(:@local_db, nil)
+
+        gem1 = ::Gem::Specification.new 'rake', '1.0'
+        gem2 = ::Gem::Specification.new 'rake', '2.0'
+        gem3 = ::Gem::Specification.new 'rails', '3.0'
+        ::Gem::Specification.should_receive(:all).and_return([gem1, gem2, gem3])
+
+        @version1 = ::Gem::Version.new '1.0'
+        @version2 = ::Gem::Version.new '2.0'
+      end
+
+      it "returns versions of specified gem in local db" do
+        described_class.local_versions_for('rake').should == [@version1, @version2]
+      end
+
+      it "invokes cb with versions retrieved" do
+        cb = proc {}
+        cb.should_receive(:call).with(:local_gem, 'rake', [@version1, @version2])
+        described_class.local_versions_for('rake', &cb)
+      end
     end
 
     describe "#parse" do
       it "returns new gem" do
-        gem = Polisher::Gem.parse
-        gem.should be_an_instance_of(Polisher::Gem)
+        gem = described_class.parse
+        gem.should be_an_instance_of(described_class)
       end
 
       it "parses gem from gem spec" do
         spec = Polisher::Test::GEM_SPEC
-        gem  = Polisher::Gem.parse(:gemspec => spec[:path])
+        gem  = described_class.parse(:gemspec => spec[:path])
         gem.name.should     == spec[:name]
         gem.version.should  == spec[:version]
         gem.deps.should     == spec[:deps]
         gem.dev_deps.should == spec[:dev_deps]
       end
 
       it "parses gem from gem at path"
 
       it "parses gem from metadata hash" do
         gemj = Polisher::Test::GEM_JSON
-        gem = Polisher::Gem.parse gemj[:json]
+        gem = described_class.parse gemj[:json]
         gem.name.should     == gemj[:name]
         gem.version.should  == gemj[:version]
         gem.deps.should     == gemj[:deps]
         gem.dev_deps.should == gemj[:dev_deps]
       end
     end
 
+    describe "#remote_versions_for" do
+      it "retrieves versions from rubygems.org" do
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.should_receive(:http_get)
 
+        # actual output too verbose, just including bits we need
+        curl.should_receive(:body_str)
+            .and_return([{'number' => 1.1}, {'number' => 2.2}].to_json)
+        described_class.remote_versions_for('polisher').should == [1.1, 2.2]
+        curl.url.should == "https://rubygems.org/api/v1/versions/polisher.json"
+      end
+    end
+
+    describe "#lastest_version_of" do
+      it "retrieves latests version of gem available on rubygems.org" do
+        described_class.should_receive(:remote_versions_for)
+                       .with('polisher')
+                       .and_return([2.2, 1.1])
+        described_class.latest_version_of('polisher').should == 2.2
+      end
+    end
+
     describe "#download_gem" do
       context "gem in GemCache" do
-        it "returns GemCache gem"
+        it "returns GemCache gem" do
+          gem = described_class.new
+          GemCache.should_receive(:get).with('polisher', '1.1')
+                                       .and_return(gem)
+          described_class.download_gem('polisher', '1.1').should == gem
+        end
       end
 
-      it "uses curl to download gem"
-      it "sets gem in gem cached"
-      it "returns downloaded gem binary contents"
+      it "uses curl to download gem" do
+        GemCache.should_receive(:get).and_return(nil)
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.should_receive(:http_get)
+        curl.should_receive(:body_str).and_return('') # stub out body_str
+
+        described_class.download_gem 'polisher', '2.2'
+        curl.url.should == "https://rubygems.org/gems/polisher-2.2.gem"
+      end
+
+      it "sets gem in gem cache" do
+        GemCache.should_receive(:get).and_return(nil)
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.stub(:http_get) # stub out http_get
+        curl.should_receive(:body_str).and_return('gem')
+        GemCache.should_receive(:set)
+                .with('polisher', '1.1', 'gem')
+        described_class.download_gem 'polisher', '1.1'
+      end
+
+      it "returns downloaded gem binary contents" do
+        GemCache.should_receive(:get).and_return(nil)
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.stub(:http_get) # stub out http_get
+        curl.should_receive(:body_str).and_return('gem')
+        described_class.download_gem('polisher', '1.1').should == 'gem'
+      end
     end
 
     describe "#download_gem_path" do
       it "downloads gem" do
-        gem = Polisher::Gem.new
-        Polisher::Gem.should_receive(:download_gem)
+        gem = described_class.new
+        described_class.should_receive(:download_gem)
         gem.downloaded_gem_path
       end
 
       it "returns gem cache path for gem" do
         # stub out d/l
-        gem = Polisher::Gem.new :name => 'rails', :version => '1.0'
-        Polisher::Gem.should_receive(:download_gem)
-        Polisher::GemCache.should_receive(:path_for).
-                           with('rails', '1.0').
-                           at_least(:once).
-                           and_return('rails_path')
+        gem = described_class.new :name => 'rails', :version => '1.0'
+        described_class.should_receive(:download_gem)
+        Polisher::GemCache.should_receive(:path_for)
+                          .with('rails', '1.0')
+                          .at_least(:once)
+                          .and_return('rails_path')
         gem.downloaded_gem_path.should == 'rails_path'
       end
     end
 
     describe "#gem_path" do
       it "returns specified path" do
-        gem = Polisher::Gem.new :path => 'gem_path'
+        gem = described_class.new :path => 'gem_path'
         gem.gem_path.should == 'gem_path'
       end
 
       context "specified path is null" do
         it "returns downloaded gem path" do
-          gem = Polisher::Gem.new
+          gem = described_class.new
           gem.should_receive(:downloaded_gem_path).and_return('gem_path')
           gem.gem_path.should == 'gem_path'
         end
       end
     end
@@ -124,52 +224,135 @@
         it "returns nil"
       end
     end
 
     describe "#file_paths" do
-      it "returns list of file paths in gem"
+      it "returns list of file paths in gem" do
+        gem = described_class.new
+        gem.should_receive(:each_file).and_yield('file1').and_yield('file2')
+        gem.file_paths.should == %w(file1 file2)
+      end
     end
 
     describe "#retrieve" do
-      before(:each) do
-        @local_gem = Polisher::Test::LOCAL_GEM
-      end
-
       it "returns gem retrieved from rubygems" do
-        gem = Polisher::Gem.retrieve(@local_gem[:name])
-        gem.should be_an_instance_of(Polisher::Gem)
-        gem.name.should     == @local_gem[:name]
-        gem.version.should  == @local_gem[:version]
-        gem.deps.should     == @local_gem[:deps]
-        gem.dev_deps.should == @local_gem[:dev_deps]
+        curl = Curl::Easy.new
+        curl.should_receive(:body_str).and_return('spec')
+
+        url = "https://rubygems.org/api/v1/gems/rails.json"
+        Curl::Easy.should_receive(:http_get).with(url).and_return(curl)
+
+        gem = described_class.new
+        described_class.should_receive(:parse).with('spec').and_return(gem)
+
+        described_class.retrieve('rails').should == gem
       end
     end
 
     describe "#versions" do
-      it "looks up and returns versions for gemname in polisher version checker"
+      it "looks up and returns versions of gem" do
+        gem = described_class.new :name => 'rails'
+        Polisher::VersionChecker.should_receive(:versions_for)
+                                .with('rails')
+                                .and_return(:koji => ['1.1.1'])
+        gem.versions.should == {'rails' => {:koji => ['1.1.1']}}
+      end
 
       context "recursive is true" do
-        it "appends versions of gem dependencies to versions list"
+        it "retrieves dependency versions" do
+          # stub out version checker
+          retrieved = {:koji => ['1.0']}
+          Polisher::VersionChecker.should_receive(:versions_for)
+                                  .and_return(retrieved)
+
+          versions = {}
+          gem = described_class.new :name => 'rails'
+          gem.should_receive(:dependency_versions)
+             .with(:recursive => true, :versions => {'rails' => retrieved})
+             .and_call_original
+          gem.versions(:recursive => true, :versions => versions)
+             .should == {'rails' => {:koji => ['1.0']}}
+        end
+
         context "dev_deps is true" do
-          it "appends versions of gem dev dependencies to versions list"
+          it "retrieves dev dependency versions" do
+            # stub out version checker
+            retrieved = {:koji => ['1.0']}
+            Polisher::VersionChecker.should_receive(:versions_for)
+                                    .and_return(retrieved)
+
+            versions = {}
+            gem = described_class.new :name => 'rails'
+            gem.should_receive(:dependency_versions)
+               .with(:recursive => true, :dev_deps => true,
+                      :versions => {'rails' => retrieved})
+               .and_call_original
+            gem.should_receive(:dependency_versions)
+               .with(:recursive => true, :dev => true, :dev_deps => true,
+                      :versions => {'rails' => retrieved})
+               .and_call_original
+            gem.versions(:recursive => true, :dev_deps => true,
+                         :versions => versions)
+               .should == {'rails' => {:koji => ['1.0']}}
+          end
         end
       end
     end
 
+    describe "#dependency_versions" do
+      it "retrieves dependency versions" do
+        gem = described_class.new
+        gem.should_receive(:deps).and_return([::Gem::Dependency.new('rake')])
+        described_class.should_receive(:retrieve)
+                       .with('rake').and_return(gem)
+
+        versions = {'rake' => {:koji => ['2.1']}}
+        gem.should_receive(:versions).and_return(versions)
+        gem.dependency_versions.should == versions
+      end
+
+      it "retrieves dev dependency versions" do
+        gem = described_class.new
+        gem.should_receive(:dev_deps).and_return([::Gem::Dependency.new('rake')])
+        described_class.should_receive(:retrieve)
+                       .with('rake').and_return(gem)
+
+        versions = {'rake' => {:koji => ['2.1']}}
+        gem.should_receive(:versions).and_return(versions)
+        gem.dependency_versions(:dev => true).should == versions
+      end
+
+      context "error during gem or version retrieval" do
+        it "sets version to 'unknown'" do
+          gem = described_class.new
+          gem.should_receive(:deps).and_return([::Gem::Dependency.new('rake')])
+          described_class.should_receive(:retrieve)
+                         .with('rake').and_raise(RuntimeError)
+
+          versions = {:all => [:unknown]}
+          gem.should_not_receive(:versions)
+          Polisher::VersionChecker.should_receive(:unknown_version)
+                                  .with(:all, 'rake')
+                                  .and_return(versions)
+          gem.dependency_versions.should == {'rake' => versions}
+        end
+      end
+    end
+
     describe "#diff" do
       before(:each) do
-        @gem1 = Polisher::Gem.new
-        @gem2 = Polisher::Gem.new
+        @gem1 = described_class.new
+        @gem2 = described_class.new
 
         @result = AwesomeSpawn::CommandResult.new '', 'diff_out', '', 0
       end
 
       it "runs diff against unpacked local and other gems and returns output" do
         @gem1.should_receive(:unpack).and_return('dir1')
         @gem2.should_receive(:unpack).and_return('dir2')
-        AwesomeSpawn.should_receive(:run).
-          with("#{Polisher::Gem::DIFF_CMD} -r dir1 dir2").
-          and_return(@result)
+        AwesomeSpawn.should_receive(:run)
+          .with("#{Polisher::Gem.diff_cmd} -r dir1 dir2")
+          .and_return(@result)
         @gem1.diff(@gem2).should == @result.output
       end
 
       it "removes unpacked gem dirs" do
         @gem1.should_receive(:unpack).and_return('dir1')