PR#344: Improve unit testing - fedora-hubs

		`@@ -6,6 +6,9 @@`
		`recursive-include hubs/migrations .py .mako *.rst`
		`include hubs/migrations/versions/.keep`
		`include hubs/actions.json`
		`+ include hubs/tests/*.cfg`
		`+ include hubs/tests/*.json`
		`+ graft hubs/tests/vcr-request-data`
		`graft ansible`
		`graft docs`
		`prune docs/_build`

check-cache-coverage.py

file modified

+1 -4

		`@@ -22,12 +22,9 @@`
		`import hubs.widgets.caching`
		`import hubs.models`

		`- import fedmsg.config`
		`-`
		`- config = fedmsg.config.load_config()`

		`empty, full = 0, 0`
		`- session = hubs.models.init(config['hubs.sqlalchemy.uri'])`
		`+ session = hubs.app.session`

		`# Register widgets`
		`hubs.widgets.registry.register_list(hubs.app.app.config["WIDGETS"])`

check-queue-length.py

file modified

+3 -2

		`@@ -17,8 +17,9 @@`

		`import retask`

		`- import fedmsg.config`
		`- config = fedmsg.config.load_config()`
		`+ from hubs.utils import get_fedmsg_config`
		`+`
		`+ config = get_fedmsg_config()`

		`for item in ['triage', 'work']:`
		`queue = retask.queue.Queue(config['hubs.redis.%s-queue-name' % item])`

delete-user.py

file modified

+2 -3

		`@@ -6,11 +6,10 @@`

		`from __future__ import unicode_literals, print_function`

		`- import fedmsg.config`
		`-`
		`import hubs.models`
		`+ from hubs.utils import get_fedmsg_config`

		`- fedmsg_config = fedmsg.config.load_config()`
		`+ fedmsg_config = get_fedmsg_config()`

		`session = hubs.models.init(fedmsg_config['hubs.sqlalchemy.uri'])`

docs/api/views.rst

file modified

+1 -1

		`@@ -4,6 +4,6 @@`
		`View utils`
		`----------`

		`- .. automodule:: hubs.views.utils`
		`+ .. automodule:: hubs.utils.views`
		`:members:`

hubs/app.py

file modified

+5 -8

		`@@ -5,15 +5,13 @@`
		`import os`

		`import datanommer.models`
		`- import fedmsg.config`
		`- import fedmsg.meta`
		`import flask`
		`import flask.json`
		`import munch`
		`from flask_oidc import OpenIDConnect`

		`import hubs.models`
		`- from hubs.utils import username2avatar`
		`+ from hubs.utils import get_fedmsg_config, username2avatar`

		`app = flask.Flask(__name__)`

		`@@ -32,9 +30,7 @@`
		`if 'HUBS_CONFIG' in os.environ:`
		`app.config.from_envvar('HUBS_CONFIG')`

		`- fedmsg_config = fedmsg.config.load_config()`
		`- fedmsg.meta.make_processors(**fedmsg_config)`
		`-`
		`+ fedmsg_config = get_fedmsg_config()`
		`session = hubs.models.init(`
		`fedmsg_config.get('hubs.sqlalchemy.uri', 'sqlite:///'))`
		`datanommer.models.init(`
		`@@ -98,12 +94,13 @@`
		`else:`
		`flask.g.auth = munch.Munch(logged_in=False, user=None)`

		`+`
		`# Register widgets`
		`- import hubs.widgets # noqa`
		`+ import hubs.widgets # noqa: E402`
		`hubs.widgets.registry.register_list(app.config["WIDGETS"])`

		`# Register routes`
		`- import hubs.views # noqa`
		`+ import hubs.views # noqa: E402`

		`# Add widget-specific routes`
		`hubs.widgets.registry.register_routes(app)`

hubs/backend/triage.py

file modified

+8 -12

		`@@ -27,8 +27,6 @@`
		`import random`
		`import sys`

		`- import fedmsg.config`
		`- import fedmsg.meta`
		`import retask.queue`

		`import hubs.app`
		`@@ -37,13 +35,14 @@`


		`log = logging.getLogger('hubs.backend.triage')`
		`- config = fedmsg.config.load_config()`
		`+ fedmsg_config = hubs.app.fedmsg_config`
		`+ session = hubs.app.session`


		`- def triage(session, outbound, msg):`
		`+ def triage(outbound, msg):`
		`topic = msg['topic']`

		`- for suffix in config['hubs.junk_suffixes']:`
		`+ for suffix in fedmsg_config['hubs.junk_suffixes']:`
		`if topic.endswith(suffix):`
		`log.debug(" Dropping junk %r", topic)`
		`return`
		`@@ -75,16 +74,14 @@`


		`def main(args):`
		`- logging.config.dictConfig(config['logging'])`
		`+ logging.config.dictConfig(fedmsg_config['logging'])`
		`logging.basicConfig()`

		`- fedmsg.meta.make_processors(**config)`
		`-`
		`# XXX - for flask.url_for to work`
		`hubs.app.app.config['SERVER_NAME'] = '0.0.0.0:5000'`

		`- inbound_name = config['hubs.redis.triage-queue-name']`
		`- outbound_name = config['hubs.redis.work-queue-name']`
		`+ inbound_name = fedmsg_config['hubs.redis.triage-queue-name']`
		`+ outbound_name = fedmsg_config['hubs.redis.work-queue-name']`

		`log.info("Triage proc starting. Moving from %r to %r."`
		`% (inbound_name, outbound_name))`
		`@@ -103,9 +100,8 @@`
		`"(triage backlog: %r, work backlog: %r) Working on %r %r",`
		`inbound.length, outbound.length, msg['msg_id'], msg['topic'],`
		`)`
		`- session = hubs.models.init(config['hubs.sqlalchemy.uri'])`
		`with hubs.app.app.app_context(): # so url_for works`
		`- for task in triage(session, outbound, msg):`
		`+ for task in triage(outbound, msg):`
		`log.debug(" Triage sending %r to workers." % task)`
		`outbound.enqueue(task)`
		`log.debug(" Done with triage of %r.", msg['msg_id'])`

hubs/backend/worker.py

