Kill classes in test_testing

tests/test_testing.py

@@ -16,242 +16,228 @@ import unittest
 from flask._compat import text_type
 
 
-class TestTestTools(object):
+def test_environ_defaults_from_config():
-
+    app = flask.Flask(__name__)
-    def test_environ_defaults_from_config(self):
+    app.testing = True
-        app = flask.Flask(__name__)
+    app.config['SERVER_NAME'] = 'example.com:1234'
-        app.testing = True
+    app.config['APPLICATION_ROOT'] = '/foo'
-        app.config['SERVER_NAME'] = 'example.com:1234'
+    @app.route('/')
-        app.config['APPLICATION_ROOT'] = '/foo'
+    def index():
-        @app.route('/')
+        return flask.request.url
-        def index():
+
-            return flask.request.url
+    ctx = app.test_request_context()
-
+    assert ctx.request.url == 'http://example.com:1234/foo/'
-        ctx = app.test_request_context()
+    with app.test_client() as c:
-        assert ctx.request.url == 'http://example.com:1234/foo/'
+        rv = c.get('/')
-        with app.test_client() as c:
+        assert rv.data == b'http://example.com:1234/foo/'
-            rv = c.get('/')
+
-            assert rv.data == b'http://example.com:1234/foo/'
+def test_environ_defaults():
-
+    app = flask.Flask(__name__)
-    def test_environ_defaults(self):
+    app.testing = True
-        app = flask.Flask(__name__)
+    @app.route('/')
-        app.testing = True
+    def index():
-        @app.route('/')
+        return flask.request.url
-        def index():
+
-            return flask.request.url
+    ctx = app.test_request_context()
-
+    assert ctx.request.url == 'http://localhost/'
-        ctx = app.test_request_context()
+    with app.test_client() as c:
-        assert ctx.request.url == 'http://localhost/'
+        rv = c.get('/')
-        with app.test_client() as c:
+        assert rv.data == b'http://localhost/'
-            rv = c.get('/')
+
-            assert rv.data == b'http://localhost/'
+def test_redirect_keep_session():
-
+    app = flask.Flask(__name__)
-    def test_redirect_keep_session(self):
+    app.secret_key = 'testing'
-        app = flask.Flask(__name__)
+
-        app.secret_key = 'testing'
+    @app.route('/', methods=['GET', 'POST'])
-
+    def index():
-        @app.route('/', methods=['GET', 'POST'])
+        if flask.request.method == 'POST':
-        def index():
+            return flask.redirect('/getsession')
-            if flask.request.method == 'POST':
+        flask.session['data'] = 'foo'
-                return flask.redirect('/getsession')
+        return 'index'
-            flask.session['data'] = 'foo'
+
-            return 'index'
+    @app.route('/getsession')
-
+    def get_session():
-        @app.route('/getsession')
+        return flask.session.get('data', '<missing>')
-        def get_session():
+
-            return flask.session.get('data', '<missing>')
+    with app.test_client() as c:
-
+        rv = c.get('/getsession')
-        with app.test_client() as c:
+        assert rv.data == b'<missing>'
-            rv = c.get('/getsession')
+
-            assert rv.data == b'<missing>'
+        rv = c.get('/')
-
+        assert rv.data == b'index'
-            rv = c.get('/')
+        assert flask.session.get('data') == 'foo'
-            assert rv.data == b'index'
+        rv = c.post('/', data={}, follow_redirects=True)
+        assert rv.data == b'foo'
+
+        # This support requires a new Werkzeug version
+        if not hasattr(c, 'redirect_client'):
             assert flask.session.get('data') == 'foo'
-            rv = c.post('/', data={}, follow_redirects=True)
-            assert rv.data == b'foo'
 
