`_)::
169 |
170 | >>> res = app.get('/object.json')
171 | >>> sorted(res.json.values())
172 | [1, 2]
173 |
174 |
175 | In each case the content-type must be correct or an AttributeError is
176 | raised. If you do not have the necessary library installed (none of
177 | them are required by WebTest), you will get an ImportError.
178 |
--------------------------------------------------------------------------------
/docs/webtest.rst:
--------------------------------------------------------------------------------
1 | ======================================
2 | Functional Testing of Web Applications
3 | ======================================
4 |
5 |
6 | .. toctree::
7 |
8 | testapp
9 | testresponse
10 | debugapp
11 |
12 |
13 | Framework Hooks
14 | ===============
15 |
16 | Frameworks can detect that they are in a testing environment by the
17 | presence (and truth) of the WSGI environmental variable
18 | ``"paste.testing"`` (the key name is inherited from
19 | ``paste.fixture``).
20 |
21 | More generally, frameworks can detect that something (possibly a test
22 | fixture) is ready to catch unexpected errors by the presence and truth
23 | of ``"paste.throw_errors"`` (this is sometimes set outside of testing
24 | fixtures too, when an error-handling middleware is in place).
25 |
26 | Frameworks that want to expose the inner structure of the request may
27 | use ``"paste.testing_variables"``. This will be a dictionary -- any
28 | values put into that dictionary will become attributes of the response
29 | object. So if you do ``env["paste.testing_variables"]['template'] =
30 | template_name`` in your framework, then ``response.template`` will be
31 | ``template_name``.
32 |
--------------------------------------------------------------------------------
/license.rst:
--------------------------------------------------------------------------------
1 | License
2 | =======
3 |
4 | Copyright (c) 2010 Ian Bicking and Contributors
5 |
6 | Permission is hereby granted, free of charge, to any person obtaining
7 | a copy of this software and associated documentation files (the
8 | "Software"), to deal in the Software without restriction, including
9 | without limitation the rights to use, copy, modify, merge, publish,
10 | distribute, sublicense, and/or sell copies of the Software, and to
11 | permit persons to whom the Software is furnished to do so, subject to
12 | the following conditions:
13 |
14 | The above copyright notice and this permission notice shall be
15 | included in all copies or substantial portions of the Software.
16 |
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
21 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |
--------------------------------------------------------------------------------
/rtd.txt:
--------------------------------------------------------------------------------
1 | -e .[docs]
2 |
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [aliases]
2 | dev = develop easy_install webtest[tests]
3 |
4 | [bdist_wheel]
5 | universal=0
6 |
7 | [tool:pytest]
8 | addopts = -p no:warnings
9 | --doctest-modules
10 | --doctest-glob='*.rst'
11 | --ignore=docs/
12 | --ignore=CHANGES.rst
13 | --ignore=setup.py
14 | --ignore=bootstrap.py
15 | --ignore=examples/
16 | --ignore=docs/conf.py
17 | -W always
18 | doctest_optionflags= NORMALIZE_WHITESPACE ELLIPSIS
19 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | from setuptools import setup
4 | from setuptools import find_packages
5 |
6 | version = '3.0.8.dev0'
7 |
8 | install_requires = [
9 | 'WebOb>=1.2',
10 | 'waitress>=3.0.2',
11 | 'beautifulsoup4',
12 | ]
13 |
14 | tests_require = [
15 | 'coverage',
16 | 'PasteDeploy',
17 | 'pyquery',
18 | 'pytest',
19 | 'pytest-cov',
20 | 'WSGIProxy2',
21 | ]
22 |
23 | docs_extras = [
24 | 'docutils',
25 | 'pylons-sphinx-themes >= 1.0.8',
26 | 'Sphinx >= 3.0.0',
27 | ]
28 |
29 | setup(name='WebTest',
30 | version=version,
31 | description="Helper to test WSGI applications",
32 | long_description=open('README.rst').read(),
33 | classifiers=[
34 | "Development Status :: 5 - Production/Stable",
35 | "Framework :: Paste",
36 | "Intended Audience :: Developers",
37 | "License :: OSI Approved :: MIT License",
38 | "Topic :: Internet :: WWW/HTTP :: WSGI",
39 | "Topic :: Internet :: WWW/HTTP :: WSGI :: Server",
40 | "Programming Language :: Python :: 3",
41 | "Programming Language :: Python :: 3 :: Only",
42 | "Programming Language :: Python :: 3.9",
43 | "Programming Language :: Python :: 3.10",
44 | "Programming Language :: Python :: 3.11",
45 | "Programming Language :: Python :: 3.12",
46 | ],
47 | keywords='wsgi test unit tests web',
48 | author='Ian Bicking',
49 | maintainer='Gael Pasgrimaud',
50 | maintainer_email='gael@gawel.org',
51 | url='https://docs.pylonsproject.org/projects/webtest/en/latest/',
52 | license='MIT',
53 | packages=find_packages(exclude=[
54 | 'ez_setup',
55 | 'examples',
56 | 'tests',
57 | 'bootstrap',
58 | 'bootstrap-py3k',
59 | ]),
60 | include_package_data=True,
61 | zip_safe=False,
62 | python_requires='>=3.9',
63 | install_requires=install_requires,
64 | tests_require=tests_require,
65 | extras_require={
66 | 'tests': tests_require,
67 | 'docs': docs_extras,
68 | },
69 | entry_points="""
70 | [paste.app_factory]
71 | debug = webtest.debugapp:make_debug_app
72 | """,
73 | )
74 |
--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
1 | #
2 |
--------------------------------------------------------------------------------
/tests/compat.py:
--------------------------------------------------------------------------------
1 | import unittest # noqa
2 |
3 | try:
4 | unicode()
5 | except NameError:
6 | b = bytes
7 |
8 | def u(value):
9 | if isinstance(value, bytes):
10 | return value.decode('utf-8')
11 | return value
12 | else:
13 | def b(value):
14 | return str(value)
15 |
16 | def u(value):
17 | if isinstance(value, unicode):
18 | return value
19 | return unicode(value, 'utf-8')
20 |
--------------------------------------------------------------------------------
/tests/deploy.ini:
--------------------------------------------------------------------------------
1 | [app:main]
2 | paste.app_factory = webtest.debugapp:make_debug_app
3 | form =
4 |
--------------------------------------------------------------------------------
/tests/html/404.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
--------------------------------------------------------------------------------
/tests/html/app.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function() {
2 |
3 | $('#myform').submit(function() {
4 | $('#message').text('Form submited');
5 | return false;
6 | });
7 |
8 | });
9 |
--------------------------------------------------------------------------------
/tests/html/form_inputs.html:
--------------------------------------------------------------------------------
1 |
2 | forms page
3 |
4 |
17 |
21 |
26 |
35 |
39 |
43 |
46 |
50 |
55 |
59 |
60 |
61 |
64 |
65 |
66 |
68 |
69 |
70 |
71 |
72 |
--------------------------------------------------------------------------------
/tests/html/form_inputs_with_defaults.html:
--------------------------------------------------------------------------------
1 |
2 | form page
3 |
4 |
8 |
13 |
17 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/tests/html/form_unicode_inputs.html:
--------------------------------------------------------------------------------
1 |
2 | form page
3 |
4 |
8 |
13 |
17 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/tests/html/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | It Works!
7 |
8 |
9 | It Works!
10 |
11 |
12 |
58 |
59 |
60 |
--------------------------------------------------------------------------------
/tests/html/message.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | %(message)s
9 |
10 |
11 |
--------------------------------------------------------------------------------
/tests/test_authorisation.py:
--------------------------------------------------------------------------------
1 | from webtest.debugapp import DebugApp
2 | from tests.compat import unittest
3 | from base64 import b64decode
4 | from webtest.compat import to_bytes
5 |
6 | import webtest
7 |
8 |
9 | class TestAuthorization(unittest.TestCase):
10 |
11 | def callFUT(self):
12 | return webtest.TestApp(DebugApp())
13 |
14 | def test_basic_authorization(self):
15 | app = self.callFUT()
16 | authorization = ('Basic', ['gawel', 'passwd'])
17 | app.authorization = authorization
18 |
19 | self.assertIn('HTTP_AUTHORIZATION', app.extra_environ)
20 | self.assertEqual(app.authorization, authorization)
21 |
22 | resp = app.get('/')
23 | resp.mustcontain('HTTP_AUTHORIZATION: Basic Z2F3ZWw6cGFzc3dk')
24 | header = resp.request.environ['HTTP_AUTHORIZATION']
25 | self.assertTrue(header.startswith('Basic '))
26 | authtype, value = header.split(' ')
27 | auth = (authtype,
28 | b64decode(to_bytes(value)).decode('latin1').split(':'))
29 | self.assertEqual(authorization, auth)
30 |
31 | app.authorization = None
32 | self.assertNotIn('HTTP_AUTHORIZATION', app.extra_environ)
33 |
34 | def test_bearer_authorization(self):
35 | app = self.callFUT()
36 | authorization = ('Bearer', '2588409761fcfa3e378bff4fb766e2e2')
37 | app.authorization = authorization
38 |
39 | self.assertIn('HTTP_AUTHORIZATION', app.extra_environ)
40 | self.assertEqual(app.authorization, authorization)
41 |
42 | resp = app.get('/')
43 | resp.mustcontain('HTTP_AUTHORIZATION: Bearer 2588409761fcfa3e378bff4fb766e2e2')
44 | header = resp.request.environ['HTTP_AUTHORIZATION']
45 | self.assertTrue(header.startswith('Bearer '))
46 |
47 | app.authorization = None
48 | self.assertNotIn('HTTP_AUTHORIZATION', app.extra_environ)
49 |
50 | def test_invalid(self):
51 | app = self.callFUT()
52 | self.assertRaises(ValueError, app.set_authorization, ())
53 | self.assertRaises(ValueError, app.set_authorization, '')
54 | self.assertRaises(ValueError, app.set_authorization, ('Basic', ''))
55 | self.assertRaises(ValueError, app.set_authorization, ('Basic', ()))
56 | self.assertRaises(ValueError, app.set_authorization, ('Bearer', ()))
57 | self.assertRaises(ValueError, app.set_authorization, ('Bearer', []))
58 |
--------------------------------------------------------------------------------
/tests/test_debugapp.py:
--------------------------------------------------------------------------------
1 | import os
2 | import sys
3 | import webtest
4 | from webtest.debugapp import debug_app
5 | from webtest.compat import to_bytes
6 | from webtest.compat import print_stderr
7 | from webtest.app import AppError
8 | from tests.compat import unittest
9 | import webbrowser
10 |
11 |
12 | def test_print_unicode():
13 | print_stderr('°C')
14 |
15 |
16 | class TestTesting(unittest.TestCase):
17 |
18 | def setUp(self):
19 | self.app = webtest.TestApp(debug_app)
20 |
21 | def test_url_class(self):
22 | class U:
23 | def __str__(self):
24 | return '/'
25 | res = self.app.get(U())
26 | self.assertEqual(res.status_int, 200)
27 |
28 | def test_testing(self):
29 | res = self.app.get('/')
30 | self.assertEqual(res.status_int, 200)
31 | self.assertEqual(res.headers['content-type'], 'text/plain')
32 | self.assertEqual(res.content_type, 'text/plain')
33 | res = self.app.request('/', method='GET')
34 | self.assertEqual(res.status_int, 200)
35 | self.assertEqual(res.headers['content-type'], 'text/plain')
36 | self.assertEqual(res.content_type, 'text/plain')
37 | res = self.app.head('/')
38 | self.assertEqual(res.status_int, 200)
39 | self.assertEqual(res.headers['content-type'], 'text/plain')
40 | self.assertTrue(res.content_length > 0)
41 | self.assertEqual(res.body, to_bytes(''))
42 | res = self.app.head('/', xhr=True)
43 | self.assertEqual(res.status_int, 200)
44 |
45 | def test_post_unicode(self):
46 | res = self.app.post(
47 | '/', params=dict(a='é'),
48 | content_type='application/x-www-form-urlencoded;charset=utf8')
49 | res.mustcontain('a=%C3%A9')
50 |
51 | def test_post_unicode_body(self):
52 | res = self.app.post(
53 | '/', params='é',
54 | content_type='text/plain; charset=utf8')
55 | self.assertTrue(res.body.endswith(b'\xc3\xa9'))
56 | res.mustcontain('é')
57 |
58 | def test_post_params(self):
59 | res = self.app.post('/', params=dict(a=1))
60 | res.mustcontain('a=1')
61 | res = self.app.post('/', params=[('a', '1')])
62 | res.mustcontain('a=1')
63 | res = self.app.post_json('/', params=dict(a=1))
64 | res.mustcontain('{"a": 1}')
65 | res = self.app.post_json('/', params=False)
66 | res.mustcontain('false')
67 |
68 | def test_put_params(self):
69 | res = self.app.put('/', params=dict(a=1))
70 | res.mustcontain('a=1')
71 | res = self.app.put_json('/', params=dict(a=1))
72 | res.mustcontain('{"a": 1}')
73 | res = self.app.put_json('/', params=False)
74 | res.mustcontain('false')
75 |
76 | def test_delete_params(self):
77 | res = self.app.delete('/', params=dict(a=1))
78 | res.mustcontain('a=1')
79 | res = self.app.delete_json('/', params=dict(a=1))
80 | res.mustcontain('{"a": 1}')
81 |
82 | def test_options(self):
83 | res = self.app.options('/')
84 | self.assertEqual(res.status_int, 200)
85 |
86 | def test_exception(self):
87 | self.assertRaises(Exception, self.app.get, '/?error=t')
88 | self.assertRaises(webtest.AppError, self.app.get,
89 | '/?status=404%20Not%20Found')
90 |
91 | def test_bad_content_type(self):
92 | resp = self.app.get('/')
93 | self.assertRaises(AttributeError, lambda: resp.json)
94 | resp = self.app.get('/?header-content-type=application/json')
95 | self.assertRaises(AttributeError, lambda: resp.pyquery)
96 | self.assertRaises(AttributeError, lambda: resp.lxml)
97 | self.assertRaises(AttributeError, lambda: resp.xml)
98 |
99 | def test_app_from_config_file(self):
100 | config = os.path.join(os.path.dirname(__file__), 'deploy.ini')
101 | app = webtest.TestApp('config:%s#main' % config)
102 | resp = app.get('/')
103 | self.assertEqual(resp.status_int, 200)
104 |
105 | def test_errors(self):
106 | try:
107 | self.app.get('/?errorlog=somelogs')
108 | assert(False, "An AppError should be raised")
109 | except AppError:
110 | e = sys.exc_info()[1]
111 | assert str(e) \
112 | == "Application had errors logged:\nsomelogs"
113 |
114 | def test_request_obj(self):
115 | res = self.app.get('/')
116 | res = self.app.request(res.request)
117 |
118 | def test_showbrowser(self):
119 | open_new = webbrowser.open_new
120 | self.filename = ''
121 |
122 | def open_new(f):
123 | self.filename = f
124 |
125 | webbrowser.open_new = open_new
126 | res = self.app.get('/')
127 | res.showbrowser()
128 | assert self.filename.startswith('file://'), self.filename
129 |
130 | def test_303(self):
131 | res = self.app.get('/?status=302%20Redirect&header-location=/foo')
132 | self.assertEqual(res.status_int, 302)
133 | print(res.location)
134 | self.assertEqual(res.location, 'http://localhost/foo', res)
135 | self.assertEqual(res.headers['location'], 'http://localhost/foo')
136 | res = res.follow()
137 | self.assertEqual(res.request.url, 'http://localhost/foo')
138 | self.assertIn('Response: 200 OK', str(res))
139 | self.assertIn('200 OK', repr(res))
140 | self.app.get('/?status=303%20redirect', status='3*')
141 |
142 | def test_204(self):
143 | self.app.post('/?status=204%20OK')
144 |
145 | def test_404(self):
146 | self.app.get('/?status=404%20Not%20Found', status=404)
147 | self.assertRaises(webtest.AppError, self.app.get, '/', status=404)
148 |
149 | def test_print_stderr(self):
150 | res = self.app.get('/')
151 | res.charset = 'utf-8'
152 | res.text = '°C'
153 | print_stderr(str(res))
154 |
155 | res.charset = None
156 | print_stderr(str(res))
157 |
158 | def test_app_error(self):
159 | res = self.app.get('/')
160 | res.charset = 'utf-8'
161 | res.text = '°C'
162 | AppError('%s %s %s %s', res.status, '', res.request.url, res)
163 | res.charset = None
164 | AppError('%s %s %s %s', res.status, '', res.request.url, res)
165 |
166 | def test_exception_repr(self):
167 | res = self.app.get('/')
168 | res.charset = 'utf-8'
169 | res.text = '°C'
170 | str(AssertionError(res))
171 | res.charset = None
172 | str(AssertionError(res))
173 |
174 | def test_fake_dict(self):
175 | class FakeDict:
176 | def items(self):
177 | return [('a', '10'), ('a', '20')]
178 | self.app.post('/params', params=FakeDict())
179 |
--------------------------------------------------------------------------------
/tests/test_ext.py:
--------------------------------------------------------------------------------
1 | from .compat import unittest
2 | from webtest import ext
3 |
4 |
5 | class TestSelenium(unittest.TestCase):
6 |
7 | def test_raises(self):
8 | self.assertRaises(ImportError, ext.casperjs)
9 |
--------------------------------------------------------------------------------
/tests/test_http.py:
--------------------------------------------------------------------------------
1 | from tests.compat import unittest
2 | from webob import Request
3 | from webtest.debugapp import debug_app
4 | from webtest import http
5 |
6 |
7 | class TestServer(unittest.TestCase):
8 |
9 | def setUp(self):
10 | self.s = http.StopableWSGIServer.create(debug_app)
11 |
12 | def test_server(self):
13 | s = self.s
14 | s.wait()
15 | self.assertEqual(200,
16 | http.check_server(s.adj.host, s.adj.port,
17 | '/__application__'))
18 | self.assertEqual(200,
19 | http.check_server(s.adj.host, s.adj.port,
20 | '/__file__?__file__=' + __file__))
21 | self.assertEqual(404,
22 | http.check_server(s.adj.host, s.adj.port,
23 | '/__file__?__file__=XXX'))
24 |
25 | self.assertEqual(304,
26 | http.check_server(s.adj.host, s.adj.port,
27 | '/?status=304'))
28 |
29 | def test_wsgi_wrapper(self):
30 | s = self.s
31 | s.wait()
32 | req = Request.blank('/__application__')
33 | resp = req.get_response(s.wrapper)
34 | self.assertEqual(resp.status_int, 200)
35 |
36 | req = Request.blank('/__file__?__file__=' + __file__)
37 | resp = req.get_response(s.wrapper)
38 | self.assertEqual(resp.status_int, 200)
39 |
40 | req = Request.blank('/__file__?__file__=XXX')
41 | resp = req.get_response(s.wrapper)
42 | self.assertEqual(resp.status_int, 404)
43 |
44 | req = Request.blank('/?status=304')
45 | resp = req.get_response(s.wrapper)
46 | self.assertEqual(resp.status_int, 304)
47 |
48 | def tearDown(self):
49 | self.s.shutdown()
50 |
51 |
52 | class TestBrokenServer(unittest.TestCase):
53 |
54 | def test_shutdown_non_running(self):
55 | host, port = http.get_free_port()
56 | s = http.StopableWSGIServer(debug_app, host=host, port=port)
57 | self.assertFalse(s.wait(retries=-1))
58 | self.assertTrue(s.shutdown())
59 |
60 |
61 | class TestClient(unittest.TestCase):
62 |
63 | def test_no_server(self):
64 | host, port = http.get_free_port()
65 | self.assertEqual(0, http.check_server(host, port, retries=2))
66 |
--------------------------------------------------------------------------------
/tests/test_lint.py:
--------------------------------------------------------------------------------
1 | import sys
2 | from tests.compat import unittest
3 | from webob import Request, Response
4 |
5 | import warnings
6 | from unittest import mock
7 | from io import StringIO
8 |
9 | from webtest import TestApp
10 | from webtest.compat import to_bytes
11 | from webtest.lint import check_headers
12 | from webtest.lint import check_content_type
13 | from webtest.lint import check_environ
14 | from webtest.lint import IteratorWrapper
15 | from webtest.lint import WriteWrapper
16 | from webtest.lint import ErrorWrapper
17 | from webtest.lint import InputWrapper
18 | from webtest.lint import to_string
19 | from webtest.lint import middleware
20 | from webtest.lint import _assert_latin1_str
21 |
22 | from io import BytesIO
23 |
24 |
25 | def application(environ, start_response):
26 | req = Request(environ)
27 | resp = Response()
28 | env_input = environ['wsgi.input']
29 | len_body = len(req.body)
30 | env_input.input.seek(0)
31 | if req.path_info == '/read':
32 | resp.body = env_input.read(len_body)
33 | elif req.path_info == '/read_line':
34 | resp.body = env_input.readline(len_body)
35 | elif req.path_info == '/read_lines':
36 | resp.body = b'-'.join(env_input.readlines(len_body))
37 | elif req.path_info == '/close':
38 | resp.body = env_input.close()
39 | return resp(environ, start_response)
40 |
41 |
42 | class TestLatin1Assertion(unittest.TestCase):
43 |
44 | def test_valid_type(self):
45 | value = "useful-inførmation-5"
46 | assert value == _assert_latin1_str(value, "fail")
47 |
48 | def test_invalid_type(self):
49 | value = b"useful-information-5"
50 | self.assertRaises(AssertionError, _assert_latin1_str, value, "fail")
51 |
52 |
53 | class TestToString(unittest.TestCase):
54 |
55 | def test_to_string(self):
56 | self.assertEqual(to_string('foo'), 'foo')
57 | self.assertEqual(to_string(b'foo'), 'foo')
58 |
59 |
60 | class TestMiddleware(unittest.TestCase):
61 |
62 | @unittest.skipIf(sys.flags.optimize > 0, "skip assert tests if optimize is enabled")
63 | def test_lint_too_few_args(self):
64 | linter = middleware(application)
65 | with self.assertRaisesRegex(AssertionError, "Two arguments required"):
66 | linter()
67 | with self.assertRaisesRegex(AssertionError, "Two arguments required"):
68 | linter({})
69 |
70 | @unittest.skipIf(sys.flags.optimize > 0, "skip assert tests if optimize is enabled")
71 | def test_lint_no_keyword_args(self):
72 | linter = middleware(application)
73 | with self.assertRaisesRegex(AssertionError, "No keyword arguments "
74 | "allowed"):
75 | linter({}, 'foo', baz='baz')
76 |
77 | # TODO: test start_response_wrapper
78 |
79 | @mock.patch.multiple('webtest.lint',
80 | check_environ=lambda x: True, # don't block too early
81 | InputWrapper=lambda x: True)
82 | def test_lint_iterator_returned(self):
83 | linter = middleware(lambda x, y: None) # None is not an iterator
84 | msg = "The application must return an iterator, if only an empty list"
85 | with self.assertRaisesRegex(AssertionError, msg):
86 | linter({'wsgi.input': 'foo', 'wsgi.errors': 'foo'}, 'foo')
87 |
88 |
89 | class TestInputWrapper(unittest.TestCase):
90 | def test_read(self):
91 | app = TestApp(application)
92 | resp = app.post('/read', 'hello')
93 | self.assertEqual(resp.body, b'hello')
94 |
95 | def test_readline(self):
96 | app = TestApp(application)
97 | resp = app.post('/read_line', 'hello\n')
98 | self.assertEqual(resp.body, b'hello\n')
99 |
100 | def test_readlines(self):
101 | app = TestApp(application)
102 | resp = app.post('/read_lines', 'hello\nt\n')
103 | self.assertEqual(resp.body, b'hello\n-t\n')
104 |
105 | def test_close(self):
106 | input_wrapper = InputWrapper(None)
107 | self.assertRaises(AssertionError, input_wrapper.close)
108 |
109 | def test_iter(self):
110 | data = to_bytes("A line\nAnother line\nA final line\n")
111 | input_wrapper = InputWrapper(BytesIO(data))
112 | self.assertEqual(to_bytes("").join(input_wrapper), data, '')
113 |
114 | def test_seek(self):
115 | data = to_bytes("A line\nAnother line\nA final line\n")
116 | input_wrapper = InputWrapper(BytesIO(data))
117 | input_wrapper.seek(0)
118 | self.assertEqual(to_bytes("").join(input_wrapper), data, '')
119 |
120 |
121 | class TestMiddleware2(unittest.TestCase):
122 | def test_exc_info(self):
123 | def application_exc_info(environ, start_response):
124 | body = to_bytes('body stuff')
125 | headers = [
126 | ('Content-Type', 'text/plain; charset=utf-8'),
127 | ('Content-Length', str(len(body)))]
128 | # PEP 3333 requires native strings:
129 | headers = [(str(k), str(v)) for k, v in headers]
130 | start_response(to_bytes('200 OK'), headers, ('stuff',))
131 | return [body]
132 |
133 | app = TestApp(application_exc_info)
134 | app.get('/')
135 | # don't know what to assert here... a bit cheating, just covers code
136 |
137 |
138 | class TestCheckContentType(unittest.TestCase):
139 | def test_no_content(self):
140 | status = "204 No Content"
141 | headers = [
142 | ('Content-Type', 'text/plain; charset=utf-8'),
143 | ('Content-Length', '4')
144 | ]
145 | self.assertRaises(AssertionError, check_content_type, status, headers)
146 |
147 | def test_no_content_type(self):
148 | status = "200 OK"
149 | headers = [
150 | ('Content-Length', '4')
151 | ]
152 | self.assertRaises(AssertionError, check_content_type, status, headers)
153 |
154 |
155 | class TestCheckHeaders(unittest.TestCase):
156 |
157 | def test_header_bytes_name(self):
158 | headers = [(b'X-Price', '100')]
159 | self.assertRaises(AssertionError, check_headers, headers)
160 |
161 | def test_header_bytes_value(self):
162 | headers = [('X-Price', b'100')]
163 | self.assertRaises(AssertionError, check_headers, headers)
164 |
165 | def test_header_non_latin1_value(self):
166 | headers = [('X-Price', '100€')]
167 | self.assertRaises(AssertionError, check_headers, headers)
168 |
169 | def test_header_non_latin1_name(self):
170 | headers = [('X-€', 'foo')]
171 | self.assertRaises(AssertionError, check_headers, headers)
172 |
173 |
174 | class TestCheckEnviron(unittest.TestCase):
175 | def test_no_query_string(self):
176 | environ = {
177 | 'REQUEST_METHOD': 'GET',
178 | 'SERVER_NAME': 'localhost',
179 | 'SERVER_PORT': '80',
180 | 'wsgi.version': (1, 0, 1),
181 | 'wsgi.input': StringIO('test'),
182 | 'wsgi.errors': StringIO(),
183 | 'wsgi.multithread': None,
184 | 'wsgi.multiprocess': None,
185 | 'wsgi.run_once': None,
186 | 'wsgi.url_scheme': 'http',
187 | 'PATH_INFO': '/',
188 | }
189 | with warnings.catch_warnings(record=True) as w:
190 | warnings.simplefilter("always")
191 | check_environ(environ)
192 | self.assertEqual(len(w), 1, "We should have only one warning")
193 | self.assertTrue(
194 | "QUERY_STRING" in str(w[-1].message),
195 | "The warning message should say something about QUERY_STRING")
196 |
197 | def test_no_valid_request(self):
198 | environ = {
199 | 'REQUEST_METHOD': 'PROPFIND',
200 | 'SERVER_NAME': 'localhost',
201 | 'SERVER_PORT': '80',
202 | 'wsgi.version': (1, 0, 1),
203 | 'wsgi.input': StringIO('test'),
204 | 'wsgi.errors': StringIO(),
205 | 'wsgi.multithread': None,
206 | 'wsgi.multiprocess': None,
207 | 'wsgi.run_once': None,
208 | 'wsgi.url_scheme': 'http',
209 | 'PATH_INFO': '/',
210 | 'QUERY_STRING': '',
211 | }
212 | with warnings.catch_warnings(record=True) as w:
213 | warnings.simplefilter("always")
214 | check_environ(environ)
215 | self.assertEqual(len(w), 1, "We should have only one warning")
216 | self.assertTrue(
217 | "REQUEST_METHOD" in str(w[-1].message),
218 | "The warning message should say something "
219 | "about REQUEST_METHOD")
220 |
221 | def test_handles_native_strings_in_variables(self):
222 | path = '/umläut'
223 | environ = {
224 | 'REQUEST_METHOD': 'GET',
225 | 'SERVER_NAME': 'localhost',
226 | 'SERVER_PORT': '80',
227 | 'wsgi.version': (1, 0, 1),
228 | 'wsgi.input': StringIO('test'),
229 | 'wsgi.errors': StringIO(),
230 | 'wsgi.multithread': None,
231 | 'wsgi.multiprocess': None,
232 | 'wsgi.run_once': None,
233 | 'wsgi.url_scheme': 'http',
234 | 'PATH_INFO': path,
235 | 'QUERY_STRING': '',
236 | }
237 | with warnings.catch_warnings(record=True) as w:
238 | warnings.simplefilter("always")
239 | check_environ(environ)
240 | self.assertEqual(0, len(w), "We should have no warning")
241 |
242 |
243 | class TestIteratorWrapper(unittest.TestCase):
244 | def test_close(self):
245 | class MockIterator:
246 |
247 | def __init__(self):
248 | self.closed = False
249 |
250 | def __iter__(self):
251 | return self
252 |
253 | def __next__(self):
254 | return None
255 |
256 | next = __next__
257 |
258 | def close(self):
259 | self.closed = True
260 |
261 | mock = MockIterator()
262 | wrapper = IteratorWrapper(mock, None)
263 | wrapper.close()
264 |
265 | self.assertTrue(mock.closed, "Original iterator has not been closed")
266 |
267 |
268 | class TestWriteWrapper(unittest.TestCase):
269 |
270 | @unittest.skipIf(sys.flags.optimize > 0, "skip assert tests if optimize is enabled")
271 | def test_wrong_type(self):
272 | write_wrapper = WriteWrapper(None)
273 | self.assertRaises(AssertionError, write_wrapper, 'not a binary')
274 |
275 | def test_normal(self):
276 | class MockWriter:
277 | def __init__(self):
278 | self.written = []
279 |
280 | def __call__(self, s):
281 | self.written.append(s)
282 |
283 | data = to_bytes('foo')
284 | mock = MockWriter()
285 | write_wrapper = WriteWrapper(mock)
286 | write_wrapper(data)
287 | self.assertEqual(
288 | mock.written, [data],
289 | "WriterWrapper should call original writer when data is binary "
290 | "type")
291 |
292 |
293 | class TestErrorWrapper(unittest.TestCase):
294 |
295 | def test_dont_close(self):
296 | error_wrapper = ErrorWrapper(None)
297 | self.assertRaises(AssertionError, error_wrapper.close)
298 |
299 | class FakeError:
300 | def __init__(self):
301 | self.written = []
302 | self.flushed = False
303 |
304 | def write(self, s):
305 | self.written.append(s)
306 |
307 | def writelines(self, lines):
308 | for line in lines:
309 | self.write(line)
310 |
311 | def flush(self):
312 | self.flushed = True
313 |
314 | def test_writelines(self):
315 | fake_error = self.FakeError()
316 | error_wrapper = ErrorWrapper(fake_error)
317 | data = [to_bytes('a line'), to_bytes('another line')]
318 | error_wrapper.writelines(data)
319 | self.assertEqual(fake_error.written, data,
320 | "ErrorWrapper should call original writer")
321 |
322 | def test_flush(self):
323 | fake_error = self.FakeError()
324 | error_wrapper = ErrorWrapper(fake_error)
325 | error_wrapper.flush()
326 | self.assertTrue(
327 | fake_error.flushed,
328 | "ErrorWrapper should have called original wsgi_errors's flush")
329 |
--------------------------------------------------------------------------------
/tests/test_response.py:
--------------------------------------------------------------------------------
1 | import webtest
2 | from webtest.debugapp import debug_app
3 | from webob import Request
4 | from webob.response import gzip_app_iter
5 |
6 | from tests.compat import unittest
7 |
8 | import webbrowser
9 |
10 |
11 | def links_app(environ, start_response):
12 | req = Request(environ)
13 | status = "200 OK"
14 | responses = {
15 | '/': """
16 |
17 | page with links
18 |
19 | Foo
20 | Bar
21 | Baz
22 | Baz
23 | Baz
24 |
27 | Click me!
28 | Click me!
29 |
33 |
35 |
39 |
40 |
41 | """,
42 |
43 | '/foo/': (
44 | 'This is foo. Bar '
45 | ''
46 | ),
47 | '/foo/bar': 'This is foobar.',
48 | '/bar': 'This is bar.',
49 | '/baz/': 'This is baz.',
50 | '/spam/': 'This is spam.',
51 | '/egg/': 'Just eggs.',
52 |
53 | '/utf8/': """
54 |
55 | Тестовая страница
56 |
57 | Менделеев
58 | Пушкин
59 | 
60 |
63 |
64 |
65 | """,
66 | '/no_form/': """
67 |
68 | Page without form
69 |
70 | This is not the form you are looking for
71 |
72 |
73 | """,
74 | '/one_forms/': """
75 |
76 | Page without form
77 |
78 |
79 |
80 |
81 | """,
82 | '/many_forms/': """
83 |
84 | Page without form
85 |
86 |
87 |
88 |
89 |
90 | """,
91 | '/html_in_anchor/': """
92 |
93 | Page with HTML in an anchor tag
94 |
95 | Foo BarQuz
96 |
97 |
98 | """,
99 | '/json/': '{"foo": "bar"}',
100 | }
101 |
102 | utf8_paths = ['/utf8/']
103 | body = responses[req.path_info]
104 | body = body.encode('utf8')
105 | headers = [
106 | ('Content-Type', 'text/html'),
107 | ('Content-Length', str(len(body)))
108 | ]
109 | if req.path_info in utf8_paths:
110 | headers[0] = ('Content-Type', 'text/html; charset=utf-8')
111 | # PEP 3333 requires native strings:
112 | headers = [(str(k), str(v)) for k, v in headers]
113 | start_response(str(status), headers)
114 | return [body]
115 |
116 |
117 | def svg_application(env, start_response):
118 | start_response('200 OK', [('Content-Type', 'image/svg+xml')])
119 | return [
120 | b""""""
121 | b""""""
123 | b""""""
125 | ]
126 |
127 |
128 | def gzipped_app(environ, start_response):
129 | status = "200 OK"
130 | encoded_body = list(gzip_app_iter([b'test']))
131 | headers = [
132 | ('Content-Type', 'text/html'),
133 | ('Content-Encoding', 'gzip'),
134 | ]
135 | # PEP 3333 requires native strings:
136 | headers = [(str(k), str(v)) for k, v in headers]
137 | start_response(str(status), headers)
138 | return encoded_body
139 |
140 |
141 | class TestResponse(unittest.TestCase):
142 | def test_repr(self):
143 | def _repr(v):
144 | br = repr(v)
145 | if len(br) > 18:
146 | br = br[:10] + '...' + br[-5:]
147 | br += '/%s' % len(v)
148 |
149 | return br
150 |
151 | app = webtest.TestApp(debug_app)
152 | res = app.post('/')
153 | self.assertEqual(
154 | repr(res),
155 | '<200 OK text/plain body=%s>' % _repr(res.body)
156 | )
157 | res.content_type = None
158 | self.assertEqual(
159 | repr(res),
160 | '<200 OK body=%s>' % _repr(res.body)
161 | )
162 | res.location = 'http://pylons.org'
163 | self.assertEqual(
164 | repr(res),
165 | '<200 OK location: http://pylons.org body=%s>' % _repr(res.body)
166 | )
167 |
168 | res.body = b''
169 | self.assertEqual(
170 | repr(res),
171 | '<200 OK location: http://pylons.org no body>'
172 | )
173 |
174 | def test_mustcontains(self):
175 | app = webtest.TestApp(debug_app)
176 | res = app.post('/', params='foobar')
177 | res.mustcontain('foobar')
178 | self.assertRaises(IndexError, res.mustcontain, 'not found')
179 | res.mustcontain('foobar', no='not found')
180 | res.mustcontain('foobar', no=['not found', 'not found either'])
181 | self.assertRaises(IndexError, res.mustcontain, no='foobar')
182 | self.assertRaises(
183 | TypeError,
184 | res.mustcontain, invalid_param='foobar'
185 | )
186 |
187 | def test_click(self):
188 | app = webtest.TestApp(links_app)
189 | self.assertIn('This is foo.', app.get('/').click('Foo'))
190 | self.assertIn(
191 | 'This is foobar.',
192 | app.get('/').click('Foo').click('Bar')
193 | )
194 | self.assertIn('This is bar.', app.get('/').click('Bar'))
195 | # should skip non-clickable links
196 | self.assertIn(
197 | 'This is baz.',
198 | app.get('/').click('Baz')
199 | )
200 | self.assertIn('This is baz.', app.get('/').click(linkid='id_baz'))
201 | self.assertIn('This is baz.', app.get('/').click(href='baz/'))
202 | self.assertIn(
203 | 'This is spam.',
204 | app.get('/').click('Click me!', index=0)
205 | )
206 | self.assertIn(
207 | 'Just eggs.',
208 | app.get('/').click('Click me!', index=1)
209 | )
210 | self.assertIn(
211 | 'This is foo.',
212 | app.get('/html_in_anchor/').click('baz qux')
213 | )
214 |
215 | def dont_match_anchor_tag():
216 | app.get('/html_in_anchor/').click('href')
217 | self.assertRaises(IndexError, dont_match_anchor_tag)
218 |
219 | def multiple_links():
220 | app.get('/').click('Click me!')
221 | self.assertRaises(IndexError, multiple_links)
222 |
223 | def invalid_index():
224 | app.get('/').click('Click me!', index=2)
225 | self.assertRaises(IndexError, invalid_index)
226 |
227 | def no_links_found():
228 | app.get('/').click('Ham')
229 | self.assertRaises(IndexError, no_links_found)
230 |
231 | def tag_inside_script():
232 | app.get('/').click('Boo')
233 | self.assertRaises(IndexError, tag_inside_script)
234 |
235 | def test_click_utf8(self):
236 | app = webtest.TestApp(links_app, use_unicode=False)
237 | resp = app.get('/utf8/')
238 | self.assertEqual(resp.charset, 'utf-8')
239 |
240 | def test_click_u(self):
241 | app = webtest.TestApp(links_app)
242 | resp = app.get('/utf8/')
243 |
244 | self.assertIn("Тестовая страница", resp)
245 | self.assertIn('This is foo.', resp.click('Менделеев'))
246 |
247 | def test_clickbutton(self):
248 | app = webtest.TestApp(links_app)
249 | self.assertIn(
250 | 'This is foo.',
251 | app.get('/').clickbutton(buttonid='button1', verbose=True)
252 | )
253 | self.assertIn(
254 | 'This is foo.',
255 | app.get('/').clickbutton(buttonid='button3', onclick=r".*href='(.*?)'", verbose=True)
256 | )
257 | self.assertRaises(
258 | IndexError,
259 | app.get('/').clickbutton, buttonid='button2'
260 | )
261 | self.assertRaises(
262 | IndexError,
263 | app.get('/').clickbutton, buttonid='button3'
264 | )
265 |
266 | def test_referer(self):
267 | app = webtest.TestApp(links_app)
268 | resp = app.get('/').click('Foo')
269 | self.assertIn('Referer', resp.request.headers)
270 | self.assertEqual(resp.request.headers['Referer'], 'http://localhost/')
271 |
272 | resp = app.get('/').clickbutton(buttonid='button1')
273 | self.assertIn('Referer', resp.request.headers)
274 | self.assertEqual(resp.request.headers['Referer'], 'http://localhost/')
275 |
276 | resp = app.get('/one_forms/').form.submit()
277 | self.assertIn('Referer', resp.request.headers)
278 | self.assertEqual(resp.request.headers['Referer'],
279 | 'http://localhost/one_forms/')
280 |
281 | def test_xml_attribute(self):
282 | app = webtest.TestApp(links_app)
283 |
284 | resp = app.get('/no_form/')
285 | self.assertRaises(
286 | AttributeError,
287 | getattr,
288 | resp, 'xml'
289 | )
290 |
291 | resp.content_type = 'text/xml'
292 | resp.xml
293 |
294 | def test_lxml_attribute(self):
295 | app = webtest.TestApp(links_app)
296 | resp = app.post('/')
297 | resp.content_type = 'text/xml'
298 | print(resp.body)
299 | print(resp.lxml)
300 |
301 | def test_lxml_attribute_with_encoding_declaration(self):
302 | app = webtest.TestApp(svg_application)
303 | resp = app.get('/')
304 | print(resp.body)
305 | print(resp.lxml)
306 |
307 | def test_pyquery(self):
308 | app = webtest.TestApp(svg_application)
309 | resp = app.get('/')
310 | self.assertRaises(ValueError, lambda: resp.pyquery)
311 | pq = resp.PyQuery(parser='xml', remove_namespaces=True)
312 | assert len(pq('svg')) == 1
313 | pq = resp.PyQuery(parser='xml')
314 | assert len(pq('svg')) == 0
315 |
316 | def test_html_attribute(self):
317 | app = webtest.TestApp(links_app)
318 | res = app.post('/')
319 | res.content_type = 'text/plain'
320 | self.assertRaises(
321 | AttributeError,
322 | getattr, res, 'html'
323 | )
324 |
325 | def test_no_form(self):
326 | app = webtest.TestApp(links_app)
327 |
328 | resp = app.get('/no_form/')
329 | self.assertRaises(
330 | TypeError,
331 | getattr,
332 | resp, 'form'
333 | )
334 |
335 | def test_one_forms(self):
336 | app = webtest.TestApp(links_app)
337 |
338 | resp = app.get('/one_forms/')
339 | self.assertEqual(resp.form.id, 'first_form')
340 |
341 | def test_too_many_forms(self):
342 | app = webtest.TestApp(links_app)
343 |
344 | resp = app.get('/many_forms/')
345 | self.assertRaises(
346 | TypeError,
347 | getattr,
348 | resp, 'form'
349 | )
350 |
351 | def test_showbrowser(self):
352 | def open_new(f):
353 | self.filename = f
354 |
355 | webbrowser.open_new = open_new
356 | app = webtest.TestApp(debug_app)
357 | res = app.post('/')
358 | res.showbrowser()
359 |
360 | def test_unicode_normal_body(self):
361 | app = webtest.TestApp(debug_app)
362 | res = app.post('/')
363 | self.assertRaises(
364 | AttributeError,
365 | getattr, res, 'unicode_normal_body'
366 | )
367 | res.charset = 'latin1'
368 | res.body = 'été'.encode('latin1')
369 | self.assertEqual(res.unicode_normal_body, 'été')
370 |
371 | def test_testbody(self):
372 | app = webtest.TestApp(debug_app)
373 | res = app.post('/')
374 | res.charset = 'utf8'
375 | res.body = 'été'.encode('latin1')
376 | res.testbody
377 |
378 | def test_xml(self):
379 | app = webtest.TestApp(links_app)
380 |
381 | resp = app.get('/no_form/')
382 | self.assertRaises(
383 | AttributeError,
384 | getattr,
385 | resp, 'xml'
386 | )
387 |
388 | resp.content_type = 'text/xml'
389 | resp.xml
390 |
391 | def test_json(self):
392 | app = webtest.TestApp(links_app)
393 |
394 | resp = app.get('/json/')
395 | with self.assertRaises(AttributeError):
396 | resp.json
397 |
398 | resp.content_type = 'text/json'
399 | self.assertIn('foo', resp.json)
400 |
401 | resp.content_type = 'application/json'
402 | self.assertIn('foo', resp.json)
403 |
404 | resp.content_type = 'application/vnd.webtest+json'
405 | self.assertIn('foo', resp.json)
406 |
407 | def test_unicode(self):
408 | app = webtest.TestApp(links_app)
409 |
410 | resp = app.get('/')
411 |
412 | print(resp.__unicode__())
413 |
414 | def test_content_dezips(self):
415 | app = webtest.TestApp(gzipped_app)
416 | resp = app.get('/')
417 | self.assertEqual(resp.body, b'test')
418 |
419 |
420 | class TestFollow(unittest.TestCase):
421 |
422 | def get_redirects_app(self, count=1, locations=None):
423 | """Return an app that issues a redirect ``count`` times"""
424 |
425 | remaining_redirects = [count] # this means "nonlocal"
426 | if locations is None:
427 | locations = ['/'] * count
428 |
429 | def app(environ, start_response):
430 | headers = [('Content-Type', 'text/html')]
431 |
432 | if remaining_redirects[0] == 0:
433 | status = "200 OK"
434 | body = b"done"
435 | else:
436 | status = "302 Found"
437 | body = b''
438 | nextloc = str(locations.pop(0))
439 | headers.append(('location', nextloc))
440 | remaining_redirects[0] -= 1
441 |
442 | headers.append(('Content-Length', str(len(body))))
443 | # PEP 3333 requires native strings:
444 | headers = [(str(k), str(v)) for k, v in headers]
445 | start_response(str(status), headers)
446 | return [body]
447 |
448 | return webtest.TestApp(app)
449 |
450 | def test_follow_with_cookie(self):
451 | app = webtest.TestApp(debug_app)
452 | app.get('/?header-set-cookie=foo=bar')
453 | self.assertEqual(app.cookies['foo'], 'bar')
454 | resp = app.get('/?status=302%20Found&header-location=/')
455 | resp = resp.follow()
456 | resp.mustcontain('HTTP_COOKIE: foo=bar')
457 |
458 | def test_follow(self):
459 | app = self.get_redirects_app(1)
460 | resp = app.get('/')
461 | self.assertEqual(resp.status_int, 302)
462 |
463 | resp = resp.follow()
464 | self.assertEqual(resp.body, b'done')
465 |
466 | # can't follow non-redirect
467 | self.assertRaises(AssertionError, resp.follow)
468 |
469 | def test_follow_relative(self):
470 | app = self.get_redirects_app(2, ['hello/foo/', 'bar'])
471 | resp = app.get('/')
472 | self.assertEqual(resp.status_int, 302)
473 | resp = resp.follow()
474 | self.assertEqual(resp.status_int, 302)
475 | resp = resp.follow()
476 | self.assertEqual(resp.body, b'done')
477 | self.assertEqual(resp.request.url, 'http://localhost/hello/foo/bar')
478 |
479 | def test_follow_twice(self):
480 | app = self.get_redirects_app(2)
481 | resp = app.get('/').follow()
482 | self.assertEqual(resp.status_int, 302)
483 | resp = resp.follow()
484 | self.assertEqual(resp.status_int, 200)
485 |
486 | def test_maybe_follow_200(self):
487 | app = self.get_redirects_app(0)
488 | resp = app.get('/').maybe_follow()
489 | self.assertEqual(resp.body, b'done')
490 |
491 | def test_maybe_follow_once(self):
492 | app = self.get_redirects_app(1)
493 | resp = app.get('/').maybe_follow()
494 | self.assertEqual(resp.body, b'done')
495 |
496 | def test_maybe_follow_twice(self):
497 | app = self.get_redirects_app(2)
498 | resp = app.get('/').maybe_follow()
499 | self.assertEqual(resp.body, b'done')
500 |
501 | def test_maybe_follow_infinite(self):
502 | app = self.get_redirects_app(100000)
503 | self.assertRaises(AssertionError, app.get('/').maybe_follow)
504 |
505 | def test_pytest_collection_disabled(self):
506 | self.assertFalse(webtest.TestResponse.__test__)
507 |
--------------------------------------------------------------------------------
/tests/test_sel.py:
--------------------------------------------------------------------------------
1 | from .compat import unittest
2 | from webtest import sel
3 |
4 |
5 | class TestSelenium(unittest.TestCase):
6 |
7 | def test_raises(self):
8 | self.assertRaises(ImportError, sel.SeleniumApp)
9 | self.assertRaises(ImportError, sel.selenium)
10 |
--------------------------------------------------------------------------------
/tests/test_utils.py:
--------------------------------------------------------------------------------
1 | import re
2 | import json
3 | import sys
4 |
5 | from .compat import unittest
6 | from webtest import utils
7 |
8 |
9 | class NoDefaultTest(unittest.TestCase):
10 |
11 | def test_nodefault(self):
12 | from webtest.utils import NoDefault
13 | self.assertEqual(repr(NoDefault), '')
14 |
15 |
16 | class encode_paramsTest(unittest.TestCase):
17 |
18 | def test_encode_params_None(self):
19 | self.assertEqual(utils.encode_params(None, None), None)
20 |
21 | def test_encode_params_NoDefault(self):
22 | self.assertEqual(utils.encode_params(utils.NoDefault, None), '')
23 |
24 | def test_encode_params_dict_or_list(self):
25 | self.assertEqual(utils.encode_params({'foo': 'bar'}, None),
26 | utils.encode_params([('foo', 'bar')], None))
27 |
28 | def test_encode_params_no_charset(self):
29 | # no content_type at all
30 | self.assertEqual(utils.encode_params({'foo': 'bar'}, None), 'foo=bar')
31 | # content_type without "charset=xxxx"
32 | self.assertEqual(utils.encode_params({'foo': 'bar'}, 'ba'), 'foo=bar')
33 |
34 | def test_encode_params_charset_utf8(self):
35 | # charset is using inconsistent casing on purpose, it should still work
36 | self.assertEqual(utils.encode_params({'f': '€'}, ' CHARset=uTF-8; '),
37 | 'f=%E2%82%AC')
38 |
39 |
40 | class make_patternTest(unittest.TestCase):
41 |
42 | def call_FUT(self, obj):
43 | from webtest.utils import make_pattern
44 | return make_pattern(obj)
45 |
46 | def test_make_pattern_None(self):
47 | self.assertEqual(self.call_FUT(None), None)
48 |
49 | def test_make_pattern_regex(self):
50 | regex = re.compile(r'foobar')
51 | self.assertEqual(self.call_FUT(regex), regex.search)
52 |
53 | def test_make_pattern_function(self):
54 | func = lambda x: x
55 | self.assertEqual(self.call_FUT(func), func)
56 |
57 | def test_make_pattern_bytes(self):
58 | # if we pass a string, it will get compiled into a regex
59 | # that we can later call and match a string
60 | self.assertEqual(self.call_FUT('a')('a').string, 'a')
61 |
62 | def test_make_pattern_invalid(self):
63 | self.assertRaises(ValueError, self.call_FUT, 0)
64 |
65 |
66 | class stringifyTest(unittest.TestCase):
67 |
68 | def test_stringify_text(self):
69 | self.assertEqual(utils.stringify("foo"), "foo")
70 |
71 | def test_stringify_binary(self):
72 | self.assertEqual(utils.stringify(b"foo"), "foo")
73 |
74 | def test_stringify_other(self):
75 | self.assertEqual(utils.stringify(123), "123")
76 |
77 |
78 | class json_methodTest(unittest.TestCase):
79 |
80 | class MockTestApp:
81 | """Mock TestApp used to test the json_object decorator."""
82 | from webtest.utils import json_method
83 | JSONEncoder = json.JSONEncoder
84 | foo_json = json_method('FOO')
85 |
86 | def _gen_request(self, method, url, **kw):
87 | return (method, url, kw)
88 |
89 | mock = MockTestApp()
90 |
91 | def test_json_method_request_calls(self):
92 | from webtest.utils import NoDefault
93 | # no params
94 | self.assertEqual(self.mock.foo_json('url', params=NoDefault, c='c'),
95 | ('FOO', 'url', {'content_type': 'application/json',
96 | 'c': 'c',
97 | 'params': NoDefault,
98 | 'upload_files': None}))
99 | # params dumped to json
100 | self.assertEqual(self.mock.foo_json('url', params={'a': 'b'}, c='c'),
101 | ('FOO', 'url', {'content_type': 'application/json',
102 | 'c': 'c',
103 | 'params': json.dumps({'a': 'b'}),
104 | 'upload_files': None}))
105 |
106 | def test_json_method_request_respects_content_type_argument(self):
107 | self.assertEqual(self.mock.foo_json('url', params={'a': 'b'}, c='c', content_type='application/vnd.api+json;charset=utf-8'),
108 | ('FOO', 'url', {'content_type': 'application/vnd.api+json;charset=utf-8',
109 | 'c': 'c',
110 | 'params': json.dumps({'a': 'b'}),
111 | 'upload_files': None}))
112 |
113 | @unittest.skipIf(sys.flags.optimize == 2, "no docstring if PYTHONOPTIMIZE=2")
114 | def test_json_method_doc(self):
115 | self.assertIn('FOO request', self.mock.foo_json.__doc__)
116 | self.assertIn('TestApp.foo', self.mock.foo_json.__doc__)
117 |
118 | def test_json_method_name(self):
119 | self.assertEqual(self.mock.foo_json.__name__, 'foo_json')
120 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | skip_missing_interpreters = true
3 | envlist =
4 | py39,py310,py311,py312
5 | coverage,
6 | docs
7 |
8 | [testenv]
9 | setenv =
10 | LC_ALL=C
11 | LANG=C
12 | COVERAGE_FILE=.coverage.{envname}
13 | extras =
14 | tests
15 | commands =
16 | python --version
17 | pip freeze
18 | pytest --cov {posargs:}
19 |
20 | [testenv:coverage]
21 | skip_install = true
22 | deps =
23 | coverage
24 | setenv =
25 | COVERAGE_FILE=.coverage
26 | commands =
27 | coverage combine
28 | coverage xml
29 | # We want to get this to 100, but for now we compromise.
30 | # See https://github.com/Pylons/webtest/pull/231#issuecomment-729574898
31 | coverage report --show-missing --fail-under=96
32 |
33 | [testenv:docs]
34 | basepython = python3.12
35 | allowlist_externals =
36 | make
37 | commands =
38 | make -C docs html BUILDDIR={envdir} "SPHINXOPTS=-W -E"
39 | extras =
40 | docs
41 |
--------------------------------------------------------------------------------
/webtest/__init__.py:
--------------------------------------------------------------------------------
1 | # (c) 2005 Ian Bicking and contributors; written for Paste
2 | # (http://pythonpaste.org)
3 | # Licensed under the MIT license:
4 | # http://www.opensource.org/licenses/mit-license.php
5 | """
6 | Routines for testing WSGI applications.
7 | """
8 |
9 | from webtest.app import TestApp
10 | from webtest.app import TestRequest
11 | from webtest.app import TestResponse
12 | from webtest.app import AppError
13 | from webtest.forms import Form
14 | from webtest.forms import Field
15 | from webtest.forms import Select
16 | from webtest.forms import Radio
17 | from webtest.forms import Checkbox
18 | from webtest.forms import Text
19 | from webtest.forms import Textarea
20 | from webtest.forms import Hidden
21 | from webtest.forms import Submit
22 | from webtest.forms import Upload
23 |
--------------------------------------------------------------------------------
/webtest/compat.py:
--------------------------------------------------------------------------------
1 | import sys
2 | from http import cookies
3 |
4 | SimpleCookie = cookies.SimpleCookie
5 | CookieError = cookies.CookieError
6 |
7 |
8 | def to_bytes(value, charset='latin1'):
9 | if isinstance(value, str):
10 | return value.encode(charset)
11 | return value
12 |
13 |
14 | from html.entities import name2codepoint
15 | from urllib.parse import urlencode
16 | import urllib.parse as urlparse
17 | from collections.abc import Iterable # noqa
18 |
19 |
20 | def print_stderr(value):
21 | print(value, file=sys.stderr)
22 |
23 |
24 | def escape_cookie_value(value):
25 | """
26 | Escapes a value so that it can be safely stored in a cookie.
27 |
28 | """
29 | return '"' + ''.join(
30 | COOKIE_ESCAPE_CHAR_MAP.get(x, x) for x in value
31 | ) + '"'
32 |
33 |
34 | # A list of illegal characters in a cookie and the escaped equivalent.
35 | # Taken from Python's cookie module.
36 | COOKIE_ESCAPE_CHAR_MAP = {
37 | '\000' : '\\000', '\001' : '\\001', '\002' : '\\002',
38 | '\003' : '\\003', '\004' : '\\004', '\005' : '\\005',
39 | '\006' : '\\006', '\007' : '\\007', '\010' : '\\010',
40 | '\011' : '\\011', '\012' : '\\012', '\013' : '\\013',
41 | '\014' : '\\014', '\015' : '\\015', '\016' : '\\016',
42 | '\017' : '\\017', '\020' : '\\020', '\021' : '\\021',
43 | '\022' : '\\022', '\023' : '\\023', '\024' : '\\024',
44 | '\025' : '\\025', '\026' : '\\026', '\027' : '\\027',
45 | '\030' : '\\030', '\031' : '\\031', '\032' : '\\032',
46 | '\033' : '\\033', '\034' : '\\034', '\035' : '\\035',
47 | '\036' : '\\036', '\037' : '\\037',
48 |
49 | # Because of the way browsers really handle cookies (as opposed
50 | # to what the RFC says) we also encode , and ;
51 |
52 | ',' : '\\054', ';' : '\\073',
53 |
54 | '"' : '\\"', '\\' : '\\\\',
55 |
56 | '\177' : '\\177', '\200' : '\\200', '\201' : '\\201',
57 | '\202' : '\\202', '\203' : '\\203', '\204' : '\\204',
58 | '\205' : '\\205', '\206' : '\\206', '\207' : '\\207',
59 | '\210' : '\\210', '\211' : '\\211', '\212' : '\\212',
60 | '\213' : '\\213', '\214' : '\\214', '\215' : '\\215',
61 | '\216' : '\\216', '\217' : '\\217', '\220' : '\\220',
62 | '\221' : '\\221', '\222' : '\\222', '\223' : '\\223',
63 | '\224' : '\\224', '\225' : '\\225', '\226' : '\\226',
64 | '\227' : '\\227', '\230' : '\\230', '\231' : '\\231',
65 | '\232' : '\\232', '\233' : '\\233', '\234' : '\\234',
66 | '\235' : '\\235', '\236' : '\\236', '\237' : '\\237',
67 | '\240' : '\\240', '\241' : '\\241', '\242' : '\\242',
68 | '\243' : '\\243', '\244' : '\\244', '\245' : '\\245',
69 | '\246' : '\\246', '\247' : '\\247', '\250' : '\\250',
70 | '\251' : '\\251', '\252' : '\\252', '\253' : '\\253',
71 | '\254' : '\\254', '\255' : '\\255', '\256' : '\\256',
72 | '\257' : '\\257', '\260' : '\\260', '\261' : '\\261',
73 | '\262' : '\\262', '\263' : '\\263', '\264' : '\\264',
74 | '\265' : '\\265', '\266' : '\\266', '\267' : '\\267',
75 | '\270' : '\\270', '\271' : '\\271', '\272' : '\\272',
76 | '\273' : '\\273', '\274' : '\\274', '\275' : '\\275',
77 | '\276' : '\\276', '\277' : '\\277', '\300' : '\\300',
78 | '\301' : '\\301', '\302' : '\\302', '\303' : '\\303',
79 | '\304' : '\\304', '\305' : '\\305', '\306' : '\\306',
80 | '\307' : '\\307', '\310' : '\\310', '\311' : '\\311',
81 | '\312' : '\\312', '\313' : '\\313', '\314' : '\\314',
82 | '\315' : '\\315', '\316' : '\\316', '\317' : '\\317',
83 | '\320' : '\\320', '\321' : '\\321', '\322' : '\\322',
84 | '\323' : '\\323', '\324' : '\\324', '\325' : '\\325',
85 | '\326' : '\\326', '\327' : '\\327', '\330' : '\\330',
86 | '\331' : '\\331', '\332' : '\\332', '\333' : '\\333',
87 | '\334' : '\\334', '\335' : '\\335', '\336' : '\\336',
88 | '\337' : '\\337', '\340' : '\\340', '\341' : '\\341',
89 | '\342' : '\\342', '\343' : '\\343', '\344' : '\\344',
90 | '\345' : '\\345', '\346' : '\\346', '\347' : '\\347',
91 | '\350' : '\\350', '\351' : '\\351', '\352' : '\\352',
92 | '\353' : '\\353', '\354' : '\\354', '\355' : '\\355',
93 | '\356' : '\\356', '\357' : '\\357', '\360' : '\\360',
94 | '\361' : '\\361', '\362' : '\\362', '\363' : '\\363',
95 | '\364' : '\\364', '\365' : '\\365', '\366' : '\\366',
96 | '\367' : '\\367', '\370' : '\\370', '\371' : '\\371',
97 | '\372' : '\\372', '\373' : '\\373', '\374' : '\\374',
98 | '\375' : '\\375', '\376' : '\\376', '\377' : '\\377'
99 | }
100 |
--------------------------------------------------------------------------------
/webtest/debugapp.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | import webob
4 |
5 |
6 | __all__ = ['DebugApp', 'make_debug_app']
7 |
8 |
9 | class DebugApp:
10 | """The WSGI application used for testing"""
11 |
12 | def __init__(self, form=None, show_form=False):
13 | if form and os.path.isfile(form):
14 | fd = open(form, 'rb')
15 | self.form = fd.read()
16 | fd.close()
17 | else:
18 | self.form = form
19 | self.show_form = show_form
20 |
21 | def __call__(self, environ, start_response):
22 | req = webob.Request(environ)
23 | if req.path_info == '/form.html' and req.method == 'GET':
24 | resp = webob.Response(content_type='text/html')
25 | resp.body = self.form
26 | return resp(environ, start_response)
27 |
28 | if 'error' in req.GET:
29 | raise Exception('Exception requested')
30 |
31 | if 'errorlog' in req.GET:
32 | log = req.GET['errorlog']
33 | req.environ['wsgi.errors'].write(log)
34 |
35 | status = str(req.GET.get('status', '200 OK'))
36 |
37 | parts = []
38 | if not self.show_form:
39 | for name, value in sorted(environ.items()):
40 | if name.upper() != name:
41 | value = repr(value)
42 | parts.append(f'{name}: {value}\n')
43 |
44 | body = ''.join(parts)
45 | if not isinstance(body, bytes):
46 | body = body.encode('latin1')
47 |
48 | if req.content_length:
49 | body += b'-- Body ----------\n'
50 | body += req.body
51 | else:
52 | body = ''
53 | for name, value in req.POST.items():
54 | body += f'{name}={value}\n'
55 |
56 | if status[:3] in ('204', '304') and not req.content_length:
57 | body = ''
58 |
59 | headers = [
60 | ('Content-Type', 'text/plain'),
61 | ('Content-Length', str(len(body)))]
62 |
63 | if not self.show_form:
64 | for name, value in req.GET.items():
65 | if name.startswith('header-'):
66 | header_name = name[len('header-'):]
67 | if isinstance(header_name, str):
68 | header_name = str(header_name)
69 | header_name = header_name.title()
70 | headers.append((header_name, str(value)))
71 |
72 | resp = webob.Response()
73 | resp.status = status
74 | resp.headers.update(headers)
75 | if req.method != 'HEAD':
76 | if isinstance(body, str):
77 | resp.body = body.encode('utf8')
78 | else:
79 | resp.body = body
80 | return resp(environ, start_response)
81 |
82 |
83 | debug_app = DebugApp(form=b'''
84 | ''')
88 |
89 |
90 | def make_debug_app(global_conf, **local_conf):
91 | """An application that displays the request environment, and does
92 | nothing else (useful for debugging and test purposes).
93 | """
94 | return DebugApp(**local_conf)
95 |
--------------------------------------------------------------------------------
/webtest/ext.py:
--------------------------------------------------------------------------------
1 | __doc__ = 'webtest.ext is now in a separate package name webtest-casperjs'
2 |
3 |
4 | def casperjs(*args, **kwargs):
5 | raise ImportError(__doc__)
6 |
--------------------------------------------------------------------------------
/webtest/forms.py:
--------------------------------------------------------------------------------
1 | """Helpers to fill and submit forms."""
2 |
3 | import operator
4 | import re
5 |
6 | from bs4 import BeautifulSoup
7 | from collections import OrderedDict
8 | from webtest import utils
9 |
10 |
11 | class NoValue:
12 | pass
13 |
14 |
15 | class Upload:
16 | """
17 | A file to upload::
18 |
19 | >>> Upload('filename.txt', 'data', 'application/octet-stream')
20 |
21 | >>> Upload('filename.txt', 'data')
22 |
23 | >>> Upload("README.txt")
24 |
25 |
26 | :param filename: Name of the file to upload.
27 | :param content: Contents of the file.
28 | :param content_type: MIME type of the file.
29 |
30 | """
31 |
32 | def __init__(self, filename, content=None, content_type=None):
33 | self.filename = filename
34 | self.content = content
35 | self.content_type = content_type
36 |
37 | def __iter__(self):
38 | yield self.filename
39 | if self.content is not None:
40 | yield self.content
41 | yield self.content_type
42 | # TODO: do we handle the case when we need to get
43 | # contents ourselves?
44 |
45 | def __repr__(self):
46 | return '' % self.filename
47 |
48 |
49 | class Field:
50 | """Base class for all Field objects.
51 |
52 | .. attribute:: classes
53 |
54 | Dictionary of field types (select, radio, etc)
55 |
56 | .. attribute:: value
57 |
58 | Set/get value of the field.
59 |
60 | """
61 |
62 | classes = {}
63 |
64 | def __init__(self, form, tag, name, pos,
65 | value=None, id=None, **attrs):
66 | self.form = form
67 | self.tag = tag
68 | self.name = name
69 | self.pos = pos
70 | self._value = value
71 | self.id = id
72 | self.attrs = attrs
73 |
74 | def value__get(self):
75 | if self._value is None:
76 | return ''
77 | else:
78 | return self._value
79 |
80 | def value__set(self, value):
81 | self._value = value
82 |
83 | value = property(value__get, value__set)
84 |
85 | def force_value(self, value):
86 | """Like setting a value, except forces it (even for, say, hidden
87 | fields).
88 | """
89 | self._value = value
90 |
91 | def __repr__(self):
92 | value = f'<{self.__class__.__name__} name="{self.name}"'
93 | if self.id:
94 | value += ' id="%s"' % self.id
95 | return value + '>'
96 |
97 |
98 | class Select(Field):
99 | """Field representing ```` form element."""
100 |
101 | def __init__(self, *args, **attrs):
102 | super().__init__(*args, **attrs)
103 | self.options = []
104 | self.optionPositions = []
105 | # Undetermined yet:
106 | self.selectedIndex = None
107 | # we have no forced value
108 | self._forced_value = NoValue
109 |
110 | def force_value(self, value):
111 | """Like setting a value, except forces it (even for, say, hidden
112 | fields).
113 | """
114 | try:
115 | self.value = value
116 | self._forced_value = NoValue
117 | except ValueError:
118 | self.selectedIndex = None
119 | self._forced_value = value
120 |
121 | def select(self, value=None, text=None):
122 | if value is not None and text is not None:
123 | raise ValueError("Specify only one of value and text.")
124 |
125 | if text is not None:
126 | value = self._get_value_for_text(text)
127 |
128 | self.value = value
129 |
130 | def _get_value_for_text(self, text):
131 | for i, (option_value, checked, option_text) in enumerate(self.options):
132 | if option_text == utils.stringify(text):
133 | return option_value
134 |
135 | raise ValueError("Option with text %r not found (from %s)"
136 | % (text, ', '.join(
137 | [repr(t) for o, c, t in self.options])))
138 |
139 | def value__set(self, value):
140 | if self._forced_value is not NoValue:
141 | self._forced_value = NoValue
142 | for i, (option, checked, text) in enumerate(self.options):
143 | if option == utils.stringify(value):
144 | self.selectedIndex = i
145 | break
146 | else:
147 | raise ValueError(
148 | "Option %r not found (from %s)"
149 | % (value, ', '.join([repr(o) for o, c, t in self.options])))
150 |
151 | def value__get(self):
152 | if self._forced_value is not NoValue:
153 | return self._forced_value
154 | elif self.selectedIndex is not None:
155 | return self.options[self.selectedIndex][0]
156 | else:
157 | for option, checked, text in self.options:
158 | if checked:
159 | return option
160 | else:
161 | if self.options:
162 | return self.options[0][0]
163 |
164 | value = property(value__get, value__set)
165 |
166 |
167 | class MultipleSelect(Field):
168 | """Field representing ``