grack 0.0.2 → 0.1.0.pre1

data/lib/grack/compatible_git_adapter.rb

@@ -0,0 +1,99 @@
+require 'pathname'
+
+require 'grack/file_streamer'
+
+module Grack
+  ##
+  # @deprecated Upgrade to a Git adapter implementation that implements the new
+  #   interface.
+  #
+  # A Git adapter adapter (yes an adapter for an adapter) that allows old-style
+  # Git adapter classes to be used.
+  class CompatibleGitAdapter
+    ##
+    # Creates a new instance of this adapter.
+    #
+    # @param [GitAdapter-like] adapter an old-style Git adapter instance to
+    #   wrap.
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    ##
+    # The path to the repository on which to operate.
+    attr_reader :repository_path
+
+    ##
+    # Sets the path to the repository on which to operate.
+    def repository_path=(path)
+      @repository_path = Pathname.new(path)
+    end
+
+    ##
+    # @return [Boolean] +true+ if the repository exists; otherwise, +false+.
+    def exist?
+      repository_path.exist?
+    end
+
+    ##
+    # Process the pack file exchange protocol.
+    #
+    # @param [String] pack_type the type of pack exchange to perform.
+    # @param [#read] io_in a readable, IO-like object providing client input
+    #   data.
+    # @param [#write] io_out a writable, IO-like object sending output data to
+    #   the client.
+    # @param [Hash] opts options to pass to the Git adapter's #handle_pack
+    #   method.
+    # @option opts [Boolean] :advertise_refs (false)
+    def handle_pack(pack_type, io_in, io_out, opts = {})
+      msg = ''
+      msg = io_in.read unless opts[:advertise_refs]
+
+      @adapter.send(
+        pack_type.sub(/^git-/, '').gsub('-', '_').to_sym,
+        repository_path.to_s,
+        opts.merge(:msg => msg)
+      ) do |result|
+        while chunk = result.read(8192) do
+          io_out.write(chunk)
+        end
+      end
+    end
+
+    ##
+    # Returns an object suitable for use as a Rack response body to provide the
+    # content of a file at _path_.
+    # 
+    # @param [Pathname] path the path to a file within the repository.
+    #
+    # @return [FileStreamer] a Rack response body that can stream the file
+    #   content at _path_.
+    # @return [nil] if _path_ does not exist.
+    def file(path)
+      full_path = @repository_path + path
+      return nil unless full_path.exist?
+      FileStreamer.new(full_path)
+    end
+
+    ##
+    # Triggers generation of data necessary to service Git Basic HTTP clients.
+    #
+    # @return [void]
+    def update_server_info
+      @adapter.update_server_info(repository_path.to_s)
+    end
+
+    ##
+    # @return [Boolean] +true+ if pushes should be allowed; otherwise; +false+.
+    def allow_push?
+      @adapter.get_config_setting('receivepack') == 'true'
+    end
+
+    ##
+    # @return [Boolean] +true+ if pulls should be allowed; otherwise; +false+.
+    def allow_pull?
+      @adapter.get_config_setting('uploadpack') != 'false'
+    end
+  end
+end

data/lib/grack/file_streamer.rb

@@ -0,0 +1,41 @@
+require 'pathname'
+
+require 'grack/io_streamer'
+
+module Grack
+  ##
+  # A Rack body implementation that streams a given file in chunks for a Rack
+  # response.
+  class FileStreamer < IOStreamer
+    ##
+    # Creates a new instance of this object.
+    #
+    # @param [Pathname, String] path a path to a file.
+    def initialize(path)
+      @path = Pathname.new(path).expand_path
+    end
+
+    ##
+    # In order to support X-Sendfile when available, this method returns the
+    # path to the file the web server would use to provide the content.
+    #
+    # @return [String] the path to the file.
+    def to_path
+      @path.to_s
+    end
+
+    ##
+    # The last modified time to report for the Rack response.
+    def mtime
+      @path.mtime
+    end
+
+    private
+
+    ##
+    # @yieldparam [#read] io the opened file.
+    def with_io(&b)
+      @path.open(&b)
+    end
+  end
+end

data/lib/grack/git_adapter.rb

