stickler 2.3.0 → 2.4.0

data/test/middleware/test_local.rb

@@ -0,0 +1,75 @@
+require 'test_stickler'
+
+module Stickler
+  class MiddlewareLocalTest < Test
+    include IndexTestHelpers
+    include Rack::Test::Methods
+
+    def app
+      repo_root = @idx_test_datadir
+      ::Rack::Builder.new do
+        use ::Stickler::Middleware::Compression
+        use ::Stickler::Middleware::Local, :repo_root => repo_root
+        run ::Sinatra::Base
+      end
+    end
+  end
+
+  class MiddlewareLocalModernTest < MiddlewareLocalTest
+    def setup
+      mirror_spec_gemdir
+      make_modern_index
+    end
+
+    def teardown
+      destroy_scratch_dir
+    end
+
+    def test_returns_the_same_bytes_as_gem_indexer 
+      [
+        "/specs.#{Gem.marshal_version}",
+        "/specs.#{Gem.marshal_version}.gz",
+        "/latest_specs.#{Gem.marshal_version}",
+        "/latest_specs.#{Gem.marshal_version}.gz",
+        "/prerelease_specs.#{Gem.marshal_version}",
+        "/prerelease_specs.#{Gem.marshal_version}.gz",
+        "/quick/Marshal.#{Gem.marshal_version}/foo-1.0.0.gemspec.rz",
+        "/quick/Marshal.#{Gem.marshal_version}/bar-1.0.0.gemspec.rz",
+        "/quick/Marshal.#{Gem.marshal_version}/foo-2.0.0a.gemspec.rz",
+        "/quick/Marshal.#{Gem.marshal_version}/baz-3.1.4-java.gemspec.rz",
+        "/quick/Marshal.#{Gem.marshal_version}/baz-3.1.4.gemspec.rz",
+      ].each do |path|
+        response  = get( path )
+        need, got = validate_contents( response.body,
+                                       IO.read( File.join(@scratch_datadir, path) ),
+                                       response.content_type )
+        assert_equal need, got, "Match failure for #{path}"
+      end
+    end
+  end
+
+  class MiddlewareLocalLegacyTest < MiddlewareLocalTest
+    def setup
+      mirror_spec_gemdir
+      make_legacy_index
+    end
+
+    def teardown
+      destroy_scratch_dir
+    end
+
+    def test_returns_the_same_bytes_as_gem_indexer 
+      [
+        "/Marshal.#{Gem.marshal_version}",
+        "/Marshal.#{Gem.marshal_version}.Z",
+      ].each do |path|
+        skip "Not testing legacy indexes at the moment"
+        response  = get( path )
+        need, got = validate_contents( response.body,
+                                       IO.read( File.join(@scratch_datadir, path) ),
+                                       response.content_type )
+        assert_equal need, got, "Match failure for #{path}"
+      end
+    end
+  end
+end

data/test/middleware/test_not_found.rb

@@ -0,0 +1,26 @@
+require 'test_stickler'
+
+module Stickler
+  class MiddlewareNotFound < Test
+    include Rack::Test::Methods
+    def app
+      ::Stickler::Middleware::NotFound.new
+    end
+
+    def setup
+      get "/"
+    end
+
+    def test_responds_with_404_to_everything
+      assert_equal 404, last_response.status
+    end
+
+    def test_resturns_html_page
+      assert_equal 'text/html', last_response.content_type
+    end
+
+    def test_body_says_look_elsewhere 
+     assert_match( /Not Found/, last_response.body)
+    end
+  end
+end

data/test/repository/test_api.rb

@@ -0,0 +1,49 @@
+require 'test_stickler'
+require 'digest/sha1'
+
+module Stickler
+  module RepositoryApiTests
+    def test_implements_all_the_api_methods
+      Stickler::Repository::Api.api_methods.each do |method|
+        assert_respond_to repo, method
+      end
+    end
+  end
+
+  # Stub class for testing
+  module Repository
+    class Stub
+      include Stickler::Repository::Api
+    end
+  end
+
+  class RepositoryApiModuleTest < Test
+    include RepositoryApiTests
+
+    def repo
+      @repo ||= Stickler::Repository::Stub.new
+    end
+
+    def setup
+      @spec = Stickler::SpecLite.new( "foo", "1.0.0" )
+    end
+
+    def test_raising_error_on_unimplemented_methods
+      %w[ uri gems_uri ].each do |method|
+        assert_raises( NotImplementedError ) { repo.send( method ) }
+      end
+    end
+
+    def test_raising_error_on_unimplemented_methods_taking_a_spec
+      %w[ uri_for_gem search_for delete yank get open ].each do |method|
+        assert_raises( NotImplementedError ) { repo.send( method, @spec ) }
+      end
+    end
+
+    def test_raising_error_on_implemented_methods_taking_an_object
+      %w[ push ].each do |method|
+        assert_raises( NotImplementedError ) { repo.send( method, Object.new ) }
+      end
+    end
+  end
+end

data/test/repository/test_api_behavior.rb

