gemirro 0.6.0 → 0.7.0

data/spec/gemirro/gems_fetcher_spec.rb

@@ -47,11 +47,11 @@ module Gemirro
     it 'should log error when fetch gem failed' do
       gem = Gem.new('gemirro')
       version = ::Gem::Version.new('0.0.1')
-      @source.should_receive(:fetch_gem)
+      allow(@source).to receive(:fetch_gem)
         .once.with('gemirro', version).and_raise(ArgumentError)
-      @fetcher.logger.should_receive(:error)
+      allow(@fetcher.logger).to receive(:error)
         .once.with(/Failed to retrieve/)
-      @fetcher.logger.should_receive(:debug)
+      allow(@fetcher.logger).to receive(:debug)
         .once.with(/Adding (.*) to the list of ignored Gems/)
 
       expect(@fetcher.fetch_gem(gem, version)).to be_nil
@@ -61,7 +61,7 @@ module Gemirro
     it 'should fetch gem' do
       gem = Gem.new('gemirro')
       version = ::Gem::Version.new('0.0.1')
-      @source.should_receive(:fetch_gem)
+      allow(@source).to receive(:fetch_gem)
         .once.with('gemirro', version).and_return('gemirro')
 
       expect(@fetcher.fetch_gem(gem, version)).to eq('gemirro')
@@ -69,17 +69,17 @@ module Gemirro
 
     it 'should retrieve versions for specific gem' do
       gem = Gem.new('gemirro', '0.0.2')
-      @versions_file.should_receive(:versions_for)
+      allow(@versions_file).to receive(:versions_for)
         .once.with('gemirro').and_return(['0.0.1', '0.0.2'])
       expect(@fetcher.versions_for(gem)).to eq([::Gem::Version.new('0.0.2')])
     end
 
     it 'should fetch all gems and log debug if gem is not satisfied' do
       gem = Gem.new('gemirro', '0.0.1')
-      gem.requirement.should_receive(:satisfied_by?)
+      allow(gem.requirement).to receive(:satisfied_by?)
         .once.with(nil).and_return(false)
       @fetcher.source.gems << gem
-      @fetcher.logger.should_receive(:debug)
+      allow(@fetcher.logger).to receive(:debug)
         .once.with('Skipping gemirro-0.0.1.gem')
       expect(@fetcher.fetch).to eq([gem])
     end
@@ -87,16 +87,16 @@ module Gemirro
     it 'should fetch all gems' do
       gem = Gem.new('gemirro', '0.0.2')
       @fetcher.source.gems << gem
-      @fetcher.should_receive(:versions_for).once.and_return(['0.0.2'])
-      gem.requirement.should_receive(:satisfied_by?)
+      allow(@fetcher).to receive(:versions_for).once.and_return(['0.0.2'])
+      allow(gem.requirement).to receive(:satisfied_by?)
         .once.with('0.0.2').and_return(true)
-      @fetcher.should_receive(:fetch_gem)
+      allow(@fetcher).to receive(:fetch_gem)
         .once.with(gem, '0.0.2').and_return('gemfile')
-      @fetcher.configuration.should_receive(:ignore_gem)
+      allow(@fetcher.configuration).to receive(:ignore_gem)
         .once.with('gemirro', '0.0.2')
-      @fetcher.logger.should_receive(:info)
+      allow(@fetcher.logger).to receive(:info)
         .once.with('Fetching gemirro-0.0.2.gem')
-      @fetcher.configuration.mirror_directory.should_receive(:add_file)
+      allow(@fetcher.configuration.mirror_directory).to receive(:add_file)
         .once.with('gemirro-0.0.2.gem', 'gemfile')
       expect(@fetcher.fetch).to eq([gem])
     end

data/spec/gemirro/http_spec.rb

@@ -14,7 +14,7 @@ module Gemirro
       uri = 'http://github.com/PierreRambaud'
       Struct.new('HTTPError', :status, :reason)
       result = Struct::HTTPError.new(401, 'Unauthorized')
-      Http.client.should_receive(:get)
+      allow(Http.client).to receive(:get)
         .once.with(uri, follow_redirect: true).and_return(result)
       expect { Http.get(uri) }
         .to raise_error HTTPClient::BadResponseError, 'Unauthorized'
@@ -24,7 +24,7 @@ module Gemirro
       uri = 'http://github.com/PierreRambaud'
       Struct.new('HTTPResponse', :status, :body)
       result = Struct::HTTPResponse.new(200, 'body content')
-      Http.client.should_receive(:get)
+      allow(Http.client).to receive(:get)
         .once.with(uri, follow_redirect: true).and_return(result)
 
       response = Http.get(uri)

data/spec/gemirro/indexer_spec.rb

@@ -11,46 +11,71 @@ module Gemirro
   describe 'Indexer' do
     include FakeFS::SpecHelpers
 
