tests: Adapt tests to recent changes in vcs lib.

rhodecode/tests/lib/middleware/utils/test_scm_app_http.py

@@ -1,130 +1,131 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import Pyro4
 import pytest
 import webtest
 
 from rhodecode.lib.middleware.utils import scm_app_http, scm_app
+from rhodecode.lib.middleware.simplegit import SimpleGit
 from rhodecode.lib.vcs.conf import settings
 
 
 def vcs_http_app(vcsserver_http_echo_app):
     """
     VcsHttpProxy wrapped in WebTest.
     """
     git_url = vcsserver_http_echo_app.http_url + 'stream/git/'
     vcs_http_proxy = scm_app_http.VcsHttpProxy(
         git_url, 'stub_path', 'stub_name', None, 'stub_backend')
     app = webtest.TestApp(vcs_http_proxy)
     return app
 
 
 @pytest.fixture(scope='module')
 def vcsserver_http_echo_app(request, vcsserver_factory):
     """
     A running VCSServer with the EchoApp activated via HTTP.
     """
     vcsserver = vcsserver_factory(
         request=request,
         use_http=True,
         overrides=[{'app:main': {'dev.use_echo_app': 'true'}}])
     return vcsserver
 
 
 @pytest.fixture(scope='session')
 def data():
     one_kb = "x" * 1024
     return one_kb * 1024 * 10
 
 
 def test_reuse_app_no_data(repeat, vcsserver_http_echo_app):
     app = vcs_http_app(vcsserver_http_echo_app)
     for x in xrange(repeat / 10):
         response = app.post('/')
         assert response.status_code == 200
 
 
 def test_reuse_app_with_data(data, repeat, vcsserver_http_echo_app):
     app = vcs_http_app(vcsserver_http_echo_app)
     for x in xrange(repeat / 10):
         response = app.post('/', params=data)
         assert response.status_code == 200
 
 
 def test_create_app_per_request_no_data(repeat, vcsserver_http_echo_app):
     for x in xrange(repeat / 10):
         app = vcs_http_app(vcsserver_http_echo_app)
         response = app.post('/')
         assert response.status_code == 200
 
 
 def test_create_app_per_request_with_data(
         data, repeat, vcsserver_http_echo_app):
     for x in xrange(repeat / 10):
         app = vcs_http_app(vcsserver_http_echo_app)
         response = app.post('/', params=data)
         assert response.status_code == 200
 
 
 @pytest.fixture(scope='module')
 def vcsserver_pyro_echo_app(request, vcsserver_factory):
     """
     A running VCSServer with the EchoApp activated via Pyro4.
     """
     vcsserver = vcsserver_factory(
         request=request,
         use_http=False,
         overrides=[{'DEFAULT': {'dev.use_echo_app': 'true'}}])
     return vcsserver
 
 
 def vcs_pyro4_app(vcsserver_pyro_echo_app):
     """
     Pyro4 based Vcs proxy wrapped in WebTest
     """
     stub_config = {
         'git_update_server_info': 'stub',
     }
     server_and_port = vcsserver_pyro_echo_app.server_and_port
     GIT_REMOTE_WSGI = Pyro4.Proxy(
         settings.pyro_remote(
             settings.PYRO_GIT_REMOTE_WSGI, server_and_port))
     with mock.patch('rhodecode.lib.middleware.utils.scm_app.GIT_REMOTE_WSGI',
                     GIT_REMOTE_WSGI):
         pyro4_app = scm_app.create_git_wsgi_app(
-            'stub_path', 'stub_name', stub_config)
+            'stub_path', 'stub_name', stub_config, SimpleGit.SCM)
     app = webtest.TestApp(pyro4_app)
     return app
 
 
 def test_pyro4_no_data(repeat, pylonsapp, vcsserver_pyro_echo_app):
     for x in xrange(repeat / 10):
         app = vcs_pyro4_app(vcsserver_pyro_echo_app)
         response = app.post('/')
         assert response.status_code == 200
 
 
 def test_pyro4_with_data(repeat, pylonsapp, vcsserver_pyro_echo_app, data):
     for x in xrange(repeat / 10):
         app = vcs_pyro4_app(vcsserver_pyro_echo_app)
         response = app.post('/', params=data)
         assert response.status_code == 200

rhodecode/tests/lib/middleware/utils/test_wsgi_app_caller_client.py

@@ -1,98 +1,102 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import webtest
 
 from rhodecode.lib.middleware.utils import wsgi_app_caller_client
 
 # pylint: disable=protected-access,too-many-public-methods
 
 
 BASE_ENVIRON = {
     'REQUEST_METHOD': 'GET',
     'SERVER_NAME': 'localhost',
     'SERVER_PORT': '80',
     'SCRIPT_NAME': '',
     'PATH_INFO': '/',
     'QUERY_STRING': '',
     'foo.bool_var': True,
     'foo.str_var': 'True',
     'wsgi.foo': True,
     # Some non string values. The validator expects to get an iterable as
     # value.
     (42,): '42',
     (True,): 'False',
 }
 
 
 def assert_all_values_are_str(environ):
     """Checks that all values of a dict are str."""
     for key, value in environ.iteritems():
         assert isinstance(value, str), (
             "Value for key %s: has type %s but 'str' was expected. Value: %s" %
             (key, type(value), repr(value)))
 
 
 def assert_all_keys_are_str(environ):
     """Checks that all keys of a dict are str."""
     for key, value in environ.iteritems():
         assert isinstance(value, str), (
             "Key %s: has type %s but 'str' was expected. " %
             (repr(key), type(key)))
 
 
 def assert_no_prefix_in_keys(environ, prefix):
     """Checks that no key of the dict starts with the prefix."""
     for key in environ:
         assert not key.startswith(prefix), 'Key %s should not be present' % key
 
 
 def test_get_environ():
     clean_environ = wsgi_app_caller_client._get_clean_environ(BASE_ENVIRON)
 
     assert len(clean_environ) == 7
     assert_no_prefix_in_keys(clean_environ, 'wsgi.')
     assert_all_keys_are_str(clean_environ)
     assert_all_values_are_str(clean_environ)
 
 
 def test_remote_app_caller():
 
     class RemoteAppCallerMock(object):
 
         def handle(self, environ, input_data, arg1, arg2,
                    arg3=None, arg4=None, arg5=None):
             assert ((arg1, arg2, arg3, arg4, arg5) ==
                     ('a1', 'a2', 'a3', 'a4', None))
             # Note: RemoteAppCaller is expected to return a tuple like the
             # following one
             return (['content'], '200 OK', [('Content-Type', 'text/plain')])
 
     wrapper_app = wsgi_app_caller_client.RemoteAppCaller(
-        RemoteAppCallerMock(), 'a1', 'a2', arg3='a3', arg4='a4')
+        RemoteAppCallerMock(), 'dummy-backend',
+        'a1', 'a2', arg3='a3', arg4='a4')
 
     test_app = webtest.TestApp(wrapper_app)
 
     response = test_app.get('/path')
 
     assert response.status == '200 OK'
-    assert response.headers.items() == [
-        ('Content-Type', 'text/plain'), ('Content-Length', '7')]
+    assert sorted(response.headers.items()) == sorted([
+        ('X-RhodeCode-Backend', 'dummy-backend'),
+        ('Content-Type', 'text/plain'),
+        ('Content-Length', '7'),
+    ])
     assert response.body == 'content'