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