file modified

+4 -8

		`@@ -31,8 +31,6 @@`
		`import logging.config`
		`import sys`

		`- import fedmsg.config`
		`- import fedmsg.meta`
		`import retask.queue`

		`import hubs.app`
		`@@ -41,7 +39,8 @@`


		`log = logging.getLogger('hubs.backend.worker')`
		`- config = fedmsg.config.load_config()`
		`+ fedmsg_config = hubs.app.fedmsg_config`
		`+ session = hubs.app.session`


		`def work(widget_idx, fn_name):`
		`@@ -55,7 +54,6 @@`


		`def handle(idx, fn_name):`
		`- session = hubs.models.init(config['hubs.sqlalchemy.uri'])`

		`try:`
		`with hubs.app.app.app_context(): # so url_for works`
		`@@ -69,15 +67,13 @@`


		`def main(args):`
		`- logging.config.dictConfig(config['logging'])`
		`+ logging.config.dictConfig(fedmsg_config['logging'])`
		`logging.basicConfig()`

		`- fedmsg.meta.make_processors(**config)`
		`-`
		`# XXX - for flask.url_for to work`
		`hubs.app.app.config['SERVER_NAME'] = '0.0.0.0:5000'`

		`- name = config['hubs.redis.work-queue-name']`
		`+ name = fedmsg_config['hubs.redis.work-queue-name']`
		`log.info("Worker starting, connecting to retask queue %r." % name)`
		`queue = retask.queue.Queue(name)`
		`queue.connect()`

hubs/migrations/env.py

file modified

+2 -3

		`@@ -2,13 +2,12 @@`

		`from logging.config import fileConfig`

		`- import fedmsg.config`
		`from alembic import context`
		`from sqlalchemy import create_engine, pool`


		`try:`
		`- import hubs # noqa`
		`+ import hubs`
		`except ImportError:`
		`import os`
		`import sys`
		`@@ -27,7 +26,7 @@`
		`# This line sets up loggers basically.`
		`fileConfig(context.config.config_file_name)`

		`- fedmsg_config = fedmsg.config.load_config()`
		`+ fedmsg_config = hubs.app.fedmsg_config`
		`url = fedmsg_config['hubs.sqlalchemy.uri']`
		`target_metadata = BASE.metadata`

hubs/tests/__init__.py

file modified

+49 -42

		`@@ -13,49 +13,52 @@`
		`import vcr`
		`from flask.signals import template_rendered`

		`- import hubs.models`
		`-`
		`+ here = dirname(__file__)`
		`cassette_dir = os.path.join(dirname(__file__), 'vcr-request-data')`

		`+ if "HUBS_CONFIG" not in os.environ:`
		`+ os.environ["HUBS_CONFIG"] = os.path.join(here, "hubs_test.cfg")`
		`+ if "FEDMSG_CONFIG" not in os.environ:`
		`+ os.environ["FEDMSG_CONFIG"] = os.path.join(here, "fedmsg_test.cfg")`
		`+`
		`+ import hubs.app # noqa: E402`
		`+ import hubs.models # noqa: E402`
		`+`

		`class APPTest(unittest.TestCase):`
		`+`
		`def setUp(self):`
		`- filename = os.path.join(cassette_dir, self.id())`
		`- self.vcr = vcr.use_cassette(filename, record_mode='new_episodes')`
		`+ vcr_filename = os.path.join(cassette_dir, self.id())`
		`+ self.vcr = vcr.use_cassette(vcr_filename, record_mode='new_episodes')`
		`self.vcr.__enter__()`

		`- import hubs.app`
		`- hubs.app.fedmsg_config = {`
		`- 'hubs.sqlalchemy.uri': 'sqlite://', # in memory`
		`- }`
		`hubs.app.session = hubs.models.init(`
		`hubs.app.fedmsg_config['hubs.sqlalchemy.uri'],`
		`create=True,`
		`)`
		`hubs.app.app.config['TESTING'] = True`
		`+`
		`self.app = hubs.app.app.test_client()`
		`self.app.testing = True`
		`self.session = hubs.app.session`
		`- from hubs.widgets.caching import cache`
		`- cache.configure(backend='dogpile.cache.null',`
		`- replace_existing_backend=True)`
		`+`
		`self.populate()`

		`def tearDown(self):`
		`- self.vcr.__exit__()`
		`self.session.remove()`
		`+ self.vcr.__exit__()`

		`def populate(self):`
		`for user in ['devyani7', 'dhrish', 'shalini', 'ralph', 'decause']:`
		`fullname = user.title()`
		`hubs.models.User.get_or_create(`
		`- hubs.app.session, username=user, fullname=fullname)`
		`+ self.session, username=user, fullname=fullname)`
		`saved_notif = hubs.models.SavedNotification(`
		`username=user, markup='foo', link='bar'`
		`)`
		`- hubs.app.session.add(saved_notif)`
		`+ self.session.add(saved_notif)`

		`- hubs.app.session.flush()`
		`+ self.session.flush()`

		`hub = hubs.models.Hub.by_name('ralph')`
		`widget = hubs.models.Widget(`
		`@@ -71,39 +74,21 @@`
		`hub.last_refreshed = datetime.utcnow() - timedelta(days=100)`
		`hub.last_updated = datetime.utcnow() - timedelta(days=200)`

		`- hubs.app.session.add(hub)`
		`- hubs.app.session.add(`
		`+ self.session.add(hub)`
		`+ self.session.add(`
		`hubs.models.HubConfig(hub=hub, summary="the %s team" % team))`
		`widget = hubs.models.Widget(plugin='meetings', index=11,`
		`_config=json.dumps({'calendar': team}))`
		`hub.widgets.append(widget)`
		`- hubs.app.session.commit()`
		`+ self.session.commit()`

		`# TODO - test that it is in the registry`
		`# TODO - test that it has all the things it needs`

		`- def widget_instance(self, hubname, plugin):`
		`- hub = hubs.models.Hub.by_name(hubname)`
		`- if not hub:`
		`- raise ValueError("No such hub %r" % hubname)`
		`- for widget in hub.widgets:`
		`- if widget.plugin == plugin:`
		`- return widget`
		`- raise KeyError("No such widget found for %s/%s" % (hubname, plugin))`
		`-`
		`- @staticmethod`
		`- def get_fedmsg(idx):`
		`- url = 'https://apps.fedoraproject.org/datagrepper/id'`
		`- response = requests.get(url, params=dict(id=idx))`
		`- if not bool(response):`
		`- raise IOError("Failed to talk to %r %r" % (response.url, response))`
		`- return response.json()`
		`-`
		`def check_url(self, url, user=None, code=200):`
		`with auth_set(hubs.app.app, user):`
		`- with hubs.app.app.app_context():`
		`- with captured_templates(flask.current_app) as templates:`
		`- response = self.app.get(url)`
		`+ with captured_templates(hubs.app.app) as templates:`
		`+ response = self.app.get(url)`
		`self.assertEqual(response.status_code, code)`
		`if templates:`
		`self.assertEqual(len(templates), 1)`
		`@@ -115,6 +100,24 @@`
		`return response`


		`+ def get_fedmsg(idx):`
		`+ url = 'https://apps.fedoraproject.org/datagrepper/id'`
		`+ response = requests.get(url, params=dict(id=idx))`
		`+ if not bool(response):`
		`+ raise IOError("Failed to talk to %r %r" % (response.url, response))`
		`+ return response.json()`
		`+`
		`+`
		`+ def widget_instance(hubname, plugin):`
		`+ hub = hubs.models.Hub.by_name(hubname)`
		`+ if not hub:`
		`+ raise ValueError("No such hub %r" % hubname)`
		`+ for widget in hub.widgets:`
		`+ if widget.plugin == plugin:`
		`+ return widget`
		`+ raise KeyError("No such widget found for %s/%s" % (hubname, plugin))`
		`+`
		`+`
		`@contextmanager`
		`def auth_set(APP, auth):`
		`"""`
		`@@ -137,7 +140,13 @@`
		`if not auth:`
		`g.auth = munch.Munch(logged_in=False, user=None)`

		`- with appcontext_pushed.connected_to(handler, APP):`
		`+ if flask._app_ctx_stack.top is None:`
		`+ # App context isn't pushed yet`
		`+ with appcontext_pushed.connected_to(handler, APP):`
		`+ yield`
		`+ else:`
		`+ # App context already pushed`
		`+ handler(APP)`
		`yield`


		`@@ -179,9 +188,7 @@`
		`usage.`

		`The argument is the signal emitter. When calling a core Hubs view, this is`
		- the Hubs app (``hubs.app.app`` or ``self.app.application`` if you're in an
		- :py:class:`APPTest` subclass). If you're calling a widget view, the signal
		`- emitter is the widget class, as found in the widgets registry.`
		+ the Hubs app (``hubs.app.app``).

		`Args:`
		`app: The signal emitter.`

