# test_web.py -- Compatibility tests for the git web server.
# Copyright (C) 2010 Google, Inc.
#
# Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
# General Public License as public by the Free Software Foundation; version 2.0
# or (at your option) any later version. You can redistribute it and/or
# modify it under the terms of either of these two licenses.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# You should have received a copy of the licenses; if not, see
# for a copy of the GNU General Public License
# and for a copy of the Apache
# License, Version 2.0.
#
"""Compatibility tests between Dulwich and the cgit HTTP server.
warning: these tests should be fairly stable, but when writing/debugging new
tests, deadlocks may freeze the test process such that it cannot be
Ctrl-C'ed. On POSIX systems, you can kill the tests with Ctrl-Z, "kill %".
"""
import sys
import threading
from typing import Tuple
from wsgiref import simple_server
from dulwich.server import DictBackend, ReceivePackHandler, UploadPackHandler
from dulwich.web import (
HTTPGitApplication,
WSGIRequestHandlerLogger,
WSGIServerLogger,
make_wsgi_chain,
)
from .. import SkipTest, skipIf
from .server_utils import NoSideBand64kReceivePackHandler, ServerTests
from .utils import CompatTestCase
@skipIf(sys.platform == "win32", "Broken on windows, with very long fail time.")
class WebTests(ServerTests):
"""Base tests for web server tests.
Contains utility and setUp/tearDown methods, but does non inherit from
TestCase so tests are not automatically run.
"""
protocol = "http"
def _start_server(self, repo):
backend = DictBackend({"/": repo})
app = self._make_app(backend)
dul_server = simple_server.make_server(
"localhost",
0,
app,
server_class=WSGIServerLogger,
handler_class=WSGIRequestHandlerLogger,
)
self.addCleanup(dul_server.shutdown)
self.addCleanup(dul_server.server_close)
threading.Thread(target=dul_server.serve_forever).start()
self._server = dul_server
_, port = dul_server.socket.getsockname()
return port
@skipIf(sys.platform == "win32", "Broken on windows, with very long fail time.")
class SmartWebTestCase(WebTests, CompatTestCase):
"""Test cases for smart HTTP server.
This server test case does not use side-band-64k in git-receive-pack.
"""
min_git_version: Tuple[int, ...] = (1, 6, 6)
def _handlers(self):
return {b"git-receive-pack": NoSideBand64kReceivePackHandler}
def _check_app(self, app):
receive_pack_handler_cls = app.handlers[b"git-receive-pack"]
caps = receive_pack_handler_cls.capabilities()
self.assertNotIn(b"side-band-64k", caps)
def _make_app(self, backend):
app = make_wsgi_chain(backend, handlers=self._handlers())
to_check = app
# peel back layers until we're at the base application
while not issubclass(to_check.__class__, HTTPGitApplication):
to_check = to_check.app
self._check_app(to_check)
return app
def patch_capabilities(handler, caps_removed):
# Patch a handler's capabilities by specifying a list of them to be
# removed, and return the original classmethod for restoration.
original_capabilities = handler.capabilities
filtered_capabilities = [
i for i in original_capabilities() if i not in caps_removed
]
def capabilities(cls):
return filtered_capabilities
handler.capabilities = classmethod(capabilities)
return original_capabilities
@skipIf(sys.platform == "win32", "Broken on windows, with very long fail time.")
class SmartWebSideBand64kTestCase(SmartWebTestCase):
"""Test cases for smart HTTP server with side-band-64k support."""
# side-band-64k in git-receive-pack was introduced in git 1.7.0.2
min_git_version = (1, 7, 0, 2)
def setUp(self):
self.o_uph_cap = patch_capabilities(UploadPackHandler, (b"no-done",))
self.o_rph_cap = patch_capabilities(ReceivePackHandler, (b"no-done",))
super().setUp()
def tearDown(self):
super().tearDown()
UploadPackHandler.capabilities = self.o_uph_cap
ReceivePackHandler.capabilities = self.o_rph_cap
def _handlers(self):
return None # default handlers include side-band-64k
def _check_app(self, app):
receive_pack_handler_cls = app.handlers[b"git-receive-pack"]
caps = receive_pack_handler_cls.capabilities()
self.assertIn(b"side-band-64k", caps)
self.assertNotIn(b"no-done", caps)
class SmartWebSideBand64kNoDoneTestCase(SmartWebTestCase):
"""Test cases for smart HTTP server with side-band-64k and no-done
support.
"""
# no-done was introduced in git 1.7.4
min_git_version = (1, 7, 4)
def _handlers(self):
return None # default handlers include side-band-64k
def _check_app(self, app):
receive_pack_handler_cls = app.handlers[b"git-receive-pack"]
caps = receive_pack_handler_cls.capabilities()
self.assertIn(b"side-band-64k", caps)
self.assertIn(b"no-done", caps)
@skipIf(sys.platform == "win32", "Broken on windows, with very long fail time.")
class DumbWebTestCase(WebTests, CompatTestCase):
"""Test cases for dumb HTTP server."""
def _make_app(self, backend):
return make_wsgi_chain(backend, dumb=True)
def test_push_to_dulwich(self):
# Note: remove this if dulwich implements dumb web pushing.
raise SkipTest("Dumb web pushing not supported.")
def test_push_to_dulwich_remove_branch(self):
# Note: remove this if dumb pushing is supported
raise SkipTest("Dumb web pushing not supported.")
def test_new_shallow_clone_from_dulwich(self):
# Note: remove this if C git and dulwich implement dumb web shallow
# clones.
raise SkipTest("Dumb web shallow cloning not supported.")
def test_shallow_clone_from_git_is_identical(self):
# Note: remove this if C git and dulwich implement dumb web shallow
# clones.
raise SkipTest("Dumb web shallow cloning not supported.")
def test_fetch_same_depth_into_shallow_clone_from_dulwich(self):
# Note: remove this if C git and dulwich implement dumb web shallow
# clones.
raise SkipTest("Dumb web shallow cloning not supported.")
def test_fetch_full_depth_into_shallow_clone_from_dulwich(self):
# Note: remove this if C git and dulwich implement dumb web shallow
# clones.
raise SkipTest("Dumb web shallow cloning not supported.")
def test_push_to_dulwich_issue_88_standard(self):
raise SkipTest("Dumb web pushing not supported.")