@@ -0,0 +1,208 @@
+require 'test_stickler'
+require 'digest/sha1'
+require 'repository/test_api'
+
+module Stickler
+  module RepositoryApiBehaviorTests
+    include RepositoryApiTests
+    def setup
+      super
+      @foo_gem_local_path = File.join( gems_dir, "foo-1.0.0.gem" )
+      @foo_spec           = Stickler::SpecLite.new( 'foo', '1.0.0' )
+      assert File.readable?( @foo_gem_local_path ), "#{@foo_gem_local_path} is missing"
+      @foo_digest         = Digest::SHA1.hexdigest( IO.read( @foo_gem_local_path ) )
+      @missing_spec       = Stickler::SpecLite.new( "does_not_exist", "0.1.0" )
+    end
+
+    #####
+    # URI
+    #####
+
+    def test_uri
+      result = repo.uri
+      assert_includes [ ::URI, ::Addressable::URI ], result.class
+    end
+
+    def test_gems_uri
+      result = repo.gems_uri
+      assert_includes [ ::URI, ::Addressable::URI ], result.class
+    end
+
+    def test_uri_for_gem
+      repo.push( @foo_gem_local_path )
+      result = repo.uri_for_gem( @foo_spec )
+      assert_includes [ ::URI, ::Addressable::URI ], result.class
+      assert_nil repo.uri_for_gem( @missing_spec )
+    end
+
+    #######
+    # Push
+    #######
+
+    def test_pushes_a_gem_file
+      repo.push( @foo_gem_local_path )
+      result = repo.search_for( Stickler::SpecLite.new( "foo", "1.0.0" ) )
+      assert_instance_of Array, result
+      assert_equal 1, result.size
+    end
+
+    def test_raising_error_when_pushing_already_existing_gem
+      repo.push( @foo_gem_local_path )
+      assert_raises_kind_of( Stickler::Repository::Error ) do 
+        repo.push( @foo_gem_local_path )
+      end
+    end
+
+    ########
+    # Delete
+    ########
+
+    def test_delete_existing_gem
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      
+      assert_equal 1, repo.search_for( @foo_spec ).size
+
+      assert repo.delete( @foo_spec )
+      assert_empty repo.search_for( @foo_spec )
+    end
+
+    def test_delete_non_existing_gem
+      assert_empty repo.search_for( @foo_spec )
+      refute repo.delete( @foo_spec )
+    end
+
+    ######
+    # yank
+    ######
+
+    def test_yank_returns_the_uri_of_the_gem
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      @response_uri = repo.yank( @foo_spec )
+      assert_includes [ ::URI, ::Addressable::URI ], @response_uri.class
+    end
+
+    def test_yank_returns_nil_for_non_existent_gem
+      assert_nil repo.yank( @missing_spec )
+    end
+
+    def test_yanked_gem_does_not_appear_in_search
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      @response_uri = repo.yank( @foo_spec )
+      assert_empty repo.search_for( @foo_spec )
+    end
+
+    def test_yanked_gem_does_still_have_a_uri
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      @response_uri = repo.yank( @foo_spec )
+      assert_equal @response_uri, repo.uri_for_gem( @foo_spec )
+    end
+
+    def test_yanked_gem_may_still_be_retrieved
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      data = repo.get( @foo_spec )
+      sha1 = Digest::SHA1.hexdigest( data )
+      assert_equal @foo_digest, sha1
+    end
+
+    ########
+    # unyank 
+    ########
+    
+    def test_unyank_returns_nil_for_non_existent_gem
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      non_existing_gem = @missing_spec
+      assert_nil repo.unyank( non_existing_gem )
+    end
+
+
+    # Do we even care about this?
+    def test_unyank_returns_nil_for_not_yet_yanked_gem
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      assert_equal 1, repo.search_for( @foo_spec ).size
+      assert_nil repo.unyank( @foo_spec )
+    end
+
+    def test_unyank_returns_true_on_success
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      repo.yank( @foo_spec )
+      assert repo.unyank( @foo_spec ), "Expected true"
+    end
+
+    def test_unyank_returns_gem_to_searchability
+      assert_empty repo.search_for( @foo_spec )
+      repo.push( @foo_gem_local_path )
+      repo.yank( @foo_spec )
+      repo.unyank( @foo_spec )
+      assert_equal 1, repo.search_for( @foo_spec ).size
+    end
+
+    ############
+    # Search For
+    ############
+    
+    def test_search_for_returns_found_items 
+      repo.push( @foo_gem_local_path )
+      refute_empty repo.search_for( @foo_spec )
+    end
+
+    def test_search_for_returns_empty_array_when_nothing_found
+      assert_empty repo.search_for( @missing_spec )
+    end
+
+
+    #####
+    # GET
+    #####
+    
+    def test_get_returns_the_bytes_of_a_gem_that_exists
+      repo.push( @foo_gem_local_path )
+      data = repo.get( @foo_spec )
+      sha1 = Digest::SHA1.hexdigest( data )
+      assert_equal @foo_digest, sha1
+    end
+
+    def test_get_returns_nil_for_non_existent_gem
+      assert_nil repo.get( @missing_spec )
+    end
+
+    ######
+    # open
+    ######
+    
+    def test_open_reads_a_gem_via_the_returned_output_stream
+      repo.push( @foo_gem_local_path )
+      io = repo.open( @foo_spec )
+      sha1 = Digest::SHA1.hexdigest( io.read )
+      assert_equal @foo_digest, sha1
+    end
+
+    def test_open_may_be_called_with_a_block
+      repo.push( @foo_gem_local_path )
+      sha1 = Digest::SHA1.new
+      repo.open( @foo_spec ) do |io|
+        sha1 << io.read
+      end
+      assert_equal @foo_digest, sha1.hexdigest
+    end
+
+    def test_open_returns_nil_for_non_existent_gem
+      assert_nil repo.open( @missing_spec )
+    end
+
+    def test_open_does_not_call_block_for_non_existent_gem
+      called = false
+      repo.open( @missing_spec ) do |io|
+        called = true
+      end
+      refute called
+    end
+  end
+end

