Merge ~pappacena/turnip:enable-http-v2 into turnip:master

[Thiago F. Pappacena]

Enabling protocol v2 compatibility on HTTP frontend

6bd0254... by Thiago F. Pappacena on 2020-08-13

Cleaning up tests

Unmerged commits

6bd0254... by Thiago F. Pappacena on 2020-08-13

Cleaning up tests

diff --git a/turnip/pack/git.py b/turnip/pack/git.py
index 1b34ac0..85fa57e 100644
--- a/turnip/pack/git.py
+++ b/turnip/pack/git.py
@@ -31,14 +31,11 @@ from turnip.config import config
 from turnip.helpers import compose_path
 from turnip.pack.helpers import (
     decode_packet,
-    DELIM_PKT,
     decode_request,
     encode_packet,
     encode_request,
     ensure_config,
     ensure_hooks,
-    FLUSH_PKT,
-    get_capabilities_advertisement,
     INCOMPLETE_PKT,
     translate_xmlrpc_fault,
     )
@@ -242,20 +239,15 @@ class GitProcessProtocol(protocol.ProcessProtocol):
 
     _err_buffer = b''
 
-    def __init__(self, peer, cmd_input=None):
+    def __init__(self, peer):
         self.peer = peer
-        self.cmd_input = cmd_input
         self.out_started = False
 
     def connectionMade(self):
         self.peer.setPeer(self)
         self.peer.transport.registerProducer(self, True)
-        if not self.cmd_input:
-            self.transport.registerProducer(
-                UnstoppableProducerWrapper(self.peer.transport), True)
-        else:
-            self.transport.write(self.cmd_input)
-            self.loseWriteConnection()
+        self.transport.registerProducer(
+            UnstoppableProducerWrapper(self.peer.transport), True)
         self.peer.resumeProducing()
 
     def outReceived(self, data):
@@ -440,29 +432,12 @@ class PackBackendProtocol(PackServerProtocol):
     hookrpc_key = None
     expect_set_symbolic_ref = False
 
-    def getV2CommandInput(self, params):
-        """Reconstruct what should be sent to git's stdin from the
-        parameters received."""
-        cmd_input = encode_packet(b"command=%s\n" % params.get(b'command'))
-        for capability in params["capabilities"].split(b"\n"):
-            cmd_input += encode_packet(b"%s\n" % capability)
-        cmd_input += DELIM_PKT
-        ignore_keys = (b'capabilities', b'version')
-        for k, v in params.items():
-            k = six.ensure_binary(k)
-            if k.startswith(b"turnip-") or k in ignore_keys:
-                continue
-            for param_value in v.split(b'\n'):
-                value = (b"" if not param_value else b" %s" % param_value)
-                cmd_input += encode_packet(b"%s%s\n" % (k, value))
-        cmd_input += FLUSH_PKT
-        return cmd_input
-
     @defer.inlineCallbacks
     def requestReceived(self, command, raw_pathname, params):
         self.extractRequestMeta(command, raw_pathname, params)
         self.command = command
         self.raw_pathname = raw_pathname
+        self.params = params
         self.path = compose_path(self.factory.root, self.raw_pathname)
         auth_params = self.createAuthParams(params)
 
@@ -482,31 +457,20 @@ class PackBackendProtocol(PackServerProtocol):
             self.resumeProducing()
             return
 
-        send_path_as_option = False
-        cmd_input = None
         cmd_env = {}
         write_operation = False
-        if not get_capabilities_advertisement(params.get(b'version', 1)):
-            if command == b'git-upload-pack':
-                subcmd = b'upload-pack'
-            elif command == b'git-receive-pack':
-                subcmd = b'receive-pack'
-                write_operation = True
-            else:
-                self.die(b'Unsupported command in request')
-                return
-        else:
-            v2_command = params.get(b'command')
-            if command == b'git-upload-pack' and not v2_command:
-                self.expectNextCommand()
-                self.transport.loseConnection()
-                return
-            subcmd = b'upload-pack'
-            cmd_env["GIT_PROTOCOL"] = 'version=2'
-            send_path_as_option = True
-            # Do not include "advertise-refs" parameter.
+        version = self.params.get(b'version', 0)
+        cmd_env["GIT_PROTOCOL"] = 'version=%s' % version
+        if version == b'2':
             params.pop(b'turnip-advertise-refs', None)
