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 channels creation via the Channels page """
channel_params = {
'action': 'create-channel',
'name': 'Plugin Channel test creation',
'description': 'Descr.',
'enabled': 'on',
'subscription_right': 'public',
'plugin': self.fake_plugin.id
}
bundle_params = dict(**channel_params)
bundle_params.update({
'action': 'create-bundle',
'name': 'Channel Bundle test creation'
})
def assert_creation(status=200):
assert PluginChannel.selectBy(
name=channel_params['name']).getOne(None) is None
assert self.testApp.post('/channels',
params=channel_params,
status=status).body is not None
chan = PluginChannel.selectBy(
name=channel_params['name']).getOne(None)
assert chan is not None
chan.destroySelf()
assert ChannelBundle.selectBy(
name=bundle_params['name']).getOne(None) is None
assert self.testApp.post('/channels',
params=bundle_params,
status=status).body is not None
chan = ChannelBundle.selectBy(
name=bundle_params['name']).getOne(None)
assert chan is not None
chan.destroySelf()
def assert_no_creation(status=200):
assert PluginChannel.selectBy(
name=channel_params['name']).getOne(None) is None
assert self.testApp.post('/channels',
params=channel_params,
status=status).body is not None
assert PluginChannel.selectBy(
name=channel_params['name']).getOne(None) is None
assert ChannelBundle.selectBy(
name=bundle_params['name']).getOne(None) is None
assert self.testApp.post('/channels',
params=bundle_params,
status=status).body is not None
assert ChannelBundle.selectBy(
name=bundle_params['name']).getOne(None) is None
# Test basic creation
assert_creation()
# Test name less than 3 chars
channel_params['name'] = bundle_params['name'] = 'aa'
assert_no_creation()
channel_params['name'] = 'Proper channel name'
bundle_params['name'] = 'Proper bundle name'
# Test invalid subscription right
channel_params['subscription_right'] = bundle_params[
'subscription_right'] = 'invalid'
assert_no_creation()
channel_params['subscription_right'] = bundle_params[
'subscription_right'] = 'public'
# Test insufficient permissions for channel creation
for u in [
self.user_nothing, self.user_contrib, self.user_chan_admin,
self.user_screen_admin
]:
self.ictv_app.test_user = {'email': u.email}
assert_no_creation(403)
# Test sufficient permissions for channel creation
for u in [self.user_admin, self.user_super_admin]:
self.ictv_app.test_user = {'email': u.email}
assert_creation()
# Test invalid plugin
channel_params['plugin'] = self.fake_plugin.id + 42
assert PluginChannel.selectBy(
name=channel_params['name']).getOne(None) is None
assert self.testApp.post('/channels',
params=channel_params,
status=200).body is not None
assert PluginChannel.selectBy(
name=channel_params['name']).getOne(None) is None
channel_params['plugin'] = 'invalid'
assert PluginChannel.selectBy(
name=channel_params['name']).getOne(None) is None
assert self.testApp.post('/channels',
params=channel_params,
status=200).body is not None
assert PluginChannel.selectBy(
name=channel_params['name']).getOne(None) is None
channel_params['plugin'] = self.fake_plugin.id
# Test invalid action
channel_params['action'] = bundle_params['action'] = 'create-invalid'
assert_no_creation(400)
channel_params['action'] = 'create-channel'
bundle_params['action'] = 'create-bundle'
# Test duplicate name
Channel(name='already taken', subscription_right='public')
channel_params['name'] = bundle_params['name'] = 'already taken'
assert_no_creation()
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 channels edition through the Channels page """
channel_params = {
'action': 'edit-channel',
'name': 'Plugin Channel test edition',
'description': 'Descr.',
'subscription_right': 'public',
'plugin': self.fake_plugin.id,
'id': self.pc1.id
}
bundle_params = dict(**channel_params)
bundle_params.update({
'action': 'edit-bundle',
'name': 'Channel Bundle test edition',
'id': self.bundle.id
})
bundle_params.pop('plugin')
def get_attr(o, a):
if a == 'plugin':
return o.plugin.id
if a == 'enabled':
return 'on' if o.enabled else ''
return getattr(o, a)
def assert_edition(attrs=None,
channel_params=channel_params,
bundle_params=bundle_params,
status=200):
if attrs is None:
attrs = [
'name', 'description', 'enabled', 'subscription_right',
'plugin'
]
assert self.testApp.post('/channels',
params=channel_params,
status=status).body is not None
pc = PluginChannel.get(self.pc1.id)
for attr in attrs:
if attr in channel_params:
assert get_attr(pc, attr) == channel_params[attr]
assert self.testApp.post('/channels',
params=bundle_params,
status=status).body is not None
bc = ChannelBundle.get(self.bundle.id)
for attr in attrs:
if attr in bundle_params:
assert get_attr(bc, attr) == bundle_params[attr]
if channel_params is not orig_plugin_channel_params and bundle_params is not orig_bundle_params:
assert_edition(channel_params=orig_plugin_channel_params,
bundle_params=orig_bundle_params) # Revert
def assert_no_edition(status=200):
assert self.testApp.post('/channels',
params=channel_params,
status=status).body is not None
assert orig_plugin_channel == repr(PluginChannel.get(self.pc1.id))
assert self.testApp.post('/channels',
params=bundle_params,
status=status).body is not None
assert orig_bundle_channel == repr(
ChannelBundle.get(self.bundle.id))
orig_plugin_channel_params = {
'action': 'edit-channel',
'name': 'Plugin Channel',
'description': 'Original descr.',
'subscription_right': 'public',
'plugin': self.fake_plugin.id,
'id': self.pc1.id
}
orig_bundle_params = dict(**orig_plugin_channel_params)
orig_bundle_params.update({
'action': 'edit-bundle',
'name': 'Channel Bundle test edition',
'id': self.bundle.id
})
orig_bundle_params.pop('plugin')
assert_edition(channel_params=orig_plugin_channel_params,
bundle_params=orig_bundle_params)
orig_plugin_channel = repr(PluginChannel.get(self.pc1.id))
orig_bundle_channel = repr(ChannelBundle.get(self.bundle.id))
# Test basic functionality
assert_edition()
# Test insufficient permissions for channel edition
for u in [
self.user_nothing, self.user_contrib, self.user_chan_admin,
self.user_screen_admin
]:
self.ictv_app.test_user = {'email': u.email}
assert_no_edition(403)
# Test sufficient permissions for channel edition
for u in [self.user_admin, self.user_super_admin]:
self.ictv_app.test_user = {'email': u.email}
assert_edition()
# Test invalid id
channel_params['id'] = bundle_params['id'] = -1
assert_no_edition()
channel_params['id'] = bundle_params['id'] = 'invalid'
assert_no_edition()
channel_params['id'] = self.pc1.id
bundle_params['id'] = self.bundle.id
# Test invalid plugin
channel_params['plugin'] = -1
assert self.testApp.post('/channels',
params=channel_params,
status=200).body is not None
assert orig_plugin_channel == repr(PluginChannel.get(self.pc1.id))
channel_params['plugin'] = 'invalid'
assert self.testApp.post('/channels',
params=channel_params,
status=200).body is not None
assert orig_plugin_channel == repr(PluginChannel.get(self.pc1.id))
channel_params['plugin'] = self.fake_plugin.id
# Test invalid action
channel_params['action'] = bundle_params['action'] = 'edit-invalid'
assert_no_edition(400)
channel_params['action'] = 'edit-channel'
bundle_params['action'] = 'edit-bundle'
# Test duplicate name
Channel(name='already taken', subscription_right='public')
channel_params['name'] = bundle_params['name'] = 'already taken'
assert_no_edition()