@@ -0,0 +1,142 @@
+require 'pathname'
+
+require 'grack/file_streamer'
+
+module Grack
+  ##
+  # A wrapper for interacting with Git repositories using the git command line
+  # tool.
+  class GitAdapter
+    ##
+    # The number of bytes to read at a time from IO streams.
+    READ_SIZE = 32768
+
+    ##
+    # Creates a new instance of this adapter.
+    #
+    # @param [String] bin_path the path to use for the Git binary.
+    def initialize(bin_path = 'git')
+      @repository_path = nil
+      @git_path = bin_path
+    end
+
+    ##
+    # The path to the repository on which to operate.
+    attr_reader :repository_path
+
+    ##
+    # Sets the path to the repository on which to operate.
+    def repository_path=(path)
+      @repository_path = Pathname.new(path)
+    end
+
+    ##
+    # @return [Boolean] +true+ if the repository exists; otherwise, +false+.
+    def exist?
+      repository_path.exist?
+    end
+
+    ##
+    # Process the pack file exchange protocol.
+    #
+    # @param [String] pack_type the type of pack exchange to perform.
+    # @param [#read] io_in a readable, IO-like object providing client input
+    #   data.
+    # @param [#write] io_out a writable, IO-like object sending output data to
+    #   the client.
+    # @param [Hash] opts options to pass to the Git adapter's #handle_pack
+    #   method.
+    # @option opts [Boolean] :advertise_refs (false)
+    def handle_pack(pack_type, io_in, io_out, opts = {})
+      args = %w{--stateless-rpc}
+      if opts.fetch(:advertise_refs, false)
+        str = "# service=#{pack_type}\n"
+        io_out.write('%04x' % (str.size + 4))
+        io_out.write(str)
+        io_out.write('0000')
+        args << '--advertise-refs'
+      end
+      args << repository_path.to_s
+      command(pack_type.sub(/^git-/, ''), args, io_in, io_out)
+    end
+
+    ##
+    # Returns an object suitable for use as a Rack response body to provide the
+    # content of a file at _path_.
+    # 
+    # @param [Pathname] path the path to a file within the repository.
+    #
+    # @return [FileStreamer] a Rack response body that can stream the file
+    #   content at _path_.
+    # @return [nil] if _path_ does not exist.
+    def file(path)
+      full_path = @repository_path + path
+      return nil unless full_path.exist?
+      FileStreamer.new(full_path)
+    end
+
+    ##
+    # Triggers generation of data necessary to service Git Basic HTTP clients.
+    #
+    # @return [void]
+    def update_server_info
+      command('update-server-info', [], nil, nil, repository_path)
+    end
+
+    ##
+    # @return [Boolean] +true+ if pushes should be allowed; otherwise; +false+.
+    def allow_push?
+      config('http.receivepack') == 'true'
+    end
+
+    ##
+    # @return [Boolean] +true+ if pulls should be allowed; otherwise; +false+.
+    def allow_pull?
+      config('http.uploadpack') != 'false'
+    end
+
+
+    private
+
+    ##
+    # The path to use for running the git utility.
+    attr_reader :git_path
+
+    ##
+    # @param [String] key a key to look up in the Git repository configuration.
+    #
+    # @return [String] the value for the given key.
+    def config(key)
+      capture_io = StringIO.new
+      command('config', ['--local', key], nil, capture_io, repository_path.to_s)
+      capture_io.string.chomp
+    end
+
+    ##
+    # Runs the Git utilty with the given subcommand.
+    #
+    # @param [String] cmd the Git subcommand to invoke.
+    # @param [Array<String>] args additional arguments for the command.
+    # @param [#read, nil] io_in a readable, IO-like source of data to write to
+    #   the Git command.
+    # @param [#write, nil] io_out a writable, IO-like sink for output produced
+    #   by the Git command.
+    # @param [String, nil] dir a directory to switch to before invoking the Git
+    #   command.
+    def command(cmd, args, io_in, io_out, dir = nil)
+      cmd = [git_path, cmd] + args
+      opts = {:err => :close}
+      opts[:chdir] = dir unless dir.nil?
+      cmd << opts
+      IO.popen(cmd, 'r+b') do |pipe|
+        while ! io_in.nil? && chunk = io_in.read(READ_SIZE) do
+          pipe.write(chunk)
+        end
+        pipe.close_write
+        while chunk = pipe.read(READ_SIZE) do
+          io_out.write(chunk) unless io_out.nil?
+        end
+      end
+    end
+  end
+end