-            cmd_input = self.getV2CommandInput(params)
+        if command == b'git-upload-pack':
+            subcmd = b'upload-pack'
+        elif command == b'git-receive-pack':
+            subcmd = b'receive-pack'
+            write_operation = True
+        else:
+            self.die(b'Unsupported command in request')
+            return
 
         args = []
         if params.pop(b'turnip-stateless-rpc', None):
@@ -516,14 +480,12 @@ class PackBackendProtocol(PackServerProtocol):
         args.append(self.path)
         self.spawnGit(
             subcmd, args,
-            write_operation=write_operation,
-            auth_params=auth_params,
-            send_path_as_option=send_path_as_option,
-            cmd_env=cmd_env, cmd_input=cmd_input)
+            write_operation=write_operation, auth_params=auth_params,
+            cmd_env=cmd_env)
 
     def spawnGit(self, subcmd, extra_args, write_operation=False,
                  send_path_as_option=False, auth_params=None,
-                 cmd_env=None, cmd_input=None):
+                 cmd_env=None):
         cmd = b'git'
         args = [b'git']
         if send_path_as_option:
@@ -545,7 +507,7 @@ class PackBackendProtocol(PackServerProtocol):
             env[b'TURNIP_HOOK_RPC_KEY'] = self.hookrpc_key
 
         self.log.info('Spawning {args}', args=args)
-        self.peer = GitProcessProtocol(self, cmd_input)
+        self.peer = GitProcessProtocol(self)
         self.spawnProcess(cmd, args, env=env)
 
     def spawnProcess(self, cmd, args, env=None):
@@ -674,7 +636,7 @@ class PackVirtServerProtocol(PackProxyServerProtocol):
     @defer.inlineCallbacks
     def requestReceived(self, command, pathname, params):
         self.extractRequestMeta(command, pathname, params)
-        permission = 'read' if command == b'git-upload-pack' else 'write'
+        permission = 'read' if command != b'git-receive-pack' else 'write'
         proxy = xmlrpc.Proxy(self.factory.virtinfo_endpoint, allowNone=True)
         try:
             auth_params = self.createAuthParams(params)
diff --git a/turnip/pack/helpers.py b/turnip/pack/helpers.py
index 93aba33..5d78d68 100644
--- a/turnip/pack/helpers.py
+++ b/turnip/pack/helpers.py
@@ -24,10 +24,10 @@ import six
 import yaml
 
 import turnip.pack.hooks
-
+from turnip.version_info import version_info
 
 FLUSH_PKT = b'0000'
-DELIM_PKT = b'0001'
+DELIM_PKT = object()
 PKT_LEN_SIZE = 4
 PKT_PAYLOAD_MAX = 65520
 INCOMPLETE_PKT = object()
@@ -37,6 +37,8 @@ def encode_packet(payload):
     if payload is None:
         # flush-pkt.
         return FLUSH_PKT
+    if payload is DELIM_PKT:
+        return b'0001'
     else:
         # data-pkt
         if len(payload) > PKT_PAYLOAD_MAX:
@@ -48,63 +50,25 @@ def encode_packet(payload):
 
 def decode_packet(input):
     """Consume a packet, returning the payload and any unconsumed tail."""
+    if input.startswith(b'0001'):
+        return (DELIM_PKT, input[PKT_LEN_SIZE:])
     if len(input) < PKT_LEN_SIZE:
         return (INCOMPLETE_PKT, input)
     if input.startswith(FLUSH_PKT):
         # flush-pkt
         return (None, input[PKT_LEN_SIZE:])