hubs/tests/fedmsg_test.cfg

file added

+53

		`@@ -0,0 +1,53 @@`
		`+ # Fedmsg configuration for testing`
		`+`
		`+ config = {`
		`+ #'hubs.consumer.enabled': True,`
		`+ 'hubs.sqlalchemy.uri': 'sqlite://', # in memory`
		`+`
		`+ ## For communication between fedmsg-hub and the cache worker farm`
		`+ #'hubs.redis.triage-queue-name': 'fedora-hubs-triage-queue',`
		`+ #'hubs.redis.work-queue-name': 'fedora-hubs-work-queue',`
		`+`
		`+ ## Junk junk junk.. that we don't care about. Drop it!`
		`+ #'hubs.junk_suffixes': [`
		`+ # 'buildsys.tag',`
		`+ # 'buildsys.untag',`
		`+ # 'buildsys.rpm.sign',`
		`+ #],`
		`+`
		`+ 'endpoints': {`
		`+ "fedora-infrastructure": [`
		`+ "tcp://hub.fedoraproject.org:9940",`
		`+ ]`
		`+ },`
		`+`
		`+ #'datanommer.sqlalchemy.uri':`
		`+ # 'postgres://postgres:laksjdf@127.0.0.1/datanommer',`
		`+`
		`+ #'fmn.url': 'https://apps.fedoraproject.org/notifications',`
		`+`
		`+ ## Some configuration for the rule processors`
		`+ #"fmn.rules.utils.use_pkgdb2": False,`
		`+ #"fmn.rules.utils.pkgdb2_api_url": "http://209.132.184.188/api/",`
		`+ #"fmn.rules.cache": {`
		`+ # "backend": "dogpile.cache.dbm",`
		`+ # "expiration_time": 300,`
		`+ # "arguments": {`
		`+ # "filename": "/var/tmp/fmn-cache.db",`
		`+ # },`
		`+ #},`
		`+`
		`+ # No cache during testing.`
		`+ "fedora-hubs.cache": {`
		`+ "backend": "dogpile.cache.null",`
		`+ },`
		`+`
		`+ ## Run datanommer locally, just for development.`
		`+ #'datanommer.enabled': True,`
		`+ #'datanommer.sqlalchemy.url':`
		`+ # 'postgres://postgres:laksjdf@127.0.0.1/datanommer',`
		`+`
		`+ ## Only do one of these so we can try to not run out of memory.`
		`+ #'moksha.workers_per_consumer': 1,`
		`+ }`
		`+`

hubs/tests/test_authz.py

file modified

+9 -4

		`@@ -1,5 +1,6 @@`
		`from __future__ import absolute_import, unicode_literals`

		`+ from hubs.app import app`
		`from hubs.authz import ObjectAuthzMixin, AccessLevel, PERMISSIONS`
		`from hubs.tests import APPTest, FakeAuthorization`

		`@@ -18,10 +19,14 @@`

		`class AuthzTestCase(APPTest):`

		`- def run(self, args, *kwargs):`
		`- import hubs.app`
		`- with hubs.app.app.app_context():`
		`- super(AuthzTestCase, self).run(args, *kwargs)`
		`+ def setUp(self):`
		`+ super(AuthzTestCase, self).setUp()`
		`+ self.app_context = app.app_context()`
		`+ self.app_context.__enter__()`
		`+`
		`+ def tearDown(self):`
		`+ self.app_context.__exit__(None, None, None)`
		`+ super(AuthzTestCase, self).tearDown()`

		`def test_mixin_access_level_anonymous(self):`
		`obj = TestObj()`