-    before(:each) do
-      skip if ::Gem::Version.new(RUBY_VERSION.dup) >= ::Gem::Version
-              .new('2.0.0')
-    end
-
     it 'should install indicies' do
-      dir = MirrorDirectory.new('./')
+      dir = MirrorDirectory.new('/tmp')
+      dir.add_directory('test')
       dir.add_directory('gem_generate_index/quick/Marshal.4.8')
-      ::Gem.configuration.should_receive(:really_verbose).once.and_return(true)
+      allow(::Gem.configuration).to receive(:really_verbose)
+        .once.and_return(true)
 
-      indexer = Indexer.new('./')
-      indexer.should_receive(:say)
-        .once.with('Downloading index into production dir ./')
-      indexer.quick_marshal_dir = 'gem_generate_index/quick/Marshal.4.8'
-      indexer.dest_directory = './'
-      indexer.directory = 'gem_generate_index'
+      indexer = Indexer.new('/tmp/test')
+      allow(indexer).to receive(:say)
+        .once.with('Downloading index into production dir /tmp/test')
+      indexer.quick_marshal_dir = '/tmp/gem_generate_index/quick/Marshal.4.8'
+      indexer.dest_directory = '/tmp/test'
+      indexer.directory = '/tmp/gem_generate_index'
+      indexer.instance_variable_set('@specs_index',
+                                    '/tmp/gem_generate_index/specs.4.8')
       indexer.files = [
-        'gem_generate_index/quick/Marshal.4.8',
-        'gem_generate_index/specs.4.8.gz'
+        '/tmp/gem_generate_index/quick/Marshal.4.8',
+        '/tmp/gem_generate_index/specs.4.8.gz',
+        '/tmp/gem_generate_index/something.4.8.gz'
       ]
 
-      FileUtils.should_receive(:mkdir_p).once.with('./quick', verbose: true)
-      FileUtils.should_receive(:rm_rf)
-        .once.with('gem_generate_index/specs.4.8.gz')
-      FileUtils.should_receive(:rm_rf)
-        .once.with('./quick/Marshal.4.8', verbose: true)
-      FileUtils.should_receive(:mv)
+      allow(FileUtils).to receive(:mkdir_p)
+        .once.with('/tmp/test/quick', verbose: true)
+      allow(FileUtils).to receive(:rm_rf)
+        .once.with('/tmp/gem_generate_index/something.4.8.gz')
+      allow(FileUtils).to receive(:rm_rf)
+        .once.with('/tmp/gem_generate_index/specs.4.8.gz')
+      allow(FileUtils).to receive(:rm_rf)
+        .once.with('/tmp/test/quick/Marshal.4.8', verbose: true)
+      allow(FileUtils).to receive(:mv)
         .once