-            # This support requires a new Werkzeug version
+        rv = c.get('/getsession')
-            if not hasattr(c, 'redirect_client'):
+        assert rv.data == b'foo'
-                assert flask.session.get('data') == 'foo'
+
-
+def test_session_transactions():
-            rv = c.get('/getsession')
+    app = flask.Flask(__name__)
-            assert rv.data == b'foo'
+    app.testing = True
-
+    app.secret_key = 'testing'
-    def test_session_transactions(self):
+
-        app = flask.Flask(__name__)
+    @app.route('/')
-        app.testing = True
+    def index():
-        app.secret_key = 'testing'
+        return text_type(flask.session['foo'])
-
+
-        @app.route('/')
+    with app.test_client() as c:
-        def index():
+        with c.session_transaction() as sess:
-            return text_type(flask.session['foo'])
+            assert len(sess) == 0
-
+            sess['foo'] = [42]
-        with app.test_client() as c:
+            assert len(sess) == 1
-            with c.session_transaction() as sess:
+        rv = c.get('/')
-                assert len(sess) == 0
+        assert rv.data == b'[42]'
-                sess['foo'] = [42]
+        with c.session_transaction() as sess:
-                assert len(sess) == 1
+            assert len(sess) == 1
-            rv = c.get('/')
+            assert sess['foo'] == [42]
-            assert rv.data == b'[42]'
+
-            with c.session_transaction() as sess:
+def test_session_transactions_no_null_sessions():
-                assert len(sess) == 1
+    app = flask.Flask(__name__)
-                assert sess['foo'] == [42]
+    app.testing = True
-
+
-    def test_session_transactions_no_null_sessions(self):
+    with app.test_client() as c:
-        app = flask.Flask(__name__)
-        app.testing = True
-
-        with app.test_client() as c:
-            try:
-                with c.session_transaction() as sess:
-                    pass
-            except RuntimeError as e:
-                assert 'Session backend did not open a session' in str(e)
-            else:
-                assert False, 'Expected runtime error'
-
-    def test_session_transactions_keep_context(self):
-        app = flask.Flask(__name__)
-        app.testing = True
-        app.secret_key = 'testing'
-
-        with app.test_client() as c:
-            rv = c.get('/')
-            req = flask.request._get_current_object()
-            assert req is not None
-            with c.session_transaction():
-                assert req is flask.request._get_current_object()
-
-    def test_session_transaction_needs_cookies(self):
-        app = flask.Flask(__name__)
-        app.testing = True
-        c = app.test_client(use_cookies=False)
         try:
-            with c.session_transaction() as s:
+            with c.session_transaction() as sess:
                 pass
         except RuntimeError as e:
-            assert 'cookies' in str(e)
+            assert 'Session backend did not open a session' in str(e)
         else:
             assert False, 'Expected runtime error'
 
-    def test_test_client_context_binding(self):
+def test_session_transactions_keep_context():
-        app = flask.Flask(__name__)
+    app = flask.Flask(__name__)
-        app.config['LOGGER_HANDLER_POLICY'] = 'never'
+    app.testing = True
-        @app.route('/')
+    app.secret_key = 'testing'
-        def index():
+
-            flask.g.value = 42
+    with app.test_client() as c:
-            return 'Hello World!'
+        rv = c.get('/')
-
+        req = flask.request._get_current_object()
-        @app.route('/other')
+        assert req is not None
-        def other():
+        with c.session_transaction():
-            1 // 0
+            assert req is flask.request._get_current_object()
-
+
-        with app.test_client() as c:
+def test_session_transaction_needs_cookies():
-            resp = c.get('/')
+    app = flask.Flask(__name__)
-            assert flask.g.value == 42
+    app.testing = True
-            assert resp.data == b'Hello World!'
+    c = app.test_client(use_cookies=False)
-            assert resp.status_code == 200
+    try:
-
+        with c.session_transaction() as s:
-            resp = c.get('/other')
-            assert not hasattr(flask.g, 'value')
-            assert b'Internal Server Error' in resp.data
-            assert resp.status_code == 500
-            flask.g.value = 23
-
-        try:
-            flask.g.value
-        except (AttributeError, RuntimeError):
             pass
