def setUp(self, fake_plugin_middleware=lambda: None, ictv_middleware=lambda: None): super().setUp(fake_plugin_middleware, ictv_middleware) building = Building(name="mytestbuilding") self.screen = Screen(name="mytestscreen", building=building, secret="secret") self.other_screen = Screen(name="myothertestscreen", building=building, secret="secret") self.plugins = [Plugin(name="%s%d" % (self.plugin_name, i), activated="yes") for i in range(self.n_elements - 1)] self.plugins.append(Plugin.selectBy(name="fake_plugin").getOne()) self.plugin_channels = [PluginChannel(name="%s%d" % (self.plugin_channel_name, i), plugin=self.plugins[i], subscription_right="public") for i in range(self.n_elements)] self.bundle_channels = [ChannelBundle(name="%s%d" % (self.bundle_channel_name, i), subscription_right="public") for i in range(self.n_elements)] other_channel = PluginChannel(name="other_channel", plugin=self.plugins[0], subscription_right="public") User(email=self.user_nothing_email, disabled=False) User(email=self.user_administrator_email, disabled=False, admin=True) User(email=self.user_super_administrator_email, disabled=False, admin=True, super_admin=True) screen_owner = User(email=self.user_screen_owner_email, disabled=False) self.screen.safe_add_user(screen_owner) other_screen_owner = User(email=self.user_other_screen_owner_email, disabled=False) self.other_screen.safe_add_user(other_screen_owner) contributor = User(email=self.user_contributor_email, disabled=False) [plugin_channel.give_permission_to_user(contributor) for plugin_channel in self.plugin_channels] contributor_other_channel = User(email=self.user_contributor_of_other_channel_email, disabled=False) other_channel.give_permission_to_user(contributor_other_channel) administrator_other_channel = User(email=self.user_administrator_of_other_channel_email, disabled=False) other_channel.give_permission_to_user(administrator_other_channel, UserPermissions.channel_administrator) channel_admin = User(email=self.user_channel_admin_email, disabled=False) [plugin_channel.give_permission_to_user(channel_admin, UserPermissions.channel_administrator) for plugin_channel in self.plugin_channels]
def tearDown(self): [plugin_channel.destroySelf() for plugin_channel in self.plugin_channels] [bundle_channel.destroySelf() for bundle_channel in self.bundle_channels] for email in [self.user_nothing_email, self.user_contributor_email, self.user_channel_admin_email, self.user_administrator_email, self.user_super_administrator_email]: User.deleteBy(email=email) Plugin.deleteBy(name=self.plugin_name) super().tearDown()
def _pre_app_start(self): self.channel = PluginChannel( plugin=Plugin.selectBy(name='editor').getOne(), name='Editor API', subscription_right='public') self.channel2 = PluginChannel( plugin=Plugin.selectBy(name='editor').getOne(), name='Editor API 2', subscription_right='public', plugin_config={ 'enable_rest_api': True, 'api_key': 'aaaaaaaa' })
def instantiate_plugins(self, app): """ Iterates over the plugins present in the plugin directory and instantiate each of them. :param app: The ICTV Core web.py app """ # two alternatives : select activated plugins and then query on PluginChannel to get the channel number # or select all channels and add mapping if its plugin is activated. Plugin.update_plugins(self.list_plugins()) # Updates plugins database plugins = [p for p in Plugin.select() if p.channels] # PluginChannel.select().throughTo.plugin.distinct() is not working a.t.m., see https://github.com/sqlobject/sqlobject/issues/137 for p in plugins: if p.activated == 'yes': self.instantiate_plugin(app, p) elif p.activated == 'no': self.missing_dependencies[p.name] = self.get_plugin_missing_dependencies(p.name)
def tearDown(self): try: Building.delete(self.building_id) Building.delete(self.building2_id) except SQLObjectNotFound: pass for email in [ self.user_nothing_email, self.user_contributor_email, self.user_channel_admin_email, self.user_administrator_email, self.user_super_administrator_email ]: User.deleteBy(email=email) self.channel.destroySelf() Plugin.deleteBy(name="dummy") super().tearDown()
def f(): p = Plugin.selectBy(name='fake_plugin').getOne() p.activated = 'yes' p.channels_params['this_parameter_does_not_exists'] = None p.channels_params = p.channels_params # Force SQLObject update PluginParamAccessRights(plugin=p, name='this_parameter_does_not_exists')
def get_logger(plugin_name, channel=None): """ Returns a Python Logger for plugins already configured with a FileHandler outputting the login the plugin directory. If a channel is provided, the default formatting outputs its name and id in a unified way for all plugins. """ # TODO: handle name interferences with core loggers logger_name = plugin_name + ('_plugin' if not channel else '_channels') logger = logging.getLogger(logger_name) logger.setLevel(logging.INFO) if not channel: formatter = logging.Formatter('%(levelname)s : %(asctime)s - %(message)s') else: formatter = logging.Formatter( '%(levelname)s : %(asctime)s [PluginChannel %(channel_name)s (%(channel_id)s)] - %(message)s') dirname = Plugin.selectBy(name=plugin_name).getOne().package_path if os.path.isdir(os.path.join(dirname)): if not logger.hasHandlers(): logger_file_path = os.path.join(dirname, logger_name + os.path.extsep + 'log') file_handler = logging.FileHandler(logger_file_path) file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.addHandler(StatHandler(logger_name, logger_file_path)) return logger else: raise Exception('the plugin with name %s is not a valid plugin' % plugin_name)
def render_page(self): current_user = User.get(self.session['user']['id']) plugin_dirs = self.plugin_manager.list_plugins() plugins = Plugin.update_plugins(plugin_dirs) return self.renderer.plugins(plugins=plugins, missing_dependencies=self.plugin_manager.missing_dependencies, current_user=current_user)
def runTest(self): """ Tests the Role object. """ try: u = User(username='******', fullname='test test', email='*****@*****.**', super_admin=True, disabled=False) PluginChannel(name='test', plugin=Plugin(name='role_plugin', activated='no'), subscription_right='restricted') c = PluginChannel.selectBy(name="test").getOne() r = Role(user=u, channel=c, permission_level=UserPermissions.channel_contributor) assert_true(r != None) assert_true( r.permission_level == UserPermissions.channel_contributor) r.permission_level = UserPermissions.channel_administrator assert_true( r.permission_level == UserPermissions.channel_administrator) Role.delete(r.id) role = Role.selectBy(user=u, channel=c).getOne(None) assert_true(role == None) PluginChannel.delete(c.id) User.delete(u.id) except DuplicateEntryError: assert_true(False)
def runTest(self): """ Tests the channel details page. """ PluginChannel(name='A', plugin=Plugin(name='fake_plugin', activated='notfound'), subscription_right='public') self.channels_1() self.channels_1_request()
def runTest(self): """ Tests the ChannelBundle SQLObject """ fake_plugin = Plugin.byName('fake_plugin') fake_plugin.cache_activated_default = False pc1 = PluginChannel(name='Channel1', plugin=fake_plugin, subscription_right='public') pc2 = PluginChannel(name='Channel2', plugin=fake_plugin, subscription_right='public') pc3 = PluginChannel(name='Channel3', plugin=fake_plugin, subscription_right='public') channel_bundle = ChannelBundle(name='Channel Bundle', subscription_right='public') channel_bundle2 = ChannelBundle(name='Channel Bundle 2', subscription_right='public') channel_bundle3 = ChannelBundle(name='Channel Bundle 3', subscription_right='public') # Test basic functionality channel_bundle.add_channel(pc1) channel_bundle.add_channel(pc1) channel_bundle.add_channel(pc2) channel_bundle.add_channel(pc2) channel_bundle.add_channel(pc3) channel_bundle.add_channel(pc3) assert list(channel_bundle.flatten()) == [pc1, pc2, pc3] channel_bundle.remove_channel(pc2) assert list(channel_bundle.flatten()) == [pc1, pc3] bundle_content = [ self.ictv_app.plugin_manager.get_plugin_content(pc) for pc in channel_bundle.flatten() ] channels_content = [ self.ictv_app.plugin_manager.get_plugin_content(pc1), self.ictv_app.plugin_manager.get_plugin_content(pc3) ] for content1, content2 in zip(bundle_content, channels_content): capsule1 = content1[0] capsule2 = content2[0] assert capsule1 == capsule2 channel_bundle.remove_channel(pc2) channel_bundle.remove_channel(pc3) channel_bundle.remove_channel(pc1) assert list(channel_bundle.flatten()) == [] assert channel_bundle.get_type_name() == 'Bundle' # Test cycle detection channel_bundle.add_channel(channel_bundle2) channel_bundle2.add_channel(channel_bundle3) with pytest.raises(ValueError): channel_bundle3.add_channel(channel_bundle) with pytest.raises(ValueError): channel_bundle.add_channel(channel_bundle)
def setUp( self ): # This test duplicates a lot of setUp code, it should be refactored or dropped from ictv.app import get_app from ictv.database import setup_database, create_database, load_plugins from ictv.plugin_manager.plugin_manager import PluginManager from paste.fixture import TestApp create_fake_plugin(self.fake_plugin_root) setup_database() create_database() load_plugins() Plugin.selectBy(name='fake_plugin').getOne().activated = 'notfound' Plugin.update_plugins(PluginManager.list_plugins()) self.ictv_app = get_app("/tmp/config.yaml") self.testApp = TestApp(self.ictv_app.wsgifunc())
def post(self): """ Handles plugin editing and activation. """ form = self.form try: if form.action == 'check_dependencies': self.plugin_manager.check_all_plugins_dependencies() else: plugin_id = int(form.id) p = Plugin.get(plugin_id) current_user = User.get(self.session['user']['id']) if form.action == 'edit': state = 'yes' if 'state' in form and form.state == 'on' else 'no' try: form.name = p.name if p.activated == 'notfound': raise ImmediateFeedback('general', 'plugin_activate_not_found') p.set(activated=state) if p.activated == 'yes': if self.plugin_manager.instantiate_plugin(self.app, p): add_feedback('general', 'plugin_activated') else: raise ImmediateFeedback('general', 'plugin_activation_error') else: add_feedback('general', 'plugin_disabled') except (SQLObjectNotFound, ValueError): raise ImmediateFeedback(form.action, 'invalid_id') elif form.action == 'configure': try: for param in p.params_access_rights: param.channel_contributor_read = form.get(param.name + '-cc-r') == 'on' param.channel_contributor_write = form.get(param.name + '-cc-w') == 'on' param.channel_administrator_read = form.get(param.name + '-ca-r') == 'on' param.channel_administrator_write = form.get(param.name + '-ca-w') == 'on' param.administrator_write = form.get(param.name + '-a-r') == 'on' param.administrator_write = form.get(param.name + '-a-w') == 'on' p.cache_activated_default = form.get('cache-activated') == 'on' if 'cache-validity' in form: p.cache_validity_default = int(form['cache-validity']) p.keep_noncomplying_capsules_default = form.get('keep-capsules') == 'on' p.drop_silently_non_complying_slides_default = form.get('drop-silently') == 'on' form.name = p.name add_feedback('general', 'plugin_configured') except (SQLObjectNotFound, ValueError): raise ImmediateFeedback(form.action, 'invalid_id') elif form.action == 'delete': if p.channels.count() > 0 and 'confirm-delete' not in form: raise ImmediateFeedback(form.action, 'plugin_has_channels', {'plugin': p.to_dictionary(['id', 'name', 'channels_number', 'screens_number']), 'channels': [(c.id, c.name, c.enabled) for c in p.channels]}) plugin_name = p.name form.name = plugin_name p.destroySelf() logger.info('The plugin %s has been deleted by %s', plugin_name, current_user.log_name) add_feedback('general', 'plugin_deleted') except ImmediateFeedback: pass store_form(form) return self.render_page()
def create_database(): Building.createTable() Channel.createTable() Plugin.createTable() User.createTable() PluginChannel.createTable() ChannelBundle.createTable() Role.createTable() Screen.createTable() ScreenMac.createTable() Subscription.createTable() Template.createTable() Asset.createTable() PluginParamAccessRights.createTable() LogStat.createTable() DBVersion.createTable() DBVersion(version=database_version) User(username="******", fullname="ICTV Admin", email="admin@ictv", super_admin=True, disabled=False)
def setUp(self, middleware=lambda: None): setup_database() create_database() load_plugins() middleware() for plugin in Plugin.select(): plugin.activated = 'yes' with open(file='/tmp/config.yaml', mode='w+') as outfile: dump(self.config, outfile, default_flow_style=False) self.ictv_app = get_app('/tmp/config.yaml') print(self.ictv_app) self.testApp = TestApp(self.ictv_app.wsgifunc())
def runTest(self): """ Tests the plugin parameter access rights. """ p = Plugin(name='testPlug', activated='yes') par = PluginParamAccessRights(plugin=p, name='testParam') assert par.get_access_rights_for( UserPermissions.super_administrator) == (True, True) assert par.get_access_rights_for( UserPermissions.administrator) == (True, True) assert par.get_access_rights_for( UserPermissions.channel_administrator) == (True, False) assert par.get_access_rights_for( UserPermissions.channel_contributor) == (False, False) assert par.get_access_rights_for( UserPermissions.no_permission) == (False, False)
def render_page(self, current_user=None, users=None): if current_user is None: current_user = User.get(self.session['user']['id']) if UserPermissions.channel_administrator in current_user.highest_permission_level: users = User.select() channels = list(Channel.get_visible_channels_of(current_user)) plugin_channels = [] bundles = [] for channel in channels: if type(channel) is PluginChannel: plugin_channels.append(channel) elif type(channel) is ChannelBundle: bundles.append(channel) return self.renderer.channels( plugin_channels=plugin_channels, bundles=bundles, current_user=current_user, users=users, activated_plugins=Plugin.selectBy(activated='yes'), found_plugins=Plugin.select(NOT(Plugin.q.activated == 'notfound')))
def runTest(self): """ Tests the Asset SQLObject. """ fake_plugin = Plugin(name='fake_plugin', activated='notfound') asset_channel = PluginChannel(name='Asset Channel', plugin=fake_plugin, subscription_right='public') a1 = Asset(plugin_channel=asset_channel, user=None, filename='path_test', extension='.txt') last_ref_a1 = a1.last_reference time.sleep(1) assert a1.path == os.path.join('static', 'storage', str(asset_channel.id), str(a1.id) + '.txt') assert a1.last_reference > last_ref_a1 a2 = Asset(plugin_channel=asset_channel, user=None, filename='path_test') assert a2.path == os.path.join('static', 'storage', str(asset_channel.id), str(a2.id)) a3 = Asset(plugin_channel=asset_channel, user=None, filename='cache_test', in_flight=True) a3_path = os.path.join('static', 'storage', str(asset_channel.id), str(a3.id)) assert a3.path is None assert a3._get_path(force=True) == a3_path a3.in_flight = False assert a3.path == a3_path a4 = Asset(plugin_channel=asset_channel, user=None, filename='test_write', extension='.txt') a4_path = os.path.join(get_root_path(), 'static', 'storage', str(asset_channel.id), str(a4.id) + '.txt') a4_content = 'a4 file content'.encode() a4.write_to_asset_file(a4_content) with open(a4_path, 'rb') as f: assert f.read() == a4_content a4.destroySelf() assert not os.path.exists(a4_path)
def runTest(self): """ Tests the ChannelRenderer page. """ Channel.deleteMany(None) fake_plugin = Plugin.byName('fake_plugin') plugin_channel = PluginChannel(plugin=fake_plugin, name='This is a cool channel', subscription_right='public') body = self.testApp.get(plugin_channel.get_preview_link(), status=200).body assert b'This is a cool channel' in body assert b"Reveal.toggleAutoSlide(true);" in body assert self.testApp.get(plugin_channel.get_preview_link() + 'incorrect_secret', status=403) assert self.testApp.get('/preview/channels/%d/incorrect_secret' % (plugin_channel.id + 42), status=404)
def runTest(self): """ Tests the Role SQLObject """ Channel.deleteMany(None) fake_plugin = Plugin(name='fake_plugin', activated='notfound') plugin_channel = PluginChannel(name='Plugin Channel', plugin=fake_plugin, subscription_right='public') user = User(fullname='User', email='test@localhost') role = Role(user=user, channel=plugin_channel, permission_level=UserPermissions.channel_administrator) assert role._SO_get_permission_level() == 'channel_administrator' assert role.permission_level == UserPermissions.channel_administrator role.permission_level = UserPermissions.channel_contributor assert role._SO_get_permission_level() == 'channel_contributor' assert role.permission_level == UserPermissions.channel_contributor
def setUp(self): super(ChannelsPageTestCase, self).setUp() Channel.deleteMany(None) self.fake_plugin = Plugin.byName('fake_plugin') self.pc1 = PluginChannel(plugin=self.fake_plugin, name='PC 1', subscription_right='public') self.pc2 = PluginChannel(plugin=self.fake_plugin, name='PC 2', subscription_right='public') self.pc3 = PluginChannel(plugin=self.fake_plugin, name='PC 3', subscription_right='public') self.bundle = ChannelBundle(name='Bundle', subscription_right='public') self.building = Building(name='Building') self.screen = Screen(name='Screen', building=self.building) self.user_nothing = User(email='nothing@localhost', disabled=False) self.user_contrib = User(email='contrib@localhost', disabled=False) self.pc1.give_permission_to_user(self.user_contrib, UserPermissions.channel_contributor) self.user_chan_admin = User(email='chan_admin@localhost', disabled=False) self.user_chan_admin2 = User(email='chan_admin2@localhost', disabled=False) self.pc1.give_permission_to_user(self.user_chan_admin, UserPermissions.channel_administrator) self.pc2.give_permission_to_user(self.user_chan_admin2, UserPermissions.channel_administrator) self.user_screen_admin = User(email='screen_admin@locahost', disabled=False) self.screen.safe_add_user(self.user_screen_admin) self.user_admin = User(email='admin@localhost', disabled=False, admin=True) self.user_super_admin = User(email='super_admin@localhost', disabled=False, admin=True, super_admin=True) self.users = [ self.user_nothing, self.user_contrib, self.user_chan_admin, self.user_chan_admin2, self.user_screen_admin, self.user_admin, self.user_super_admin ]
def setUp(self): super().setUp() self.building_id = Building(name=self.building_name).id self.building2_id = Building(name=self.second_building_name).id self.channel = PluginChannel(name=self.channel_name, plugin=Plugin(name="dummy", activated="notfound"), subscription_right="public") User(email=self.user_nothing_email, disabled=False) User(email=self.user_administrator_email, disabled=False, admin=True) User(email=self.user_super_administrator_email, disabled=False, admin=True, super_admin=True) contributor = User(email=self.user_contributor_email, disabled=False) self.channel.give_permission_to_user(contributor) channel_admin = User(email=self.user_channel_admin_email, disabled=False) self.channel.give_permission_to_user( channel_admin, UserPermissions.channel_administrator)
def runTest(self): """ Tests the cache mecanism. """ u = User(username='******', fullname='testasset test', email='*****@*****.**', super_admin=True, disabled=False) PluginChannel(name='testasset2', plugin=Plugin(name='cache_plugin', activated='no'), subscription_right='restricted') c = PluginChannel.selectBy(name="testasset2").getOne() a = Asset(plugin_channel=c, user=u) self.testApp.get('/cache/' + str(a.id), status=303) try: Asset.delete(a.id) except SQLObjectNotFound: pass finally: User.delete(u.id) PluginChannel.delete(c.id)
def runTest(self): fake_plugin = Plugin.byName('fake_plugin') user = User(fullname='User', email='test@localhost') assert fake_plugin.channels_number == 0 pc1 = PluginChannel(plugin=fake_plugin, name='Plugin Channel 1', subscription_right='public') assert fake_plugin.channels_number == 1 pc2 = PluginChannel(plugin=fake_plugin, name='Plugin Channel 2', subscription_right='public') assert fake_plugin.channels_number == 2 pc2.destroySelf() assert fake_plugin.channels_number == 1 pc2 = PluginChannel(plugin=fake_plugin, name='Plugin Channel 2', subscription_right='public') pc3 = PluginChannel(plugin=fake_plugin, name='Plugin Channel 3', subscription_right='public') bundle_channel = ChannelBundle(name='Bundle', subscription_right='public') bundle_channel.add_channel(pc3) building = Building(name='building') screen1 = Screen(name='Screen1', building=building) screen2 = Screen(name='Screen2', building=building) screen3 = Screen(name='Screen3', building=building) assert fake_plugin.screens_number == 0 screen1.subscribe_to(user, pc1) assert fake_plugin.screens_number == 1 screen1.subscribe_to(user, pc2) assert fake_plugin.screens_number == 1 screen2.subscribe_to(user, pc3) assert fake_plugin.screens_number == 2 screen2.subscribe_to(user, bundle_channel) assert fake_plugin.screens_number == 2 screen3.subscribe_to(user, bundle_channel) assert fake_plugin.screens_number == 3
def get_plugin_missing_dependencies(plugin_name): """ Returns the dependencies that are not met for the given plugin. If all are met or the plugin could not be found or has no dependencies, it returns an empty list. """ path = os.path.join(Plugin.selectBy(name=plugin_name).getOne().package_path, 'config.yaml') failed_import = [] if os.path.isfile(path): with open(path, 'r') as f: config = yaml.unsafe_load(f) if 'dependencies' in config['plugin']: for module_name in config['plugin']['dependencies']: try: importlib.import_module(module_name) except ImportError: failed_import.append(module_name) logger.info('Import failed for module %s when checking dependencies of plugins %s' % ( module_name, plugin_name)) else: return None return failed_import
def runTest(self): """ Tests the Channel object. """ try: PluginChannel(name='test', plugin=Plugin(name='channel_plugin', activated='no'), subscription_right='restricted') PluginChannel( name='test2', plugin=Plugin.selectBy(name='channel_plugin').getOne(), subscription_right='restricted') c = PluginChannel.selectBy(name="test").getOne() assert_not_equal(None, c) c.set(name="testNew") assert_equal(c.name, "testNew") u = User(username='******', fullname='test test', email='*****@*****.**', super_admin=True, disabled=False) up = UserPermissions.channel_contributor c.give_permission_to_user(u, up) role = Role.selectBy(user=u, channel=c).getOne(None) assert_true(role != None) c.give_permission_to_user(u, up) role = Role.selectBy(user=u, channel=c).getOne(None) assert_true(role != None) getup = c.get_channel_permissions_of(u) assert_equal(getup, up) getupnoperm = c.get_channel_permissions_of(User.get(1)) assert_equal(getupnoperm, UserPermissions.no_permission) c.remove_permission_to_user(u) role = Role.selectBy(user=u, channel=c).getOne(None) assert_true(role == None) assert_false(c.has_admin(u)) up = UserPermissions.channel_administrator c.give_permission_to_user(u, up) assert_true(c.has_admin(u)) assert_true(c.has_contrib(u)) assert_is_not_none(c.get_admins()) assert_is_not_none(c.get_contribs()) assert_in(str(u.id), c.get_users_as_json()) c.remove_permission_to_user(u) role = Role.selectBy(user=u, channel=c).getOne(None) assert_true(role == None) c.give_permission_to_user(None, up) role = Role.selectBy(user=u).getOne(None) assert_true(role == None) tru = c.has_visible_params_for(u) assert_true(tru) u3 = User(username='******', fullname='test3 test2', email='*****@*****.**', super_admin=False, disabled=False) tru = c.has_visible_params_for(u3) assert_false(tru) t = PluginChannel.delete(c.id) assert_equal(t, None) # try to delete a channel used by a screen - Seems to work... sc = Screen(name='A', building=Building(name='A')) sc.subscribe_to(u, PluginChannel.get(2)) # t2 = PluginChannel.delete(2) c4 = PluginChannel.get(2) nbSub = c4.subscriptions.count() c4.set(enabled=False) assert_equal(nbSub, c4.subscriptions.count()) c4.set(enabled=True) c4.set(subscription_right="private") assert_equal(nbSub, c4.subscriptions.count()) c4.set(subscription_right="public") # todo seems working by bypassing the webinterface c4.set(cache_validity=-10) assert_true(c4.cache_validity < 0) sc.unsubscribe_from(u, PluginChannel.get(2)) u2 = User(username='******', fullname='test2 test2', email='*****@*****.**', super_admin=False, disabled=False) l = PluginChannel.get_screens_channels_from(u2) assert_is_not_none(l) temp = PluginChannel.get_visible_channels_of(u2) assert_is_not_none(temp) User.delete(u.id) User.delete(u2.id) User.delete(u3.id) except DuplicateEntryError: assert_true(False) return
def runTest(self): p = Plugin.byName('fake_plugin') assert 'this_parameter_does_not_exists' not in p.channels_params assert PluginParamAccessRights.selectBy( plugin=p, name='this_parameter_does_not_exists').getOne(None) is None
def runTest(self): """ Tests the User SQLObject """ user = User(username='******', fullname='fullname', email='email') fake_plugin = Plugin(name='fake_plugin', activated='notfound') plugin_channel = PluginChannel(plugin=fake_plugin, name='Channel', subscription_right='public') building = Building(name='building') screen = Screen(name='Screen', building=building) screen.subscribe_to(user, plugin_channel) # Miscellaneous test assert user.log_name == 'fullname (%d)' % user.id user.fullname = None assert user.log_name == 'email (%d)' % user.id user.fullname = 'fullname' assert user.log_name == 'fullname (%d)' % user.id assert user.readable_name == 'fullname' user.fullname = None assert user.readable_name == 'username' user.username = None assert user.readable_name == 'email' # Test permissions assert user.highest_permission_level == UserPermissions.no_permission assert list(user.get_subscriptions_of_owned_screens()) == [] assert list( user.get_channels_with_permission_level( UserPermissions.channel_contributor)) == [] assert list( user.get_channels_with_permission_level( UserPermissions.channel_administrator)) == [] plugin_channel.give_permission_to_user( user, UserPermissions.channel_contributor) assert user.highest_permission_level == UserPermissions.channel_contributor assert list( user.get_channels_with_permission_level( UserPermissions.channel_contributor)) == [plugin_channel] assert list( user.get_channels_with_permission_level( UserPermissions.channel_administrator)) == [] plugin_channel.give_permission_to_user( user, UserPermissions.channel_administrator) assert user.highest_permission_level == UserPermissions.channel_administrator assert list( user.get_channels_with_permission_level( UserPermissions.channel_contributor)) == [] assert list( user.get_channels_with_permission_level( UserPermissions.channel_administrator)) == [plugin_channel] plugin_channel.remove_permission_to_user(user) assert user.highest_permission_level == UserPermissions.no_permission assert list(user.get_subscriptions_of_owned_screens()) == [] user.admin = True assert user.highest_permission_level == UserPermissions.administrator assert list(user.get_subscriptions_of_owned_screens()) == list( screen.subscriptions) user.admin = False assert user.highest_permission_level == UserPermissions.no_permission assert list(user.get_subscriptions_of_owned_screens()) == [] user.super_admin = True assert user.highest_permission_level == UserPermissions.super_administrator assert list(user.get_subscriptions_of_owned_screens()) == list( screen.subscriptions) user.super_admin = False assert user.highest_permission_level == UserPermissions.no_permission assert list(user.get_subscriptions_of_owned_screens()) == [] screen.safe_add_user(user) assert user.highest_permission_level == UserPermissions.screen_administrator assert list(user.get_subscriptions_of_owned_screens()) == list( screen.subscriptions) screen.removeUser(user) assert list(user.get_subscriptions_of_owned_screens()) == [] assert user.highest_permission_level == UserPermissions.no_permission
def runTest(self): """ Tests the plugin config page. """ r = self.testApp.get('/plugins/%d/config' % Plugin.selectBy(name='fake_plugin').getOne().id, status=200) assert_not_equal(r.body, None)
def runTest(self): """ Tests the Channel SQLObject """ Channel.deleteMany(None) fake_plugin = Plugin(name='fake_plugin', activated='notfound') channel = Channel(name='Channel', subscription_right='public', secret='abcdef') plugin_channel = PluginChannel(name='Channel2', plugin=fake_plugin, subscription_right='public') bundle_channel = ChannelBundle(name='Channel3', subscription_right='public') building = Building(name='building') screen = Screen(name='Screen', building=building) user = User(fullname='User', email='test@localhost') user2 = User(fullname='User2', email='test2@localhost') # Test can_subscribe() def test_channel_subscription(c, u): def assert_subscription_no_perm(): assert c.can_subscribe(u) c.subscription_right = 'restricted' assert not c.can_subscribe(u) c.subscription_right = 'private' assert not c.can_subscribe(u) c.subscription_right = 'public' assert c.can_subscribe(u) def assert_subscription_admin(): assert c.can_subscribe(u) c.subscription_right = 'restricted' assert c.can_subscribe(u) c.subscription_right = 'private' assert c.can_subscribe(u) c.subscription_right = 'public' assert c.can_subscribe(u) def assert_subscription_super_admin(): assert c.can_subscribe(u) c.subscription_right = 'restricted' assert c.can_subscribe(u) c.subscription_right = 'private' assert c.can_subscribe(u) c.subscription_right = 'public' assert c.can_subscribe(u) assert_subscription_no_perm() user.admin = True assert_subscription_admin() user.admin = False user.super_admin = True assert_subscription_super_admin() user.super_admin = False test_channel_subscription(channel, user) test_channel_subscription(plugin_channel, user) test_channel_subscription(bundle_channel, user) # Test get_channels_authorized_subscribers_as_json() def test_channel_subscribers(c): def assert_no_users(): assert Channel.get_channels_authorized_subscribers_as_json( [c]) == '{"%d": []}' % c.id def assert_only_user(u): assert Channel.get_channels_authorized_subscribers_as_json( [c]) == '{"%d": [%d]}' % (c.id, u.id) def assert_users(*users): for u in json.loads( Channel.get_channels_authorized_subscribers_as_json( [c]))[str(c.id)]: assert u in [u.id for u in users] assert_no_users() c.safe_add_user(user) assert_only_user(user) # check that there is no duplicate c.safe_add_user(user) assert_only_user(user) c.removeUser(user) c.safe_add_user(user) assert_only_user(user) c.safe_add_user(user2) assert_users(user, user2) c.removeUser(user) assert_only_user(user2) c.removeUser(user2) assert_no_users() test_channel_subscribers(channel) test_channel_subscribers(plugin_channel) test_channel_subscribers(bundle_channel) # Test get_visible_channels_of() def test_visible_channels(u): def assert_no_channels(): assert Channel.get_visible_channels_of(u) == set() def assert_channel(c): assert Channel.get_visible_channels_of(u) == {c} def assert_all_channels(): assert Channel.get_visible_channels_of(u) == { channel, plugin_channel, bundle_channel } def assert_public_channels(): channel.subscription_right = 'restricted' assert Channel.get_visible_channels_of(u) == { plugin_channel, bundle_channel } channel.subscription_right = 'private' assert Channel.get_visible_channels_of(u) == { plugin_channel, bundle_channel } channel.subscription_right = 'public' assert_no_channels() u.admin = True assert_all_channels() u.admin = False assert_no_channels() u.super_admin = True assert_all_channels() u.super_admin = False assert_no_channels() screen.addUser(u) assert_public_channels() screen.removeUser(u) assert_no_channels() channel.subscription_right = 'restricted' assert_no_channels() channel.addUser(u) assert_channel(channel) screen.addUser(u) assert_all_channels() channel.removeUser(u) screen.removeUser(u) assert_no_channels() channel.subscription_right = 'public' plugin_channel.give_permission_to_user( u, UserPermissions.channel_contributor) assert_channel(plugin_channel) plugin_channel.give_permission_to_user( u, UserPermissions.channel_administrator) assert_channel(plugin_channel) plugin_channel.remove_permission_to_user(u) assert_no_channels() test_visible_channels(user) test_visible_channels(user2) # Test get_screens_channels_from() def test_screens_channels(u): def assert_no_channels(): assert set(Channel.get_screens_channels_from(u)) == set() def assert_channel(c): assert set(Channel.get_screens_channels_from(u)) == {c} def assert_channels(*channels): assert set( Channel.get_screens_channels_from(u)) == set(channels) def assert_all_channels(): assert set(Channel.get_screens_channels_from(u)) == { channel, plugin_channel, bundle_channel } assert_all_channels() channel.subscription_right = 'restricted' plugin_channel.subscription_right = 'restricted' bundle_channel.subscription_right = 'restricted' assert_no_channels() u.super_admin = True assert_all_channels() u.super_admin = False assert_no_channels() channel.addUser(u) assert_channel(channel) channel.removeUser(u) assert_no_channels() screen.addUser(user) screen.subscribe_to(user, channel) assert_channel(channel) screen.subscribe_to(user, bundle_channel) assert_channels(channel, bundle_channel) channel.subscription_right = 'public' plugin_channel.subscription_right = 'public' bundle_channel.subscription_right = 'public' test_screens_channels(user) # Test get_preview_link() assert channel.get_preview_link( ) == '/preview/channels/%d/abcdef' % channel.id