-    # data-pkt
-    try:
-        pkt_len = int(input[:PKT_LEN_SIZE], 16)
-    except ValueError:
-        pkt_len = 0
-    if not (PKT_LEN_SIZE <= pkt_len <= (PKT_LEN_SIZE + PKT_PAYLOAD_MAX)):
-        raise ValueError("Invalid pkt-len")
-    if len(input) < pkt_len:
-        # Some of the packet is yet to be received.
-        return (INCOMPLETE_PKT, input)
-    # v2 protocol "hides" extra parameters after the end of the packet.
-    if len(input) > pkt_len and b'version=2\x00' in input:
-        if FLUSH_PKT not in input:
-            return INCOMPLETE_PKT, input
-        end = input.index(FLUSH_PKT)
-        return input[PKT_LEN_SIZE:end], input[end + len(FLUSH_PKT):]
-    return (input[PKT_LEN_SIZE:pkt_len], input[pkt_len:])
-
-
-def decode_packet_list(data):
-    remaining = data
-    retval = []
-    while remaining:
-        pkt, remaining = decode_packet(remaining)
-        retval.append(pkt)
-    return retval
-
-
-def decode_protocol_v2_params(data):
-    """Parse the protocol v2 extra parameters hidden behind the end of v1
-    protocol.
-
-    :return: An ordered dict with parsed v2 parameters.
-    """
-    params = OrderedDict()
-    cmd, remaining = decode_packet(data)
-    cmd = cmd.split(b'=', 1)[-1].strip()
-    capabilities, args = remaining.split(DELIM_PKT)
-    params[b"command"] = cmd
-    params[b"capabilities"] = decode_packet_list(capabilities)
-    for arg in decode_packet_list(args):
-        if arg is None:
-            continue
-        arg = arg.strip('\n')
-        if b' ' in arg:
-            k, v = arg.split(b' ', 1)
-            if k not in params:
-                params[k] = []
-            params[k].append(v)
-        else:
-            params[arg] = b""
-    return params
+    else:
+        # data-pkt
+        try:
+            pkt_len = int(input[:PKT_LEN_SIZE], 16)
+        except ValueError:
+            pkt_len = 0
+        if not (PKT_LEN_SIZE <= pkt_len <= (PKT_LEN_SIZE + PKT_PAYLOAD_MAX)):
+            raise ValueError("Invalid pkt-len")
+        if len(input) < pkt_len:
+            # Some of the packet is yet to be received.
+            return (INCOMPLETE_PKT, input)
+        return (input[PKT_LEN_SIZE:pkt_len], input[pkt_len:])
 
 
 def decode_request(data):
@@ -121,7 +85,7 @@ def decode_request(data):
     # Following the command is a pathname, then any number of named
     # parameters. Each of these is NUL-terminated.
     # After that, v1 should end (v2 might have extra commands).
-    if len(bits) < 2 or (b'version=2' not in bits and bits[-1] != b''):
+    if len(bits) < 2 or bits[-1] != b'':
         raise ValueError('Invalid git-proto-request')
     pathname = bits[0]
     params = OrderedDict()
@@ -139,12 +103,6 @@ def decode_request(data):
             raise ValueError('Parameters must not be repeated')
         params[name] = value
 
-    # If there are remaining bits at the end, we must be dealing with v2
-    # protocol. So, we append v2 parameters at the end of original parameters.
-    if bits[-1]:
-        for k, v in decode_protocol_v2_params(bits[-1]).items():
-            params[k] = v
-
     return command, pathname, params
 
 