data/test/repository/test_index.rb

@@ -0,0 +1,48 @@
+require 'test_stickler'
+
+module Stickler
+  class TestIndexRepository < Test
+    def setup
+      @index_me = File.join( test_dir, "tmp" )
+      FileUtils.mkdir_p( @index_me )
+
+      @specifications = Dir.glob( File.join( specifications_dir, "*.gemspec" ) )
+      @specifications.each do |s|
+          FileUtils.cp( s, @index_me )
+      end
+      @index = ::Stickler::Repository::Index.new( @index_me )
+    end
+
+    def teardown
+      FileUtils.rm_rf( @index_me )
+    end
+
+    def test_all_gemspec_files_in_a_directory_are_indexed
+      assert_equal @specifications.size, @index.specs.size
+    end
+
+    def test_notice_changes_in_the_index
+      assert_equal @specifications.size, @index.specs.size
+      FileUtils.rm( File.join( @index_me, "foo-1.0.0.gemspec" ) )
+      assert_equal @specifications.size-1, @index.specs.size
+    end
+
+    def test_latest_specs
+      assert_equal( @specifications.size - 1, @index.latest_specs.size )
+      expected = %w[ bar-1.0.0 baz-3.1.4 baz-3.1.4-java foo-1.0.0 ]
+      assert_equal expected, @index.latest_specs.collect { |s| s.full_name }.sort
+    end
+
+    def test_pre_release_specs
+      assert_equal 1, @index.prerelease_specs.size
+      assert_equal "foo-2.0.0a",@index.prerelease_specs.first.full_name
+    end
+
+    def test_released_specs
+      assert_equal 4, @index.released_specs.size
+      expected = %w[ bar-1.0.0 baz-3.1.4 baz-3.1.4-java foo-1.0.0 ]
+      assert_equal expected, @index.released_specs.collect { |s| s.full_name }.sort
+    end
+  end
+end
+

data/test/repository/test_local.rb

@@ -0,0 +1,59 @@
+require 'test_stickler'
+require 'repository/test_api_behavior'
+
+module Stickler
+  class LocalRepositoryTest < Test
+    include RepositoryApiBehaviorTests
+
+    def repos_dir
+      File.join( test_dir, "repos" )
+    end
+
+    def repo_dir
+      File.join( repos_dir, "1" )
+    end
+
+    def repo
+      @repo ||= ::Stickler::Repository::Local.new( repo_dir )
+    end
+
+    def teardown
+      super
+      FileUtils.rm_rf( repos_dir )
+    end
+
+    def test_creates_gems_directory
+      repo.gems_dir
+      new_dir = File.join( repo_dir , 'gems') + File::SEPARATOR
+      assert File.directory?( new_dir ), "#{new_dir} must be a directory"
+      assert_equal new_dir, repo.gems_dir
+    end
+
+    def test_creates_specifications_directory
+      repo.specifications_dir
+      new_dir = File.join( repo_dir , 'specifications' ) + File::SEPARATOR
+      assert File.directory?( new_dir ), "#{new_dir} must be a directory"
+      assert_equal new_dir, repo.specifications_dir
+    end
+
+    def test_lists_all_specs_in_the_repo
+      Dir.glob( File.join( gems_dir, "*.gem" ) ).each do |gem|
+        repo.push( gem )
+      end
+      assert_equal 5, repo.specs.size
+    end
+
+    def test_two_instances_with_the_same_repo_dir_are_the_same_object
+      repo2 = ::Stickler::Repository::Local.new( File.join( repos_dir, '1') )
+      assert_equal repo.object_id, repo2.object_id
+      assert_equal 1, ::Stickler::Repository::Local.repos.size
+    end
+
+    def test_tracks_all_repository_instances
+      ::Stickler::Repository::Local.new( File.join( repos_dir, "2" ) )
+      ::Stickler::Repository::Local.new( File.join( repos_dir, "3" ) )
+      assert_equal 2, ::Stickler::Repository::Local.repos.size
+    end
+  end
+end
+