hubs/tests/test_fedora_hubs_flask_api.py

file removed

-587

		`@@ -1,587 +0,0 @@`
		`- from __future__ import unicode_literals`
		`-`
		`- import unittest`
		`- from six.moves.urllib.parse import urlparse`
		`-`
		`- from flask import json`
		`- from werkzeug.datastructures import ImmutableMultiDict`
		`-`
		`- import hubs`
		`- from hubs import tests`
		`- from hubs.app import app`
		`-`
		`- import hubs.models`
		`-`
		`-`
		`- class HubsAPITest(hubs.tests.APPTest):`
		`-`
		`- def test_index_logged_out(self):`
		`- result = self.app.get('/', follow_redirects=False)`
		`- self.assertEqual(result.status_code, 302)`
		`- self.assertEqual(urlparse(result.location).path, "/login")`
		`-`
		`- def test_index_logged_in(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/', follow_redirects=True)`
		`- # its trying to redirect to login id.fedoraproject.org/openid`
		`- # assert the status code of the response`
		`- self.assertEqual(result.status_code, 200)`
		`- self.assertNotIn(`
		`- 'Not logged in. Click to <a href="/login">login</a>',`
		`- result.get_data(as_text=True))`
		`-`
		`- def test_hub_logged_out(self):`
		`- with tests.auth_set(app, None): # check_auth doesn't load in unittest`
		`- result = self.app.get('/ralph', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`- match_expected = r'<h5[^>]*>Ralph</h5>'`
		`- self.assertRegexpMatches(`
		`- result.get_data(as_text=True), match_expected)`
		`- str_expected = 'Not logged in.'`
		`- self.assertIn(str_expected, result.get_data(as_text=True))`
		`-`
		`- def test_groups_logged_out(self):`
		`- result = self.app.get('/groups', follow_redirects=False)`
		`- # assert the status code of the response`
		`- self.assertEqual(result.status_code, 302)`
		`- # this will redirect to fedora.login`
		`- self.assertEqual(urlparse(result.location).path, "/login")`
		`-`
		`- def test_groups_logged_in(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/groups', follow_redirects=True)`
		`- # assert the status code of the response`
		`- self.assertEqual(result.status_code, 200)`
		`- self.assertIn("ZOMG - is the Hub Of The Month!",`
		`- result.get_data(as_text=True))`
		`-`
		`- def test_hub_logged_in(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`- self.assertNotIn(`
		`- 'Not logged in. Click to <a href="/login">login</a>',`
		`- result.get_data(as_text=True))`
		`-`
		`- def test_hub_preview(self):`
		`- hub = hubs.models.Hub.by_name('ralph')`
		`- hub.config.visibility = "preview"`
		`- # Preview hubs are accessible to anonymous users (but some`
		`- # widgets may be restricted).`
		`- with tests.auth_set(app, None):`
		`- result = self.app.get('/ralph', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`-`
		`- def test_hub_private(self):`
		`- hub = hubs.models.Hub.by_name('ralph')`
		`- hub.config.visibility = "private"`
		`- self.session.commit()`
		`- # Private hubs are not accessible to anonymous users.`
		`- with tests.auth_set(app, None):`
		`- result = self.app.get('/ralph', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 403)`
		`- # But they are accessible to members.`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`-`
		`- def test_hub_json(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph/json', follow_redirects=True)`
		`- # assert the status code of the response`
		`- self.assertEqual(result.status_code, 200)`
		`- data = {`
		`- "config": {`
		`- "avatar": "https://seccdn.libravatar.org/avatar/"`
		`- "9c9f7784935381befc302fe3c814f9136e7a339"`
		`- "53d0318761669b8643f4df55c?s=312&d=retro",`
		`- 'chat_channel': None,`
		`- 'chat_domain': None,`
		`- "left_width": 8,`
		`- "summary": "Ralph",`
		`- "visibility": "public",`
		`- },`
		`- "members": ["ralph"],`
		`- "name": "ralph",`
		`- "owners": ["ralph"],`
		`- "subscribers": [],`
		`- "widgets": [37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 61],`
		`- }`
		`- self.assertDictEqual(data, json.loads(result.get_data(as_text=True)))`
		`-`
		`- def test_hub_private_json(self):`
		`- hub = hubs.models.Hub.by_name('ralph')`
		`- hub.config.visibility = "private"`
		`- self.session.commit()`
		`- # Private hubs are not accessible to anonymous users.`
		`- with tests.auth_set(app, None):`
		`- result = self.app.get('/ralph/json', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 403)`
		`- # But they are accessible to members.`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph/json', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`-`
		`- def test_hub_edit_get_logged_out(self):`
		`- with tests.auth_set(app, None):`
		`- result = self.app.get('/ralph/edit', follow_redirects=False)`
		`- self.assertEqual(result.status_code, 302)`
		`- self.assertEqual(urlparse(result.location).path, "/login")`
		`-`
		`- def test_hub_edit_get_logged_in_not_owner(self):`
		`- user = tests.FakeAuthorization('not_ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph/edit', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 403)`
		`-`
		`- def test_hub_edit_get_logged_in_owner(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph/edit', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`-`
		`- def test_hub_edit_post_logged_out(self):`
		`- with tests.auth_set(app, None):`
		`- result = self.app.post('/ralph/edit', follow_redirects=False)`
		`- self.assertEqual(result.status_code, 302)`
		`- self.assertEqual(urlparse(result.location).path, "/login")`
		`-`
		`- def test_hub_edit_post_logged_in_not_owner(self):`
		`- user = tests.FakeAuthorization('not_ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.post('/ralph/edit', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 403)`
		`-`
		`- def test_hub_edit_post_logged_in_owner_empty_data(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.post('/ralph/edit', data={},`
		`- follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`- self.assertNotIn(`
		`- 'Not logged in. Click to <a href="/login">login</a>',`
		`- result.get_data(as_text=True))`
		`- self.assertIn(`
		`- '<a href="#" class="dropdown-item">Full Name: '`
		`- 'fullname: ralph</a>', result.get_data(as_text=True))`
		`-`
		`- def test_hub_edit_post_logged_in_owner_valid_data(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- data = ImmutableMultiDict(`
		`- [('right_indexes[]', u'0'), ('right_indexes[]', u'1'),`
		`- ('right_indexes[]', u'2'), ('right_indexes[]', u'3'),`
		`- ('right_indexes[]', u'4'), ('right_indexes[]', u'5'),`
		`- ('right_indexes[]', u'6'), ('right_indexes[]', u'7'),`
		`- ('right_indexes[]', u'8'), ('right_widgets[]', u'32'),`
		`- ('right_widgets[]', u'33'), ('right_widgets[]', u'34'),`
		`- ('right_widgets[]', u'35'), ('right_widgets[]', u'36'),`
		`- ('right_widgets[]', u'37'), ('right_widgets[]', u'38'),`
		`- ('right_widgets[]', u'39'), ('right_widgets[]', u'40'),`
		`- ('js', u'true'), ('left_indexes[]', u'0'),`
		`- ('left_indexes[]', u'1'), ('left_widgets[]', u'31'),`
		`- ('left_widgets[]', u'32')])`
		`- result = self.app.post('/ralph/edit', data=data,`
		`- follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`- self.assertEqual(result.get_data(as_text=True), 'ok')`
		`-`
		`- def test_hub_edit_post_logged_in_owner_invalid_data_1(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- # some indexes and widgets are not integers`
		`- data = ImmutableMultiDict(`
		`- [('right_indexes[]', u'0a'), ('right_indexes[]', u'1'),`
		`- ('right_indexes[]', u'2'), ('right_indexes[]', u'3'),`
		`- ('right_indexes[]', u'4'), ('right_indexes[]', u'5'),`
		`- ('right_indexes[]', u'6'), ('right_indexes[]', u'7'),`
		`- ('right_indexes[]', u'8'), ('right_widgets[]', u'32'),`
		`- ('right_widgets[]', u'33a'), ('right_widgets[]', u'34'),`
		`- ('right_widgets[]', u'35'), ('right_widgets[]', u'36'),`
		`- ('right_widgets[]', u'37'), ('right_widgets[]', u'38'),`
		`- ('right_widgets[]', u'39'), ('right_widgets[]', u'40'),`
		`- ('js', u'true'), ('left_indexes[]', u'0a'),`
		`- ('left_indexes[]', u'1'), ('left_widgets[]', u'31a'),`
		`- ('left_widgets[]', u'32')])`
		`- result = self.app.post('/ralph/edit', data=data,`
		`- follow_redirects=True)`
		`- self.assertEqual(result.status_code, 400)`
		`-`
		`- def test_hub_edit_post_logged_in_owner_invalid_data_2(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- # indexes len don't match widgets len`
		`- data = ImmutableMultiDict(`
		`- [('right_indexes[]', u'1'), ('right_indexes[]', u'2'),`
		`- ('right_indexes[]', u'3'), ('right_indexes[]', u'4'),`
		`- ('right_indexes[]', u'5'), ('right_indexes[]', u'6'),`
		`- ('right_indexes[]', u'7'), ('right_indexes[]', u'8'),`
		`- ('right_widgets[]', u'32'), ('right_widgets[]', u'34'),`
		`- ('right_widgets[]', u'35'), ('right_widgets[]', u'36'),`
		`- ('right_widgets[]', u'37'), ('right_widgets[]', u'38'),`
		`- ('right_widgets[]', u'39'), ('right_widgets[]', u'40'),`
		`- ('js', u'true'), ('left_indexes[]', u'0'),`
		`- ('left_indexes[]', u'1'), ('left_widgets[]', u'32')])`
		`- result = self.app.post('/ralph/edit', data=data,`
		`- follow_redirects=True)`
		`- self.assertEqual(result.status_code, 400)`
		`-`
		`- def test_login_already_loggedin(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/login', follow_redirects=False)`
		`- self.assertEqual(result.status_code, 302)`
		`- self.assertEqual(`
		`- urlparse(result.location).path,`
		`- "/openidc/Authorization")`
		`-`
		`- def test_hub_add_widget_get_no_args(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph/add', follow_redirects=False)`
		`- self.assertEqual(result.status_code, 400)`
		`- expected_str = 'Invalid position provided'`
		`- self.assertIn(expected_str, result.get_data(as_text=True))`
		`-`
		`- def test_hub_add_widget_get_with_args(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph/add?position=right',`
		`- follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`- page_html = result.get_data(as_text=True)`
		`- self.assertIn('Adding a widget to hub: ralph', page_html)`
		`- self.assertIn('<form method="post" action="/ralph/add">', page_html)`
		`- self.assertIn('<input type="hidden" name="position" value="right" />',`
		`- page_html)`
		`-`
		`- def test_hub_add_widget_post_no_widget_name(self):`
		`- data = {"position": "left"}`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.post(`
		`- '/ralph/add', data=data, follow_redirects=False)`
		`- self.assertEqual(result.status_code, 400)`
		`- expected_str = 'Invalid request sent'`
		`- self.assertIn(expected_str, result.get_data(as_text=True))`
		`-`
		`- def test_hub_add_widget_post_invalid_widget_name(self):`
		`- data = {'widget': 'invalid_widget_name',`
		`- 'position': 'right'}`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.post(`
		`- '/ralph/add', data=data, follow_redirects=False)`
		`- self.assertEqual(result.status_code, 404)`
		`- expected_str = 'Unknown widget called'`
		`- self.assertIn(expected_str, result.get_data(as_text=True))`
		`-`
		`- def test_hub_add_widget_post_valid_widget_name_no_args(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- data = {`
		`- 'widget': 'memberships',`
		`- 'position': 'right',`
		`- }`
		`- result = self.app.post('/ralph/add', data=data)`
		`- self.assertEqual(result.status_code, 200)`
		`- self.assertEqual(`
		`- json.loads(result.get_data(as_text=True)),`
		`- {"status": "ADDED"})`
		`- result = self.app.get('/ralph/edit')`
		`- self.assertEqual(result.status_code, 200)`
		`- page_html = result.get_data(as_text=True)`
		`- self.assertIn('data-url="/ralph/w/memberships/', page_html)`
		`-`
		`- def test_hub_add_widget_post_valid_widget_name_with_args(self):`
		`- self.assertEqual(`
		`- hubs.models.Widget.query.filter(`
		`- hubs.models.Hub.name == "ralph",`
		`- hubs.models.Widget.plugin == "about",`
		`- ).count(), 1)`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- data = {`
		`- 'text': 'text of widget',`
		`- 'position': 'right',`
		`- }`
		`- result = self.app.post('/ralph/add/about', data=data,`
		`- follow_redirects=False)`
		`- self.assertEqual(result.status_code, 200)`
		`- self.assertEqual(`
		`- json.loads(result.get_data(as_text=True)),`
		`- {"status": "ADDED"})`
		`- self.assertEqual(`
		`- hubs.models.Widget.query.filter(`
		`- hubs.models.Hub.name == "ralph",`
		`- hubs.models.Widget.plugin == "about",`
		`- ).count(), 2)`
		`-`
		`- def test_hub_edit_widget_get_logged_in(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- result = self.app.get('/ralph/37/edit', follow_redirects=True)`
		`- self.assertEqual(result.status_code, 200)`
		`- expected_str = '/ralph/37/edit'`
		`- self.assertIn(expected_str, result.get_data(as_text=True))`
		`-`
		`- def test_hub_edit_widget_get_logged_out(self):`
		`- result = self.app.get('/ralph/31/edit', follow_redirects=False)`
		`- self.assertEqual(result.status_code, 302)`
		`- self.assertEqual(urlparse(result.location).path, "/login")`
		`-`
		`- def test_hub_edit_widget_post_empty_data_logged_in(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- data = {}`
		`- url = '/ralph/37/edit'`
		`- result = self.app.post(url, data=data, follow_redirects=False)`
		`- self.assertEqual(result.status_code, 302)`
		`- self.assertEqual(urlparse(result.location).path, '/ralph/edit')`
		`-`
		`- def test_hub_visit_counter_logged_in(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/visit/decause'`
		`- result = self.app.get(url)`
		`- self.assertEqual(`
		`- json.loads(result.get_data(as_text=True)),`
		`- {"count": 0})`
		`-`
		`- result = self.app.post(url)`
		`- self.assertEqual(`
		`- json.loads(result.get_data(as_text=True)),`
		`- {"count": 1})`
		`-`
		`- # accessing my hub shouldn't increment the count`
		`- url = 'visit/ralph'`
		`- result = self.app.post(url)`
		`- self.assertEqual(result.status_code, 403)`
		`-`
		`- # visiting no hub while logged should throw a 405`
		`- url = 'visit/'`
		`- result = self.app.post(url)`
		`- self.assertEqual(result.status_code, 405)`
		`-`
		`- # visiting a hub that doesn't exist should 404`
		`- url = 'visit/hub-does-not-exist'`
		`- result = self.app.post(url)`
		`- self.assertEqual(result.status_code, 404)`
		`-`
		`- @unittest.skip("Ajax calls don't seem to work in unittests ")`
		`- def test_hub_vist_counter_logged_in_2(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/visit/decause'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.get_data(as_text=True), '0')`
		`-`
		`- url = '/decause'`
		`- result = self.app.get(url, follow_redirects=True)`
		`-`
		`- url = '/visit/decause'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.get_data(as_text=True), '1')`
		`-`
		`- def test_hub_add_widget_valid_side(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/add/about?position=right'`
		`- result = self.app.get(url)`
		`- self.assertIn('Adding widget "about" to hub ralph',`
		`- result.get_data(as_text=True))`
		`-`
		`- def test_hub_add_widget_invalid_side(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/add/about?position=invalid'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 400)`
		`-`
		`- def test_hub_delete(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/37/delete' # 37 is widget fedmsgstats for ralph`
		`- result = self.app.post(url)`
		`- self.assertEqual(result.status_code, 302)`
		`- self.assertIn('/ralph/edit', result.get_data(as_text=True))`
		`-`
		`- def test_source_name(self):`
		`- with tests.auth_set(app, None):`
		`- url = '/source/about'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 302)`
		`- expected_str = 'https://pagure.io/fedora-hubs/' \`
		`- 'blob/develop/f/hubs/widgets/about/__init__.py'`
		`- self.assertIn(expected_str, result.get_data(as_text=True))`
		`-`
		`- def test_source_name_not_existent(self):`
		`- with tests.auth_set(app, None):`
		`- url = '/source/notexistent'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 404)`
		`-`
		`- def test_hub_config_get(self):`
		`- expected = {`
		`- "hubconfig": {`
		`- "summary": "Ralph",`
		`- "left_width": 8,`
		`- "avatar": (`
		`- "https://seccdn.libravatar.org/avatar/9c9f7784935381befc30"`
		`- "2fe3c814f9136e7a33953d0318761669b8643f4df55c"`
		`- "?s=312&d=retro"`
		`- ),`
		`- "chat_channel": None,`
		`- "chat_domain": None,`
		`- "visibility": "public",`
		`- },`
		`- "general": {`
		`- "chat_networks": app.config["CHAT_NETWORKS"],`
		`- "roles": ["owner", "member"],`
		`- "hub_visibility": hubs.models.HubConfig.VISIBILITY,`
		`- },`
		`- "users": {`
		`- "member": [],`
		`- "owner": [{`
		`- "fullname": "Ralph",`
		`- "locked": True,`
		`- "role": "owner",`
		`- "username": "ralph",`
		`- }],`
		`- },`
		`- }`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/config'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 200)`
		`- result_data = json.loads(result.get_data(as_text=True))`
		`- self.assertEqual(result_data["status"], "OK")`
		`- self.assertDictEqual(result_data["result"], expected)`
		`-`
		`- def test_hub_config_post(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/config?category=config'`
		`- result = self.app.post(url, data={`
		`- "summary": "changed value",`
		`- "chat_domain": "",`
		`- })`
		`- self.assertEqual(result.status_code, 200)`
		`- result_data = json.loads(result.get_data(as_text=True))`
		`- self.assertEqual(result_data["status"], "OK")`
		`- self.assertEqual(`
		`- result_data["result"]["hubconfig"]["summary"],`
		`- "changed value")`
		`- self.assertEqual(`
		`- result_data["result"]["hubconfig"]["chat_domain"],`
		`- app.config["CHAT_NETWORKS"][0]["domain"])`
		`-`
		`- def test_hub_config_post_unknown_post_data(self):`
		`- # Unknown POST data is silently ignored`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/config?category=config'`
		`- result = self.app.post(url, data={"non_existant": "dummy"})`
		`- self.assertEqual(result.status_code, 200)`
		`- result_data = json.loads(result.get_data(as_text=True))`
		`- self.assertEqual(result_data["status"], "ERROR")`
		`- self.assertEqual(result_data["message"], "Invalid value(s)")`
		`- self.assertIn("non_existant", result_data["fields"])`
		`- self.assertEqual(`
		`- result_data["fields"]["non_existant"],`
		`- "Unexpected parameter."`
		`- )`
		`-`
		`- def test_hub_config_post_invalid_chat_domain(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/config?category=config'`
		`- result = self.app.post(url, data={"chat_domain": "dummy"})`
		`- self.assertEqual(result.status_code, 200)`
		`- result_data = json.loads(result.get_data(as_text=True))`
		`- self.assertEqual(result_data["status"], "ERROR")`
		`- self.assertEqual(result_data["message"], "Invalid value(s)")`
		`- self.assertIn("chat_domain", result_data["fields"])`
		`- self.assertEqual(`
		`- result_data["fields"]["chat_domain"],`
		`- "Unsupported chat domain."`
		`- )`
		`-`
		`- def test_hub_config_get_unauthorized(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/decause/config'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 403)`
		`-`
		`- def test_hub_config_post_unauthorized(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- with tests.auth_set(app, user):`
		`- url = '/decause/config?category=config'`
		`- result = self.app.post(url, data={"summary": "Defaced!"})`
		`- self.assertEqual(result.status_code, 403)`
		`-`
		`- def test_hub_config_suggest_users_no_filter(self):`
		`- user = tests.FakeAuthorization('ralph')`
		`- expected = [`
		`- u.username for u in`
		`- hubs.models.User.query.order_by(`
		`- hubs.models.User.username`
		`- ).all()]`
		`- # Check without filter`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/config/suggest-users'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 200)`
		`- result_data = json.loads(result.get_data(as_text=True))`
		`- self.assertEqual(result_data["status"], "OK")`
		`- self.assertListEqual(result_data["results"], expected)`
		`-`
		`- def test_hub_config_suggest_users_filter_owners(self):`
		`- # Filters on owners`
		`- user = tests.FakeAuthorization('ralph')`
		`- expected = [`
		`- u.username for u in`
		`- hubs.models.User.query.order_by(`
		`- hubs.models.User.username`
		`- ).filter(`
		`- hubs.models.User.username != "ralph"`
		`- ).all()]`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/config/suggest-users?exclude-role=owner'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 200)`
		`- result_data = json.loads(result.get_data(as_text=True))`
		`- self.assertEqual(result_data["status"], "OK")`
		`- self.assertListEqual(result_data["results"], expected)`
		`-`
		`- def test_hub_config_suggest_users_filter_members(self):`
		`- # Filters on members`
		`- user = tests.FakeAuthorization('ralph')`
		`- hub = hubs.models.Hub.get('ralph')`
		`- decause = hubs.models.User.query.get("decause")`
		`- devyani7 = hubs.models.User.query.get("devyani7")`
		`- hub.subscribe(decause, "member")`
		`- hub.subscribe(devyani7, "member")`
		`- expected = [`
		`- u.username for u in`
		`- hubs.models.User.query.order_by(`
		`- hubs.models.User.username`
		`- ).filter(`
		`- hubs.models.User.username != "decause",`
		`- hubs.models.User.username != "devyani7"`
		`- ).all()]`
		`- with tests.auth_set(app, user):`
		`- url = '/ralph/config/suggest-users?exclude-role=member'`
		`- result = self.app.get(url)`
		`- self.assertEqual(result.status_code, 200)`
		`- result_data = json.loads(result.get_data(as_text=True))`
		`- self.assertEqual(result_data["status"], "OK")`
		`- self.assertListEqual(result_data["results"], expected)`

hubs/tests/test_models.py

file modified

-4

		`@@ -1,14 +1,10 @@`
		`from __future__ import unicode_literals`

		`- import fedmsg.config`
		`-`
		`import hubs`
		`import hubs.models`
		`import hubs.tests`
		`from hubs.authz import AccessLevel`

		`- fedmsg_config = fedmsg.config.load_config()`
		`-`

		`class ModelTest(hubs.tests.APPTest):`
		`def test_delete_user(self):`

hubs/tests/test_view_utils.py

file modified

+23 -19

		`@@ -1,21 +1,30 @@`
		`from __future__ import unicode_literals`

		`import hubs.models`
		`+ from hubs.app import app`
		`from hubs.tests import APPTest, FakeAuthorization, auth_set`
		`- from hubs.views.utils import get_visible_widgets`
		`+ from hubs.utils.views import get_visible_widgets`


		`class ViewUtilsTest(APPTest):`

		`+ def setUp(self):`
		`+ super(ViewUtilsTest, self).setUp()`
		`+ self.app_context = app.app_context()`
		`+ self.app_context.__enter__()`
		`+`
		`+ def tearDown(self):`
		`+ self.app_context.__exit__(None, None, None)`
		`+ super(ViewUtilsTest, self).tearDown()`
		`+`
		`def test_removed_widget(self):`
		`hub = hubs.models.Hub.get("ralph")`
		`widget = hubs.models.Widget(`
		`hub=hub, plugin="does-not-exist",`
		`left=True, index=-1, _config="{}")`
		`self.session.add(widget)`
		`- with auth_set(self.app.application, FakeAuthorization('ralph')):`
		`- with self.app.application.app_context():`
		`- widgets = get_visible_widgets(hub)`
		`+ with auth_set(app, FakeAuthorization('ralph')):`
		`+ widgets = get_visible_widgets(hub)`
		`self.assertNotIn(`
		`"does-not-exist", [w.plugin for w in widgets["left"]])`
		`widget.left = False`
		`@@ -24,9 +33,8 @@`

		`def test_get_visible_widgets(self):`
		`hub = hubs.models.Hub.get('ralph')`
		`- with auth_set(self.app.application, None):`
		`- with self.app.application.app_context():`
		`- widgets = get_visible_widgets(hub)`
		`+ with auth_set(app, None):`
		`+ widgets = get_visible_widgets(hub)`
		`self.assertListEqual(`
		`[w.plugin for w in widgets["left"]],`
		`["feed"])`
		`@@ -48,15 +56,13 @@`
		`meetings.visibility = "restricted"`
		`# Restricted widgets in preview hubs aren't displayed to`
		`# anonymous users.`
		`- with auth_set(self.app.application, None):`
		`- with self.app.application.app_context():`
		`- widgets = get_visible_widgets(hub)`
		`+ with auth_set(app, None):`
		`+ widgets = get_visible_widgets(hub)`
		`self.assertNotIn(`
		`"meetings", [w.plugin for w in widgets["right"]])`
		`# But they are displayed to members.`
		`- with auth_set(self.app.application, FakeAuthorization('ralph')):`
		`- with self.app.application.app_context():`
		`- widgets = get_visible_widgets(hub)`
		`+ with auth_set(app, FakeAuthorization('ralph')):`
		`+ widgets = get_visible_widgets(hub)`
		`self.assertIn(`
		`"meetings", [w.plugin for w in widgets["right"]])`

		`@@ -69,14 +75,12 @@`
		`assert meetings.left is False`
		`# Widgets in private hubs aren't displayed to`
		`# anonymous users.`
		`- with auth_set(self.app.application, None):`
		`- with self.app.application.app_context():`
		`- widgets = get_visible_widgets(hub)`
		`+ with auth_set(app, None):`
		`+ widgets = get_visible_widgets(hub)`
		`self.assertEqual(widgets["left"], [])`
		`self.assertEqual(widgets["right"], [])`
		`# But they are displayed to members.`
		`- with auth_set(self.app.application, FakeAuthorization('ralph')):`
		`- with self.app.application.app_context():`
		`- widgets = get_visible_widgets(hub)`
		`+ with auth_set(app, FakeAuthorization('ralph')):`
		`+ widgets = get_visible_widgets(hub)`
		`self.assertNotEqual(len(widgets["left"]), 0)`
		`self.assertNotEqual(len(widgets["right"]), 0)`

hubs/tests/test_widget_base.py

file modified

+14 -20

		`@@ -1,14 +1,14 @@`
		`from __future__ import unicode_literals`

		`import six`
		`+ from mock import Mock`

		`+ from hubs.app import app`
		`+ from hubs.tests import APPTest`
		`from hubs.widgets.base import Widget`
		`from hubs.widgets.caching import CachedFunction`
		`from hubs.widgets.view import WidgetView`

		`- from mock import Mock`
		`- from hubs.tests import APPTest`
		`-`

		`class TestingWidget(Widget):`
		`name = "testing"`
		`@@ -28,14 +28,14 @@`
		`super(WidgetTest, self).setUp()`
		`# Backup the URL map`
		`self._old_url_map = (`
		`- self.app.application.url_map._rules[:],`
		`- self.app.application.url_map._rules_by_endpoint.copy()`
		`+ app.url_map._rules[:],`
		`+ app.url_map._rules_by_endpoint.copy()`
		`)`

		`def tearDown(self):`
		`# Restore the URL map`
		`- self.app.application.url_map._rules = self._old_url_map[0]`
		`- self.app.application.url_map._rules_by_endpoint = self._old_url_map[1]`
		`+ app.url_map._rules = self._old_url_map[0]`
		`+ app.url_map._rules_by_endpoint = self._old_url_map[1]`
		`super(WidgetTest, self).tearDown()`

		`def test_validate(self):`
		`@@ -126,23 +126,17 @@`
		`"root": TestView1(testing_widget),`
		`"test2": TestView2(testing_widget),`
		`}`
		`- testing_widget.register_routes(self.app.application)`
		`+ testing_widget.register_routes(app)`
		`# TestView1`
		`- self.assertIn("testing_root",`
		`- self.app.application.url_map._rules_by_endpoint)`
		`- self.assertIn("testing_root", self.app.application.view_functions)`
		`- rules = list(`
		`- self.app.application.url_map.iter_rules(endpoint="testing_root")`
		`- )`
		`+ self.assertIn("testing_root", app.url_map._rules_by_endpoint)`
		`+ self.assertIn("testing_root", app.view_functions)`
		`+ rules = list(app.url_map.iter_rules(endpoint="testing_root"))`
		`self.assertEqual(len(rules), 2)`
		`self.assertEqual(rules[0].rule, "/<hub>/w/testing/<int:idx>/")`
		`self.assertEqual(rules[1].rule, "/<hub>/w/testing/<int:idx>/test-1/")`
		`# TestView2`
		`- self.assertIn("testing_test2",`
		`- self.app.application.url_map._rules_by_endpoint)`
		`- self.assertIn("testing_test2", self.app.application.view_functions)`
		`- rules = list(`
		`- self.app.application.url_map.iter_rules(endpoint="testing_test2")`
		`- )`
		`+ self.assertIn("testing_test2", app.url_map._rules_by_endpoint)`
		`+ self.assertIn("testing_test2", app.view_functions)`
		`+ rules = list(app.url_map.iter_rules(endpoint="testing_test2"))`
		`self.assertEqual(len(rules), 1)`
		`self.assertEqual(rules[0].rule, "/<hub>/w/testing/<int:idx>/test-2")`

hubs/tests/vcr-request-data/hubs.tests.widgets.test_about.TestBadges.test_data_simple ~~hubs/tests/vcr-request-data/hubs.tests.test_widgets.test_about.TestBadges.test_data_simple~~

file renamed