@@ -297,5 +255,14 @@ def get_capabilities_advertisement(version='1'):
 
     If no binary data is sent, no advertisement is done and we declare to
     not be compatible with that specific version."""
-    # XXX pappacena 2020-08-11: Return the correct data for protocol v2.
-    return b""
+    if version != '2':
+        return b""
+    turnip_version = six.ensure_binary(version_info.get("revision_id", '-1'))
+    return (
+        encode_packet(b"version 2\n") +
+        encode_packet(b"agent=turnip/%s\n" % turnip_version) +
+        encode_packet(b"ls-refs\n") +
+        encode_packet(b"fetch=shallow\n") +
+        encode_packet(b"server-option\n") +
+        FLUSH_PKT
+    )
diff --git a/turnip/pack/http.py b/turnip/pack/http.py
index c0becf0..9e0661c 100644
--- a/turnip/pack/http.py
+++ b/turnip/pack/http.py
@@ -29,6 +29,7 @@ from paste.auth.cookie import (
     decode as decode_cookie,
     encode as encode_cookie,
     )
+import six
 from twisted.internet import (
     defer,
     error,
@@ -58,8 +59,8 @@ from turnip.pack.helpers import (
     encode_packet,
     encode_request,
     translate_xmlrpc_fault,
-    TurnipFaultCode,
-    )
+    TurnipFaultCode, get_capabilities_advertisement,
+)
 try:
     from turnip.version_info import version_info
 except ImportError:
@@ -80,6 +81,16 @@ def fail_request(request, message, code=http.INTERNAL_SERVER_ERROR):
     return b''
 
 
+def get_protocol_version_from_request(request):
+    version_header = request.requestHeaders.getRawHeaders(
+        'git-protocol', ['version=1'])[0]
+    try:
+        return version_header.split('version=', 1)[1]
+    except IndexError:
+        pass
+    return 1
+
+
 class HTTPPackClientProtocol(PackProtocol):
     """Abstract bridge between a Git pack connection and a smart HTTP request.
 
@@ -99,7 +110,11 @@ class HTTPPackClientProtocol(PackProtocol):
 
     def startGoodResponse(self):
         """Prepare the HTTP response for forwarding from the backend."""
-        raise NotImplementedError()
+        self.factory.http_request.write(
+            get_capabilities_advertisement(self.getProtocolVersion()))
+
+    def getProtocolVersion(self):
+        return get_protocol_version_from_request(self.factory.http_request)
 
     def backendConnected(self):
         """Called when the backend is connected and has sent a good packet."""
@@ -209,6 +224,7 @@ class HTTPPackClientRefsProtocol(HTTPPackClientProtocol):
         self.factory.http_request.setHeader(
             b'Content-Type',
             b'application/x-%s-advertisement' % self.factory.command)
+        super(HTTPPackClientRefsProtocol, self).startGoodResponse()
 
     def backendConnected(self):
         HTTPPackClientProtocol.backendConnected(self)
@@ -221,10 +237,11 @@ class HTTPPackClientCommandProtocol(HTTPPackClientProtocol):
 
     def startGoodResponse(self):
         """Prepare the HTTP response for forwarding from the backend."""
-        self.factory.http_request.setResponseCode(http.OK)
-        self.factory.http_request.setHeader(
-            b'Content-Type',
-            b'application/x-%s-result' % self.factory.command)
+        if self.getProtocolVersion() != b'2':
+            self.factory.http_request.setResponseCode(http.OK)
+            self.factory.http_request.setHeader(
+                b'Content-Type',
+                b'application/x-%s-result' % self.factory.command)
 
 
 class HTTPPackClientFactory(protocol.ClientFactory):