-        .with('gem_generate_index/quick/Marshal.4.8', './quick/Marshal.4.8',
+        .with('/tmp/gem_generate_index/quick/Marshal.4.8',
+              '/tmp/test/quick/Marshal.4.8',
               verbose: true, force: true)
+
       source = Source.new('Rubygems', 'https://rubygems.org')
-      Gemirro.configuration.should_receive(:source).and_return(source)
+      allow(Gemirro.configuration).to receive(:source).and_return(source)
+
       Struct.new('HttpGet', :code, :body)
-      http_get = Struct::HttpGet.new(200, 'content')
-      Http.should_receive(:get)
+      wio = StringIO.new('w')
+      w_gz = Zlib::GzipWriter.new(wio)
+      w_gz.write(['content'])
+      w_gz.close
+      http_get = Struct::HttpGet.new(200, wio.string)
+      allow(Marshal).to receive(:load).and_return(['content'])
+      allow(Marshal).to receive(:dump).and_return(['content'])
+      allow(Zlib::GzipWriter).to receive(:open)
+        .once.with('/tmp/test/specs.4.8.gz.orig')
+      allow(Zlib::GzipWriter).to receive(:open)
+        .once.with('/tmp/test/specs.4.8.gz')
+      allow(Http).to receive(:get)
         .with('https://rubygems.org/specs.4.8.gz').and_return(http_get)
+      allow(Http).to receive(:get)
+        .with('https://rubygems.org/something.4.8.gz').and_return(http_get)
+
+      Struct.new('GzipReader', :read)
+      gzip_reader = Struct::GzipReader.new(wio.string)
+      allow(Zlib::GzipReader).to receive(:open)
+        .once
+        .with('/tmp/gem_generate_index/specs.4.8.gz')
+        .and_return(gzip_reader)
 
       files = indexer.install_indicies
-      expect(files).to eq(['gem_generate_index/specs.4.8.gz'])
-      expect(MirrorFile.new('specs.4.8.gz').read).to eq('content')
+      expect(files).to eq(['/tmp/gem_generate_index/specs.4.8.gz',
+                           '/tmp/gem_generate_index/something.4.8.gz'])
     end
 
     it 'should exit if there is no new gems' do
@@ -59,12 +84,12 @@ module Gemirro
       MirrorFile.new('./specs.4.8').write('')
 
       indexer = Indexer.new('./')
-      indexer.should_receive(:make_temp_directories).and_return(true)
+      allow(indexer).to receive(:make_temp_directories).and_return(true)
 
       expect { indexer.update_gemspecs }.to raise_error SystemExit
     end
 
-    it 'should generate gemspecs files' do
+    it 'should update gemspecs files' do
       dir = MirrorDirectory.new('/')
       dir.add_directory('gems')
       dir.add_directory('quick')
@@ -80,10 +105,10 @@ module Gemirro
       MirrorFile.new("#{indexer.directory}/quick/gemirro-0.1.0.gemspec.rz")
         .write('test')
 
-      indexer.should_receive(:gem_file_list)
+      allow(indexer).to receive(:gem_file_list)
         .and_return(['gems/gemirro-0.1.0.gem'])
-      indexer.should_receive(:make_temp_directories).once.and_return(true)
-      indexer.should_receive(:build_marshal_gemspecs).once.and_return([
+      allow(indexer).to receive(:make_temp_directories).once.and_return(true)
+      allow(indexer).to receive(:build_marshal_gemspecs).once.and_return([
         "#{indexer.directory}/quick/gemirro-0.1.0.gemspec.rz"])
 
       indexer.update_gemspecs

data/spec/gemirro/server_spec.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+require 'rack/test'
+require 'gemirro/mirror_directory'
+require 'gemirro/mirror_file'
+require 'gemirro/gem_version_collection'
+
+ENV['RACK_ENV'] = 'test'
+
+# Rspec mixin module
+module RSpecMixin
+  include Rack::Test::Methods
+  def app
+    require 'gemirro/server'
+    Gemirro::Server
+  end
+end
+
+RSpec.configure do |c|
+  c.include RSpecMixin
+end
+
+# Server tests
+module Gemirro
+  describe 'Gemirro::Server' do
+    include FakeFS::SpecHelpers
+
+    before(:each) do
+      @fake_logger = Logger.new(STDOUT)
+      MirrorDirectory.new('/var/www/gemirro').add_directory('gems')
+      MirrorDirectory.new('/').add_directory('tmp')
+      MirrorFile.new('/var/www/gemirro/test').write('content')
+      Gemirro.configuration.destination = '/var/www/gemirro'
+      FakeFS::FileSystem.clone(Gemirro::Configuration.views_directory)
+    end
+
+    it 'should display index page' do
+      allow(Logger).to receive(:new).twice.and_return(@fake_logger)
+      allow(@fake_logger).to receive(:tap).and_return(nil)
+        .and_yield(@fake_logger)
+
+      get '/'
+      expect(last_response).to be_ok
+    end
+
+    it 'should return 404' do
+      get '/wrong-path'
+      expect(last_response.status).to eq(404)
+      expect(last_response).to_not be_ok
+    end
+
+    it 'should return 404 when gem does not exist' do
+      get '/gem/something'
+      expect(last_response.status).to eq(404)
+      expect(last_response).to_not be_ok
+    end
+
+    it 'should display gem specifications' do
+      marshal_dump = Marshal.dump([['groove-dl',
+                                    ::Gem::Version.create('0.1.0'),
+                                    'ruby']])
+
+      MirrorFile.new('/var/www/gemirro/specs.4.8.gz.orig').write(marshal_dump)
+      Struct.new('SuccessGzipReader', :read)
+      gzip_reader = Struct::SuccessGzipReader.new(marshal_dump)
+
+      allow(Zlib::GzipReader).to receive(:open)
+        .once
+        .with('/var/www/gemirro/specs.4.8.gz.orig')
+        .and_return(gzip_reader)
+
+      get '/gem/groove-dl'
+      expect(last_response.status).to eq(200)
+      expect(last_response).to be_ok
+    end
+
+    it 'should download existing file' do
+      get '/test'
+      expect(last_response.body).to eq('content')
+      expect(last_response).to be_ok
+    end
+
+    it 'should try to download gems.' do
+      source = Gemirro::Source.new('test', 'http://rubygems.org')
+
+      versions_fetcher = Gemirro::VersionsFetcher.new(source)
+      allow(versions_fetcher).to receive(:fetch).once.and_return(true)
+
+      gems_fetcher = Gemirro::VersionsFetcher.new(source)
+      allow(gems_fetcher).to receive(:fetch).once.and_return(true)
+
+      Struct.new('GemIndexer')
+      gem_indexer = Struct::GemIndexer.new
+      allow(gem_indexer).to receive(:only_origin=).once.and_return(true)
+      allow(gem_indexer).to receive(:ui=).once.and_return(true)
+      allow(gem_indexer).to receive(:generate_index).once.and_return(true)
+
+      allow(Gemirro.configuration).to receive(:source).twice.and_return(source)
+      allow(Gemirro::GemsFetcher).to receive(:new).once.and_return(gems_fetcher)
+      allow(Gemirro::VersionsFetcher).to receive(:new)
+        .once.and_return(versions_fetcher)
+      allow(Gemirro::Indexer).to receive(:new).once.and_return(gem_indexer)
+      allow(::Gem::SilentUI).to receive(:new).once.and_return(true)
+
+      allow(Gemirro.configuration).to receive(:logger)
+        .exactly(3).and_return(@fake_logger)
+      allow(@fake_logger).to receive(:info).exactly(3)
+
+      get '/gems/gemirro-0.0.1.gem'
+      expect(last_response).to_not be_ok
+      expect(last_response.status).to eq(404)
+
+      MirrorFile.new('/var/www/gemirro/gems/gemirro-0.0.1.gem').write('content')
+      get '/gems/gemirro-0.0.1.gem'
+      expect(last_response).to be_ok
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('content')
+    end
+
+    it 'should catch exceptions' do
+      source = Gemirro::Source.new('test', 'http://rubygems.org')
+
+      versions_fetcher = Gemirro::VersionsFetcher.new(source)
+      allow(versions_fetcher).to receive(:fetch).once.and_return(true)
+
+      gems_fetcher = Gemirro::VersionsFetcher.new(source)
+      allow(gems_fetcher).to receive(:fetch).once.and_raise(
+        StandardError, 'Not ok')
+
+      gem_indexer = Struct::GemIndexer.new
+      allow(gem_indexer).to receive(:only_origin=).once.and_return(true)
+      allow(gem_indexer).to receive(:ui=).once.and_return(true)
+      allow(gem_indexer).to receive(:generate_index).once.and_raise(SystemExit)
+
+      allow(Gemirro.configuration).to receive(:source).twice.and_return(source)
+      allow(Gemirro::GemsFetcher).to receive(:new).once.and_return(gems_fetcher)
+      allow(Gemirro::VersionsFetcher).to receive(:new)
+        .once.and_return(versions_fetcher)
+      allow(Gemirro::Indexer).to receive(:new).once.and_return(gem_indexer)
+      allow(::Gem::SilentUI).to receive(:new).once.and_return(true)
+
+      allow(Gemirro.configuration).to receive(:logger)
+        .exactly(4).and_return(@fake_logger)
+      allow(@fake_logger).to receive(:info).exactly(3)
+      allow(@fake_logger).to receive(:error)
+      get '/gems/gemirro-0.0.1.gem'
+      expect(last_response).to_not be_ok
+    end
+  end
+end

data/spec/gemirro/source_spec.rb

@@ -19,7 +19,7 @@ module Gemirro
     it 'should fetch versions' do
       Struct.new('FetchVersions', :body)
       result = Struct::FetchVersions.new(true)
-      Http.should_receive(:get).once.with(
+      allow(Http).to receive(:get).once.with(
         "https://rubygems.org/#{Configuration.versions_file}"
       ).and_return(result)
       expect(@source.fetch_versions).to be_truthy
@@ -28,7 +28,7 @@ module Gemirro
     it 'should fetch gem' do
       Struct.new('FetchGem', :body)
       result = Struct::FetchGem.new(true)
-      Http.should_receive(:get).once.with(
+      allow(Http).to receive(:get).once.with(
         'https://rubygems.org/gems/gemirro-0.0.1.gem').and_return(result)
       expect(@source.fetch_gem('gemirro', '0.0.1')).to be_truthy
     end

data/spec/gemirro/versions_fetcher_spec.rb

@@ -15,10 +15,10 @@ module Gemirro
     end
 
     it 'should fetch versions' do
-      Gemirro.configuration.logger.should_receive(:info)
+      allow(Gemirro.configuration.logger).to receive(:info)
         .once.with("Updating #{@source.name} (#{@source.host})")
-      @source.should_receive(:fetch_versions).once.and_return([])
-      VersionsFile.should_receive(:load).with([])
+      allow(@source).to receive(:fetch_versions).once.and_return([])
+      allow(VersionsFile).to receive(:load).with([])
       expect(@fetcher.fetch).to be_nil
     end
   end

data/spec/spec_helper.rb

@@ -6,12 +6,6 @@ require 'confstruct'
 require 'logger'
 require 'fakefs/spec_helpers'
 
-RSpec.configure do |config|
-  config.mock_with :rspec do |mocks|
-    mocks.syntax = :should
-  end
-end
-
 SimpleCov.start do
   add_filter '/spec/'
 end

data/template/logs/.gitkeep

@@ -0,0 +1 @@
+