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 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 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 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
def runTest(self): """ Tests the Screen SQLObject """ Channel.deleteMany(None) Screen.deleteMany(None) channel = Channel(name='Channel', subscription_right='public', secret='abcdef') plugin_channel = PluginChannel(name='Channel2', plugin=Plugin.byName('fake_plugin'), subscription_right='public') plugin_channel2 = PluginChannel(name='Channel3', plugin=Plugin.byName('fake_plugin'), subscription_right='public') bundle_channel = ChannelBundle(name='Channel4', subscription_right='public') bundle_channel.add_channel(plugin_channel2) building = Building(name='building') screen = Screen(name='Screen', building=building, secret='abcdef') screen2 = Screen(name='Screen2', building=building) user = User(fullname='User', email='test@localhost') user2 = User(fullname='User2', email='test2@localhost') # Miscellaneous test assert screen.get_view_link() == '/screens/%d/view/abcdef' % screen.id assert screen.get_client_link( ) == '/screens/%d/client/abcdef' % screen.id assert screen.get_macs_string() == '' assert screen not in user.screens screen.safe_add_user(user) assert screen in user.screens assert screen not in user2.screens screen.removeUser(user) assert screen not in user2.screens # Test subscription assert not screen.is_subscribed_to(channel) screen.subscribe_to(user, channel) assert screen.is_subscribed_to(channel) sub = screen.subscriptions[0] screen.subscribe_to(user2, channel, weight=42) assert sub.created_by == user2 assert sub.weight == 42 assert screen.is_subscribed_to(channel) assert list(screen.subscribed_channels) == [channel] screen.unsubscribe_from(user2, channel) assert not screen.is_subscribed_to(channel) # Test macs ScreenMac(screen=screen, mac='00b16b00b500') ScreenMac(screen=screen, mac='00b16b00b501') assert screen.get_macs_string( ) == '00:b1:6b:00:b5:00;00:b1:6b:00:b5:01' # Test get_visible_screens_of() assert list(Screen.get_visible_screens_of(user)) == list( Screen.get_visible_screens_of(user2)) == [] user.admin = True assert list(Screen.get_visible_screens_of(user)) == [screen, screen2] assert list(Screen.get_visible_screens_of(user2)) == [] user.admin = False user2.super_admin = True assert list(Screen.get_visible_screens_of(user2)) == [screen, screen2] assert list(Screen.get_visible_screens_of(user)) == [] user2.super_admin = False screen.safe_add_user(user) screen2.safe_add_user(user2) assert list(Screen.get_visible_screens_of(user)) == [screen] assert list(Screen.get_visible_screens_of(user2)) == [screen2] # Test channel content screen.subscribe_to(user, plugin_channel) screen.subscribe_to(user, bundle_channel) screen_content = screen.get_channels_content(self.ictv_app) assert len(screen_content) == 2 assert len(screen_content[0].get_slides()) == 1 assert screen_content[0].get_slides()[0].get_content() == { 'background-1': { 'size': 'contain', 'src': '' }, 'title-1': { 'text': 'Channel2' }, 'text-1': { 'text': '' } } assert len(screen_content[1].get_slides()) == 1 assert screen_content[1].get_slides()[0].get_content() == { 'background-1': { 'size': 'contain', 'src': '' }, 'title-1': { 'text': 'Channel3' }, 'text-1': { 'text': '' } } screen.shuffle = True assert len(screen.get_channels_content(self.ictv_app)) == 2
def runTest(self): """ Tests the PluginChannel SQLObject """ Channel.deleteMany(None) fake_plugin = Plugin.selectBy(name='fake_plugin').getOne() plugin_channel = PluginChannel(name='MyPluginChannel', plugin=fake_plugin, subscription_right='public') user = User(fullname='User', email='test@localhost') user2 = User(fullname='User2', email='test2@localhost') assert plugin_channel.get_type_name() == 'Plugin fake_plugin' # Test user permissions def assert_no_permission(c, u): assert c.get_channel_permissions_of( u) == UserPermissions.no_permission assert u not in c.get_admins() and u not in c.get_contribs() def has_contrib(u, check_inlist=True): return plugin_channel.has_contrib(u) and ( not check_inlist or u in plugin_channel.get_contribs()) def has_admin(u): return plugin_channel.has_admin( u) and u in plugin_channel.get_admins() assert_no_permission(plugin_channel, user) assert_no_permission(plugin_channel, user2) plugin_channel.give_permission_to_user( user, UserPermissions.channel_contributor) role = Role.selectBy(user=user, channel=plugin_channel).getOne() assert has_contrib(user) assert not has_admin(user) assert not has_contrib(user2) assert not has_admin(user2) assert role.permission_level == UserPermissions.channel_contributor == plugin_channel.get_channel_permissions_of( user) assert json.loads(plugin_channel.get_users_as_json()) == { str(user.id): UserPermissions.channel_contributor.value } plugin_channel.give_permission_to_user( user, UserPermissions.channel_administrator) assert has_contrib(user, check_inlist=False) assert has_admin(user) assert not has_contrib(user2) assert not has_admin(user2) assert role.permission_level == UserPermissions.channel_administrator == plugin_channel.get_channel_permissions_of( user) assert json.loads(plugin_channel.get_users_as_json()) == { str(user.id): UserPermissions.channel_administrator.value } assert json.loads(PluginChannel.get_channels_users_as_json([plugin_channel])) == \ {str(plugin_channel.id): {str(user.id): UserPermissions.channel_administrator.value}} plugin_channel.remove_permission_to_user(user) plugin_channel.give_permission_to_user( user2, UserPermissions.channel_administrator) assert not has_contrib(user) assert not has_admin(user) assert has_contrib(user2, check_inlist=False) assert has_admin(user2) plugin_channel.remove_permission_to_user(user2) assert not has_contrib(user2) assert not has_admin(user2) # Test plugin config parameters assert plugin_channel.get_config_param( 'string_param') == 'default string' assert plugin_channel.get_config_param('int_param') == 1 assert plugin_channel.get_config_param('float_param') == float('-inf') assert plugin_channel.get_config_param('boolean_param') is True assert plugin_channel.get_config_param('template_param') is None with pytest.raises(KeyError): assert plugin_channel.get_config_param( 'this_param_does_not_exists') def assert_value_is_set(param, value): plugin_channel.plugin_config[param] = value plugin_channel.plugin_config = plugin_channel.plugin_config # Force SQLObject update assert plugin_channel.get_config_param(param) == value assert_value_is_set('string_param', 'Hello, world!') assert_value_is_set('int_param', 42) assert_value_is_set('float_param', 42.0) assert_value_is_set('boolean_param', False) assert_value_is_set('template_param', 'fake-template') # Test parameters access rights ppar = PluginParamAccessRights.selectBy(plugin=fake_plugin, name='int_param').getOne() ppar.channel_contributor_read = False ppar.channel_contributor_write = False ppar.channel_administrator_read = True ppar.channel_administrator_write = False ppar.administrator_read = True ppar.administrator_write = True user.super_admin = True assert plugin_channel.has_visible_params_for(user) for param in [ 'string_param', 'int_param', 'float_param', 'boolean_param', 'template_param' ]: assert plugin_channel.get_access_rights_for(param, user) == (True, True) user.super_admin = False assert not plugin_channel.has_visible_params_for(user) plugin_channel.give_permission_to_user( user, UserPermissions.channel_contributor) assert not plugin_channel.has_visible_params_for(user) assert plugin_channel.get_access_rights_for('int_param', user) == (False, False) plugin_channel.give_permission_to_user( user, UserPermissions.channel_administrator) assert plugin_channel.has_visible_params_for(user) assert plugin_channel.get_access_rights_for('int_param', user) == (True, False) user.admin = True assert plugin_channel.has_visible_params_for(user) assert plugin_channel.get_access_rights_for('int_param', user) == (True, True) plugin_channel.remove_permission_to_user(user) user.admin = False assert not plugin_channel.has_visible_params_for(user) assert plugin_channel.get_access_rights_for('int_param', user) == (False, False) # Test miscellaneous parameters assert plugin_channel.cache_activated is True plugin_channel.plugin.cache_activated_default = False assert plugin_channel.cache_activated is False plugin_channel.cache_activated = True assert plugin_channel.cache_activated is True assert plugin_channel.cache_validity is 60 plugin_channel.plugin.cache_validity_default = 120 assert plugin_channel.cache_validity is 120 plugin_channel.cache_validity = 42 assert plugin_channel.cache_validity is 42 assert plugin_channel.keep_noncomplying_capsules is False plugin_channel.plugin.keep_noncomplying_capsules_default = True assert plugin_channel.keep_noncomplying_capsules is True plugin_channel.keep_noncomplying_capsules = False assert plugin_channel.keep_noncomplying_capsules is False # Test flatten() plugin_channel.enabled = False assert plugin_channel.flatten() == [] assert plugin_channel.flatten(keep_disabled_channels=True) == [ plugin_channel ] plugin_channel.enabled = True assert plugin_channel.flatten() == [plugin_channel]