@@ -280,8 +297,11 @@ class BaseSmartHTTPResource(resource.Resource):
         by the virt service, if any.
         """
         params = {
+            b'turnip-frontend': b'http',
             b'turnip-can-authenticate': b'yes',
             b'turnip-request-id': str(uuid.uuid4()),
+            b'version': six.ensure_binary(
+                get_protocol_version_from_request(request))
             }
         authenticated_params = yield self.authenticateUser(request)
         for key, value in authenticated_params.items():
diff --git a/turnip/pack/tests/test_functional.py b/turnip/pack/tests/test_functional.py
index 27bc26e..c811b2a 100644
--- a/turnip/pack/tests/test_functional.py
+++ b/turnip/pack/tests/test_functional.py
@@ -815,16 +815,19 @@ class TestSmartHTTPFrontendWithAuthFunctional(TestSmartHTTPFrontendFunctional):
         test_root = self.useFixture(TempDir()).path
         clone = os.path.join(test_root, 'clone')
         yield self.assertCommandSuccess((b'git', b'clone', self.ro_url, clone))
+        expected_requests = 1 if self.protocol_version == '1' else 2
         self.assertEqual(
-            [(b'test-user', b'test-password')], self.virtinfo.authentications)
-        self.assertThat(self.virtinfo.translations, MatchesListwise([
-            MatchesListwise([
+            [(b'test-user', b'test-password')] * expected_requests,
+            self.virtinfo.authentications)
+        self.assertEqual(expected_requests, len(self.virtinfo.translations))
+        for translation in self.virtinfo.translations:
+            self.assertThat(translation, MatchesListwise([
                 Equals(b'/test'), Equals(b'read'),
                 MatchesDict({
                     b'can-authenticate': Is(True),
                     b'request-id': Not(Is(None)),
-                    b'user': Equals(b'test-user'),
-                    })])]))
+                    b'user': Equals(b'test-user')})
+                ]))
 
     @defer.inlineCallbacks
     def test_authenticated_push(self):
diff --git a/turnip/pack/tests/test_git.py b/turnip/pack/tests/test_git.py
index b69049c..d1a8162 100644
--- a/turnip/pack/tests/test_git.py
+++ b/turnip/pack/tests/test_git.py
@@ -9,7 +9,6 @@ from __future__ import (
 
 import hashlib
 import os.path
-from collections import OrderedDict
 
 from fixtures import TempDir, MonkeyPatch
 from pygit2 import init_repository
@@ -35,7 +34,6 @@ from turnip.pack import (
     git,
     helpers,
     )
-from turnip.pack.git import GitProcessProtocol
 from turnip.pack.tests.fake_servers import FakeVirtInfoService
 from turnip.pack.tests.test_hooks import MockHookRPCHandler
 from turnip.tests.compat import mock
@@ -51,18 +49,6 @@ class DummyPackServerProtocol(git.PackServerProtocol):
         self.test_request = (command, pathname, host)
 
 
-class TestGitProcessProtocol(TestCase):
-    def test_can_write_to_stdin_directly(self):
-        peer = mock.Mock()
-        transport = mock.Mock()
-        protocol = GitProcessProtocol(peer, b"this is the stdin")
-        protocol.transport = transport
-        protocol.connectionMade()
-        self.assertEqual(
-            [mock.call(b'this is the stdin', )],
-            transport.write.call_args_list)
-
-
 class TestPackServerProtocol(TestCase):
     """Test the base implementation of the git pack network protocol."""
 
@@ -243,8 +229,9 @@ class TestPackBackendProtocol(TestCase):
             [('foo.git', )], self.virtinfo.confirm_repo_creation_call_args)
 
         self.assertEqual(
-            (b'git', [b'git', b'upload-pack', full_path], {}),
-            self.proto.test_process)
+            (b'git', [b'git', b'upload-pack', full_path], {
+                'GIT_PROTOCOL': 'version=0'
+            }), self.proto.test_process)
 
     @defer.inlineCallbacks
     def test_create_repo_fails_to_confirm(self):
@@ -281,47 +268,8 @@ class TestPackBackendProtocol(TestCase):
         self.assertEqual(
             (b'git',
              [b'git', b'upload-pack', full_path],
-             {}),
-            self.proto.test_process)
-
-    def test_git_upload_pack_v2_calls_spawnProcess(self):
-        # If the command is git-upload-pack using v2 protocol, requestReceived
-        # calls spawnProcess with appropriate arguments.
-        advertise_capabilities = mock.Mock()
-        self.useFixture(
-            MonkeyPatch("turnip.pack.git.get_capabilities_advertisement",
-                        advertise_capabilities))
-        advertise_capabilities.return_value = b'fake capability'
-
-        self.proto.requestReceived(
-            b'git-upload-pack', b'/foo.git', OrderedDict([
-                (b'turnip-x', b'yes'),
-                (b'turnip-request-id', b'123'),
-                (b'version', b'2'),
-                (b'command', b'ls-refs'),
-                (b'capabilities', b'agent=git/2.25.1'),
-                (b'peel', b''),
-                (b'symrefs', b''),
-                (b'ref-prefix', b'HEAD\nrefs/heads/\nrefs/tags/')
-                ]))
-        full_path = os.path.join(six.ensure_binary(self.root), b'foo.git')
-        self.assertEqual(
-            (b'git',
-             [b'git', b'-C', full_path, b'upload-pack', full_path],
-             {'GIT_PROTOCOL': 'version=2'}),
+             {'GIT_PROTOCOL': 'version=0'}),
             self.proto.test_process)
-        stdin_content = (
-            b'0014command=ls-refs\n'
-            b'0015agent=git/2.25.1\n'
-            b'00010014command ls-refs\n'
-            b'0009peel\n'
-            b'000csymrefs\n'
-            b'0014ref-prefix HEAD\n'
-            b'001bref-prefix refs/heads/\n'
-            b'001aref-prefix refs/tags/\n'
-            b'0000'
-        )
-        self.assertEqual(stdin_content, self.proto.peer.cmd_input)
 
     def test_git_receive_pack_calls_spawnProcess(self):
         # If the command is git-receive-pack, requestReceived calls
diff --git a/turnip/pack/tests/test_helpers.py b/turnip/pack/tests/test_helpers.py
index bad7117..a5ba913 100644
--- a/turnip/pack/tests/test_helpers.py
+++ b/turnip/pack/tests/test_helpers.py
@@ -7,25 +7,32 @@ from __future__ import (
     unicode_literals,
     )
 
+from collections import OrderedDict
 import os.path
 import re
-from collections import OrderedDict
-
-import stat
-import sys
-from textwrap import dedent
-import time
+import shutil
+import subprocess
+import tempfile
 
 from fixtures import TempDir
 from pygit2 import (
     Config,
     init_repository,
     )
+import six
+import stat
+import sys
 from testtools import TestCase
+from textwrap import dedent
+import time
 
 from turnip.pack import helpers
 import turnip.pack.hooks
-from turnip.pack.helpers import FLUSH_PKT
+from turnip.pack.helpers import (
+    get_capabilities_advertisement,
+    encode_packet,
+    )
+from turnip.version_info import version_info
 
 TEST_DATA = b'0123456789abcdef'
 TEST_PKT = b'00140123456789abcdef'
@@ -175,27 +182,6 @@ class TestDecodeRequest(TestCase):
             b'git-do-stuff /foo\0host=foo\0host=bar\0',
             b'Parameters must not be repeated')
 
-    def test_v2_extra_commands(self):
-        data = (
-            b"git-upload-pack b306d" +
-            b"\x00turnip-x=yes\x00turnip-request-id=123\x00" +
-            b"version=2\x000014command=ls-refs\n0014agent=git/2.25.1" +
-            b'00010009peel\n000csymrefs\n0014ref-prefix HEAD\n' +
-            b'001bref-prefix refs/heads/\n'
-            b'001aref-prefix refs/tags/\n0000' +
-            FLUSH_PKT)
-        decoded = helpers.decode_request(data)
-        self.assertEqual((b'git-upload-pack', b'b306d', OrderedDict([
-            (b'turnip-x', b'yes'),
-            (b'turnip-request-id', b'123'),
-            (b'version', b'2'),
-            (b'command', b'ls-refs'),
-            (b'capabilities', [b'agent=git/2.25.1']),
-            (b'peel', b''),
-            (b'symrefs', b''),
-            (b'ref-prefix', [b'HEAD', b'refs/heads/', b'refs/tags/'])
-            ])), decoded)
-
 
 class TestEncodeRequest(TestCase):
     """Test git-proto-request encoding."""
@@ -344,3 +330,30 @@ class TestEnsureHooks(TestCase):
                 self.assertEqual(expected_bytes, actual.read())
         # The hook is executable.
         self.assertTrue(os.stat(self.hook('hook.py')).st_mode & stat.S_IXUSR)
+
+
+class TestCapabilityAdvertisement(TestCase):
+    def test_returning_same_output_as_git_command(self):
+        """Make sure that our hard-coded feature advertisement matches what
+        our git command advertises."""
+        root = tempfile.mkdtemp(prefix=b'turnip-test-root-')
+        self.addCleanup(shutil.rmtree, root, ignore_errors=True)
+        # Create a dummy repository
+        subprocess.call(['git', 'init', root])
+
+        git_version = subprocess.check_output(['git', '--version'])
+        git_version_num = six.ensure_binary(git_version.split(' ')[-1].strip())
+        git_agent = encode_packet(b"agent=git/%s\n" % git_version_num)
+
+        proc = subprocess.Popen(
+            ['git', 'upload-pack', root], env={"GIT_PROTOCOL": "version=2"},
+            stdout=subprocess.PIPE, stdin=subprocess.PIPE)
+        git_advertised_capabilities, _ = proc.communicate()
+
+        turnip_capabilities = get_capabilities_advertisement(version=b'2')
+        turnip_agent = encode_packet(
+            b"agent=turnip/%s\n" % version_info["revision_id"])
+
+        self.assertEqual(
+            turnip_capabilities,
+            git_advertised_capabilities.replace(git_agent, turnip_agent))
diff --git a/turnip/pack/tests/test_http.py b/turnip/pack/tests/test_http.py
index 26e2754..9c547c1 100644
--- a/turnip/pack/tests/test_http.py
+++ b/turnip/pack/tests/test_http.py
@@ -24,7 +24,10 @@ from turnip.pack import (
     helpers,
     http,
     )
+from turnip.pack.helpers import encode_packet
 from turnip.pack.tests.fake_servers import FakeVirtInfoService
+from turnip.tests.compat import mock
+from turnip.version_info import version_info
 
 
 class LessDummyRequest(requesthelper.DummyRequest):
@@ -74,12 +77,14 @@ class FakeRoot(object):
 
     def __init__(self):
         self.backend_transport = None
+        self.client_factory = None
         self.backend_connected = defer.Deferred()
 
     def authenticateWithPassword(self, user, password):
         return {}
 
     def connectToBackend(self, client_factory):
+        self.client_factory = client_factory
         self.backend_transport = testing.StringTransportWithDisconnection()
         p = client_factory.buildProtocol(None)
         self.backend_transport.protocol = p
@@ -186,6 +191,37 @@ class TestSmartHTTPRefsResource(ErrorTestMixin, TestCase):
             'And I am raw, since we got a good packet to start with.',
             self.request.value)
 
+    @defer.inlineCallbacks
+    def test_good_v2_included_version_and_capabilities(self):
+        self.request.requestHeaders.addRawHeader("Git-Protocol", "version=2")
+        yield self.performRequest(
+            helpers.encode_packet(b'I am git protocol data.') +
+            b'And I am raw, since we got a good packet to start with.')
+        self.assertEqual(200, self.request.responseCode)
+        self.assertEqual(self.root.client_factory.params, {
+            'version': '2',
+            'turnip-frontend': 'http',
+            'turnip-advertise-refs': 'yes',
+            'turnip-can-authenticate': 'yes',
+            'turnip-request-id': mock.ANY,
+            'turnip-stateless-rpc': 'yes'})
+
+        ver = version_info["revision_id"]
+        capabilities = (
+            encode_packet(b'version 2\n') +
+            encode_packet(b'agent=turnip/%s\n' % ver) +
+            encode_packet(b'ls-refs\n') +
+            encode_packet(b'fetch=shallow\n') +
+            encode_packet(b'server-option\n') +
+            b'0000'
+            )
+        self.assertEqual(
+            capabilities +
+            '001e# service=git-upload-pack\n'
+            '0000001bI am git protocol data.'
+            'And I am raw, since we got a good packet to start with.',
+            self.request.value)
+
 
 class TestSmartHTTPCommandResource(ErrorTestMixin, TestCase):