-        else:
+    except RuntimeError as e:
-            raise AssertionError('some kind of exception expected')
+        assert 'cookies' in str(e)
-
+    else:
-    def test_reuse_client(self):
+        assert False, 'Expected runtime error'
-        app = flask.Flask(__name__)
+
-        c = app.test_client()
+def test_test_client_context_binding():
-
+    app = flask.Flask(__name__)
-        with c:
+    app.config['LOGGER_HANDLER_POLICY'] = 'never'
-            assert c.get('/').status_code == 404
+    @app.route('/')
-
+    def index():
-        with c:
+        flask.g.value = 42
-            assert c.get('/').status_code == 404
+        return 'Hello World!'
-
+
-    def test_test_client_calls_teardown_handlers(self):
+    @app.route('/other')
-        app = flask.Flask(__name__)
+    def other():
-        called = []
+        1 // 0
-        @app.teardown_request
+
-        def remember(error):
+    with app.test_client() as c:
-            called.append(error)
+        resp = c.get('/')
-
+        assert flask.g.value == 42
-        with app.test_client() as c:
+        assert resp.data == b'Hello World!'
-            assert called == []
+        assert resp.status_code == 200
-            c.get('/')
+
-            assert called == []
+        resp = c.get('/other')
+        assert not hasattr(flask.g, 'value')
+        assert b'Internal Server Error' in resp.data
+        assert resp.status_code == 500
+        flask.g.value = 23
+
+    try:
+        flask.g.value
+    except (AttributeError, RuntimeError):
+        pass
+    else:
+        raise AssertionError('some kind of exception expected')
+
+def test_reuse_client():
+    app = flask.Flask(__name__)
+    c = app.test_client()
+
+    with c:
+        assert c.get('/').status_code == 404
+
+    with c:
+        assert c.get('/').status_code == 404
+
+def test_test_client_calls_teardown_handlers():
+    app = flask.Flask(__name__)
+    called = []
+    @app.teardown_request
+    def remember(error):
+        called.append(error)
+
+    with app.test_client() as c:
+        assert called == []
+        c.get('/')
+        assert called == []
+    assert called == [None]
+
+    del called[:]
+    with app.test_client() as c:
+        assert called == []
+        c.get('/')
+        assert called == []
+        c.get('/')
         assert called == [None]
-
+    assert called == [None, None]
-        del called[:]
+
-        with app.test_client() as c:
+def test_full_url_request():
-            assert called == []
+    app = flask.Flask(__name__)
-            c.get('/')
+    app.testing = True
-            assert called == []
+
-            c.get('/')
+    @app.route('/action', methods=['POST'])
-            assert called == [None]
+    def action():
-        assert called == [None, None]
+        return 'x'
-
+
-    def test_full_url_request(self):
+    with app.test_client() as c:
-        app = flask.Flask(__name__)
+        rv = c.post('http://domain.com/action?vodka=42', data={'gin': 43})
-        app.testing = True
+        assert rv.status_code == 200
-
+        assert 'gin' in flask.request.form
-        @app.route('/action', methods=['POST'])
+        assert 'vodka' in flask.request.args
-        def action():
+
-            return 'x'
+def test_subdomain():
-
+    app = flask.Flask(__name__)
-        with app.test_client() as c:
+    app.config['SERVER_NAME'] = 'example.com'
-            rv = c.post('http://domain.com/action?vodka=42', data={'gin': 43})
+    @app.route('/', subdomain='<company_id>')
-            assert rv.status_code == 200
+    def view(company_id):
-            assert 'gin' in flask.request.form
+        return company_id
-            assert 'vodka' in flask.request.args
+
-
+    with app.test_request_context():
-
-class TestSubdomain(object):
-
-    @pytest.fixture
-    def app(self, request):
-        app = flask.Flask(__name__)
-        app.config['SERVER_NAME'] = 'example.com'
-
-        ctx = app.test_request_context()
-        ctx.push()
-
-        def teardown():
-            if ctx is not None:
-                ctx.pop()
-        request.addfinalizer(teardown)
-        return app
-
-    @pytest.fixture
-    def client(self, app):
-        return app.test_client()
-
-    def test_subdomain(self, app, client):
-        @app.route('/', subdomain='<company_id>')
-        def view(company_id):
-            return company_id
-
         url = flask.url_for('view', company_id='xxx')
-        response = client.get(url)
 
-        assert 200 == response.status_code
+    with app.test_client() as c:
-        assert b'xxx' == response.data
+        response = c.get(url)
 
+    assert 200 == response.status_code
+    assert b'xxx' == response.data
 
-    def test_nosubdomain(self, app, client):
+def test_nosubdomain():
-        @app.route('/<company_id>')
+    app = flask.Flask(__name__)
-        def view(company_id):
+    app.config['SERVER_NAME'] = 'example.com'
-            return company_id
+    @app.route('/<company_id>')
+    def view(company_id):
+        return company_id
 
+    with app.test_request_context():
         url = flask.url_for('view', company_id='xxx')
-        response = client.get(url)
 
-        assert 200 == response.status_code
+    with app.test_client() as c:
-        assert b'xxx' == response.data
+        response = c.get(url)
+
+    assert 200 == response.status_code
+    assert b'xxx' == response.data