data/lib/grack/io_streamer.rb

@@ -0,0 +1,45 @@
+module Grack
+  ##
+  # A Rack body implementation that streams a given IO object in chunks for a
+  # Rack response.
+  class IOStreamer
+    ##
+    # The number of bytes to read at a time from IO streams.
+    READ_SIZE = 32768
+
+    ##
+    # Creates a new instance of this object.
+    #
+    # @param [#read] io a readable, IO-like object.
+    # @param [Time] mtime a timestamp to use for the last modified header in the
+    #   response.
+    def initialize(io, mtime)
+      @io = io
+      @mtime = mtime
+    end
+
+    ##
+    # The last modified time to report for the Rack response.
+    attr_reader :mtime
+
+    ##
+    # Iterates over the wrapped IO object in chunks, yielding each one.
+    #
+    # @yieldparam [String] chunk a chunk read from the wrapped IO object.
+    def each
+      with_io do |io|
+        while chunk = io.read(READ_SIZE) do
+          yield(chunk)
+        end
+      end
+    end
+
+    private
+
+    ##
+    # @yieldparam [#read] io the wrapped IO object.
+    def with_io
+      yield(@io)
+    end
+  end
+end

data/tests/app_test.rb

@@ -0,0 +1,534 @@
+require_relative 'test_helper'
+
+require 'digest/sha1'
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'mocha/setup'
+require 'pathname'
+require 'rack/test'
+require 'tempfile'
+require 'zlib'
+
+require 'grack/app'
+require 'grack/git_adapter'
+
+class AppTest < Minitest::Test
+  include Rack::Test::Methods
+  include Grack
+
+  def example_repo_urn
+    '/example_repo.git'
+  end
+
+  def app_config
+    {
+      :root => repositories_root,
+      :allow_pull => true,
+      :allow_push => true,
+      :git_adapter_factory => ->{ GitAdapter.new(git_path) }
+    }
+  end
+
+  def app
+    App.new(app_config)
+  end
+
+  def setup
+    init_example_repository
+  end
+
+  def teardown
+    remove_example_repository
+  end
+
+  def test_upload_pack_advertisement
+    get "#{example_repo_urn}/info/refs?service=git-upload-pack"
+    assert_equal 200, r.status
+    assert_equal 'application/x-git-upload-pack-advertisement', r.headers['Content-Type']
+    assert_equal '001e# service=git-upload-pack', r.body.split("\n").first
+    assert_match 'multi_ack_detailed', r.body
+  end
+
+  def test_no_access_upload_pack_advertisement
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.get "#{example_repo_urn}/info/refs?service=git-upload-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_no_access_wrong_content_type_up
+    post "#{example_repo_urn}/git-upload-pack"
+    assert_equal 403, r.status
+  end
+
+  def test_no_access_wrong_content_type_rp
+    post "#{example_repo_urn}/git-receive-pack"
+    assert_equal 403, r.status
+  end
+
+  def test_no_access_wrong_method_rcp
+    get "#{example_repo_urn}/git-upload-pack"
+    assert_equal 400, r.status
+    get "#{example_repo_urn}/git-upload-pack", {}, {'SERVER_PROTOCOL' => 'HTTP/1.1'}
+    assert_equal 405, r.status
+  end
+
+  def test_no_access_wrong_command_rcp
+    post "#{example_repo_urn}/git-upload-packfile"
+    assert_equal 404, r.status
+  end
+
+  def test_no_access_wrong_path_rcp
+    post "/example-wrong/git-upload-pack"
+    assert_equal 404, r.status
+  end
+
+  def test_upload_pack_rpc
+    IO.stubs(:popen).returns(MockProcess.new)
+
+    post(
+      "#{example_repo_urn}/git-upload-pack",
+      {},
+      {'CONTENT_TYPE' => 'application/x-git-upload-pack-request'}
+    )
+    assert_equal 200, r.status
+    assert_equal 'application/x-git-upload-pack-result', r.headers['Content-Type']
+  end
+
+  def test_no_access_upload_pack_rpc
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.post(
+      "#{example_repo_urn}/git-upload-pack",
+      {},
+      {'CONTENT_TYPE' => 'application/x-git-upload-pack-request'}
+    )
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_upload_pack_rpc_compressed
+    IO.stubs(:popen).returns(MockProcess.new)
+
+    content = StringIO.new
+    gz = Zlib::GzipWriter.new(content)
+    gz.write('foo')
+    gz.close
+
+    post(
+      "#{example_repo_urn}/git-upload-pack",
+      content.string,
+      {
+        'CONTENT_TYPE' => 'application/x-git-upload-pack-request',
+        'HTTP_CONTENT_ENCODING' => 'gzip',
+      }
+    )
+    assert_equal 200, r.status
+    assert_equal 'application/x-git-upload-pack-result',
+                 r.headers['Content-Type']
+  end
+
+  def test_receive_pack_advertisement
+    get "#{example_repo_urn}/info/refs?service=git-receive-pack"
+    assert_equal 200, r.status
+    assert_equal 'application/x-git-receive-pack-advertisement',
+                 r.headers['Content-Type']
+    assert_equal '001f# service=git-receive-pack', r.body.split("\n").first
+    assert_match 'report-status', r.body
+    assert_match 'delete-refs', r.body
+    assert_match 'ofs-delta', r.body
+  end
+
+  def test_no_access_receive_pack_advertisement
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_push => false))
+    )
+
+    session.get "#{example_repo_urn}/info/refs?service=git-receive-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_receive_pack_rpc
+    IO.stubs(:popen).returns(MockProcess.new)
+
+    post(
+      "#{example_repo_urn}/git-receive-pack",
+      {},
+      {'CONTENT_TYPE' => 'application/x-git-receive-pack-request'}
+    )
+    assert_equal 200, r.status
+    assert_equal 'application/x-git-receive-pack-result',
+                 r.headers['Content-Type']
+  end
+
+  def test_no_access_receive_pack_rpc
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_push => false))
+    )
+
+    session.post "#{example_repo_urn}/git-receive-pack",
+                 {},
+                 {'CONTENT_TYPE' => 'application/x-git-receive-pack-request'}
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_info_refs_dumb
+    get "#{example_repo_urn}/info/refs"
+    assert_equal 200, r.status
+  end
+
+  def test_no_access_info_refs_dumb
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.get "#{example_repo_urn}/info/refs"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_info_packs
+    get "#{example_repo_urn}/objects/info/packs"
+    assert_equal 200, r.status
+    assert_match /P pack-(.*?).pack/, r.body
+  end
+
+  def test_no_access_info_packs
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.get "#{example_repo_urn}/objects/info/packs"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_loose_objects
+    obj_path = 'objects/31/d73eb4914a8ddb6cb0e4adf250777161118f90'
+    obj_file = File.join(example_repo, obj_path)
+    content = File.open(obj_file, 'rb') { |f| f.read }
+
+    get "#{example_repo_urn}/#{obj_path}"
+    assert_equal 200, r.status
+    assert_equal content, r.body
+  end
+
+  def test_no_access_loose_objects
+    obj_path = 'objects/31/d73eb4914a8ddb6cb0e4adf250777161118f90'
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.get "#{example_repo_urn}/#{obj_path}"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_pack_file
+    pack_path =
+      'objects/pack/pack-62c9f443d8405cd6da92dcbb4f849cc01a339c06.pack'
+    pack_file = File.join(example_repo, pack_path)
+    content = File.open(pack_file, 'rb') { |f| f.read }
+
+    get "#{example_repo_urn}/#{pack_path}"
+    assert_equal 200, r.status
+    assert_equal content, r.body
+  end
+
+  def test_no_access_pack_file
+    pack_path =
+      'objects/pack/pack-62c9f443d8405cd6da92dcbb4f849cc01a339c06.pack'
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.get "#{example_repo_urn}/#{pack_path}"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_index_file
+    idx_path = 'objects/pack/pack-62c9f443d8405cd6da92dcbb4f849cc01a339c06.idx'
+    idx_file = File.join(example_repo, idx_path)
+    content = File.open(idx_file, 'rb') { |f| f.read }
+
+    get "#{example_repo_urn}/#{idx_path}"
+    assert_equal 200, r.status
+    assert_equal content, r.body
+  end
+
+  def test_no_access_index_file
+    idx_path = 'objects/pack/pack-62c9f443d8405cd6da92dcbb4f849cc01a339c06.idx'
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.get "#{example_repo_urn}/#{idx_path}"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_text_file
+    head_file = File.join(example_repo, 'HEAD')
+    content = File.open(head_file, 'rb') { |f| f.read }
+
+    get "#{example_repo_urn}/HEAD"
+    assert_equal 200, r.status
+    assert_equal content, r.body
+  end
+
+  def test_no_access_text_file
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge!(:allow_pull => false))
+    )
+
+    session.get "#{example_repo_urn}/HEAD"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_config_allow_pull_off
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge(:allow_pull => false))
+    )
+    session.get "#{example_repo_urn}/info/refs?service=git-upload-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_config_allow_push_off
+    session = Rack::Test::Session.new(
+      App.new(app_config.merge(:allow_push => false))
+    )
+    session.get "#{example_repo_urn}/info/refs?service=git-receive-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_config_bad_service
+    get "#{example_repo_urn}/info/refs?service=git-receive-packfile"
+    assert_equal 404, r.status
+  end
+
+  def test_git_adapter_forbid_push
+    GitAdapter.any_instance.stubs(:allow_push?).returns(false)
+
+    app = App.new({
+      :root => repositories_root
+    })
+    session = Rack::Test::Session.new(app)
+    session.get "#{example_repo_urn}/info/refs?service=git-receive-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_git_adapter_allow_push
+    GitAdapter.any_instance.stubs(:allow_push?).returns(true)
+
+    app = App.new(:root => repositories_root)
+    session = Rack::Test::Session.new(app)
+    session.get "#{example_repo_urn}/info/refs?service=git-receive-pack"
+    assert_equal 200, session.last_response.status
+  end
+
+  def test_git_adapter_forbid_pull
+    GitAdapter.any_instance.stubs(:allow_pull?).returns(false)
+
+    app = App.new(:root => repositories_root)
+    session = Rack::Test::Session.new(app)
+    session.get "#{example_repo_urn}/info/refs?service=git-upload-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_git_adapter_allow_pull
+    GitAdapter.any_instance.stubs(:allow_pull?).returns(true)
+
+    app = App.new(:root => repositories_root)
+    session = Rack::Test::Session.new(app)
+    session.get "#{example_repo_urn}/info/refs?service=git-upload-pack"
+    assert_equal 200, session.last_response.status
+  end
+
+  def test_reject_bad_uri
+    get '/../HEAD'
+    assert_equal 400, r.status
+    get "#{example_repo_urn}/../HEAD"
+    assert_equal 400, r.status
+    get '/./HEAD'
+    assert_equal 400, r.status
+    get "#{example_repo_urn}/./HEAD"
+    assert_equal 400, r.status
+
+    get '/%2e%2e/HEAD'
+    assert_equal 400, r.status
+    get "#{example_repo_urn}/%2e%2e/HEAD"
+    assert_equal 400, r.status
+    get '/%2e/HEAD'
+    assert_equal 400, r.status
+    get "#{example_repo_urn}/%2e/HEAD"
+    assert_equal 400, r.status
+  end
+
+  def test_not_found_in_empty_repo
+    empty_dir = repositories_root + 'empty-dir'
+    empty_dir.mkdir
+
+    example_repo_urn = '/empty-dir'
+
+    get "#{example_repo_urn}/info/refs"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/info/alternates"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/info/http-alternates"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/info/packs"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/objects/00/00000000000000000000000000000000000000"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/objects/packs/pack-0000000000000000000000000000000000000000.pack"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/objects/packs/pack-0000000000000000000000000000000000000000.idx"
+    assert_equal 404, r.status
+  ensure
+    empty_dir.rmdir if empty_dir.exist?
+  end
+
+  def test_not_found_in_nonexistent_repo
+    example_repo_urn = '/no-dir'
+
+    get "#{example_repo_urn}/info/refs"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/info/alternates"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/info/http-alternates"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/info/packs"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/objects/00/00000000000000000000000000000000000000"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/objects/packs/pack-0000000000000000000000000000000000000000.pack"
+    assert_equal 404, r.status
+    get "#{example_repo_urn}/objects/packs/pack-0000000000000000000000000000000000000000.idx"
+    assert_equal 404, r.status
+  end
+
+  def test_config_project_root_used_when_root_not_set
+    session = Rack::Test::Session.new(
+      App.new(:project_root => repositories_root)
+    )
+
+    session.get "#{example_repo_urn}/info/refs"
+    assert_equal 200, session.last_response.status
+  end
+
+  def test_config_project_root_ignored_when_root_is_set
+    session = Rack::Test::Session.new(
+      App.new(:project_root => 'unlikely/path', :root => repositories_root)
+    )
+
+    session.get "#{example_repo_urn}/info/refs"
+    assert_equal 200, session.last_response.status
+  end
+
+  def test_config_upload_pack_used_when_allow_pull_not_set
+    session = Rack::Test::Session.new(
+      App.new(:root => repositories_root, :upload_pack => false)
+    )
+
+    session.get "#{example_repo_urn}/info/refs?service=git-upload-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_config_upload_pack_ignored_when_allow_pull_is_set
+    session = Rack::Test::Session.new(
+      App.new(
+        :root => repositories_root, :upload_pack => true, :allow_pull => false
+      )
+    )
+
+    session.get "#{example_repo_urn}/info/refs?service=git-upload-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_config_receive_pack_used_when_allow_push_not_set
+    session = Rack::Test::Session.new(
+      App.new(:root => repositories_root, :receive_pack => false)
+    )
+
+    session.get "#{example_repo_urn}/info/refs?service=git-receive-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_config_receive_pack_ignored_when_allow_push_is_set
+    session = Rack::Test::Session.new(
+      App.new(
+        :root => repositories_root, :receive_pack => true, :allow_push => false
+      )
+    )
+
+    session.get "#{example_repo_urn}/info/refs?service=git-receive-pack"
+    assert_equal 403, session.last_response.status
+  end
+
+  def test_config_adapter_with_GitAdapter
+    session = Rack::Test::Session.new(
+      App.new(:root => repositories_root, :adapter => GitAdapter)
+    )
+
+    session.get "#{example_repo_urn}/objects/info/packs"
+    assert_equal 200, session.last_response.status
+    assert_match /P pack-(.*?).pack/, session.last_response.body
+  end
+
+  def test_config_adapter_with_custom_adapter
+    git_adapter = mock('git_adapter')
+    git_adapter.
+      expects(:update_server_info).
+      with("#{repositories_root}#{example_repo_urn}")
+    git_adapter_class = mock('git_adapter_class')
+    git_adapter_class.expects(:new).with.returns(git_adapter)
+    session = Rack::Test::Session.new(
+      App.new(
+        :root => repositories_root,
+        :allow_pull => true,
+        :adapter => git_adapter_class
+      )
+    )
+
+    session.get "#{example_repo_urn}/info/refs"
+    assert_equal 200, session.last_response.status
+  end
+
+  def test_config_adapter_ignored_when_adapter_factory_is_set
+    git_adapter_class = mock('git_adapter_class')
+    session = Rack::Test::Session.new(
+      App.new(
+        :root => repositories_root,
+        :adapter => git_adapter_class,
+        :git_adapter_factory => ->{ GitAdapter.new(git_path) }
+      )
+    )
+
+    session.get "#{example_repo_urn}/info/refs"
+    assert_equal 200, session.last_response.status
+  end
+
+  private
+
+  def r
+    last_response
+  end
+
+end
+
+class MockProcess
+
+  def initialize
+    @counter = 0
+  end
+
+  def close_write
+  end
+
+  def write(data)
+  end
+
+  def read(length = nil, buffer = nil)
+    nil
+  end
+
+end