def test_edit_asset(self):
with db.conn(settings['database']) as conn:
assets_helper.create(conn, asset_x)
with Browser() as browser:
browser.visit('http://localhost:8080')
wait_for_and_do(browser, '.edit-asset-button', lambda btn: btn.click())
sleep(1)
wait_for_and_do(browser, 'input[name="duration"]', lambda field: field.fill('333'))
sleep(1) # wait for new-asset panel animation
wait_for_and_do(browser, '#add-form', lambda form: form.click())
sleep(1)
wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
self.assertEqual(len(assets), 1)
asset = assets[0]
self.assertEqual(asset['duration'], u'333')
def test_edit_asset(self):
with db.conn(settings['database']) as conn:
assets_helper.create(conn, asset_x)
with Browser() as browser:
browser.visit(main_page_url)
wait_for_and_do(browser, '.edit-asset-button',
lambda btn: btn.click())
sleep(1)
wait_for_and_do(browser, 'input[name="duration"]',
lambda field: field.fill('333'))
sleep(1) # wait for new-asset panel animation
wait_for_and_do(browser, '#add-form', lambda form: form.click())
sleep(1)
wait_for_and_do(browser, '#save-asset', lambda btn: btn.click())
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
self.assertEqual(len(assets), 1)
asset = assets[0]
self.assertEqual(asset['duration'], u'333')
def test_create_update_read_asset_utf8(self):
assets_helper.create(self.conn, asset_w)
asset_w_ = asset_w.copy()
asset_w_.update(**asset_w_diff)
assets_helper.update(self.conn, asset_w['asset_id'], asset_w_)
should_be_w_ = assets_helper.read(self.conn)
self.assertEqual([asset_w_], should_be_w_)
def test_create_update_read_asset_utf8(self):
assets_helper.create(self.conn, asset_w)
asset_w_ = asset_w.copy()
asset_w_.update(**asset_w_diff)
assets_helper.update(self.conn, asset_w['asset_id'], asset_w_)
should_be_w_ = assets_helper.read(self.conn)
self.assertEqual([asset_w_], should_be_w_)
def test_keep_same_position_on_playlist_update(self):
assets_helper.create_multiple(viewer.db_conn, [asset_x, asset_y])
sch = viewer.Scheduler()
sch.get_next_asset()
assets_helper.create(viewer.db_conn, asset_z)
sch.update_playlist()
self.assertEqual(sch.index, 1)
def test_create_delete_asset(self):
assets_helper.create(self.conn, asset_x)
assets_helper.delete(self.conn, asset_x['asset_id'])
assets_helper.create(self.conn, asset_y)
assets_helper.delete(self.conn, asset_y['asset_id'])
should_be_empty = assets_helper.read(self.conn)
self.assertEmpty(should_be_empty)
def test_create_delete_asset(self):
assets_helper.create(self.conn, asset_x)
assets_helper.delete(self.conn, asset_x['asset_id'])
assets_helper.create(self.conn, asset_y)
assets_helper.delete(self.conn, asset_y['asset_id'])
should_be_empty = assets_helper.read(self.conn)
self.assertEmpty(should_be_empty)
def test_keep_same_position_on_playlist_update(self):
assets_helper.create_multiple(viewer.db_conn, [asset_x, asset_y])
sch = viewer.Scheduler()
sch.get_next_asset()
assets_helper.create(viewer.db_conn, asset_z)
sch.update_playlist()
self.assertEqual(sch.index, 1)
def test_create_update_read_asset(self):
assets_helper.create(self.conn, asset_x)
asset_x_ = asset_x.copy()
asset_x_.update(**asset_x_diff)
assets_helper.update(self.conn, asset_x['asset_id'], asset_x_)
assets_helper.create(self.conn, asset_y)
asset_y_ = asset_y.copy()
asset_y_.update(**asset_y_diff)
assets_helper.update(self.conn, asset_y['asset_id'], asset_y_)
should_be_y__x_ = assets_helper.read(self.conn)
self.assertEqual([asset_y_, asset_x_], should_be_y__x_)
def test_create_update_read_asset(self):
assets_helper.create(self.conn, asset_x)
asset_x_ = asset_x.copy()
asset_x_.update(**asset_x_diff)
assets_helper.update(self.conn, asset_x['asset_id'], asset_x_)
assets_helper.create(self.conn, asset_y)
asset_y_ = asset_y.copy()
asset_y_.update(**asset_y_diff)
assets_helper.update(self.conn, asset_y['asset_id'], asset_y_)
should_be_y__x_ = assets_helper.read(self.conn)
self.assertEqual([asset_y_, asset_x_], should_be_y__x_)
def test_rm_asset(self):
with db.conn(settings['database']) as conn:
assets_helper.create(conn, asset_x)
with Browser() as browser:
browser.visit(main_page_url)
wait_for_and_do(browser, '.delete-asset-button', lambda btn: btn.click())
wait_for_and_do(browser, '.confirm-delete', lambda btn: btn.click())
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
self.assertEqual(len(assets), 0)
def test_rm_asset(self):
with db.conn(settings['database']) as conn:
assets_helper.create(conn, asset_x)
with Browser() as browser:
browser.visit('http://localhost:8080')
wait_for_and_do(browser, '.delete-asset-button', lambda btn: btn.click())
wait_for_and_do(browser, '.confirm-delete', lambda btn: btn.click())
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
self.assertEqual(len(assets), 0)
def test_enable_asset(self):
with db.conn(settings['database']) as conn:
assets_helper.create(conn, asset_x)
with Browser() as browser:
browser.visit('http://localhost:8080')
wait_for_and_do(browser, 'span[class="on"]', lambda btn: btn.click())
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
self.assertEqual(len(assets), 1)
asset = assets[0]
self.assertEqual(asset['is_enabled'], 1)
def test_enable_asset(self):
with db.conn(settings['database']) as conn:
assets_helper.create(conn, asset_x)
with Browser() as browser:
browser.visit(main_page_url)
wait_for_and_do(browser, '.toggle', lambda btn: btn.click())
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
self.assertEqual(len(assets), 1)
asset = assets[0]
self.assertEqual(asset['is_enabled'], 1)
def test_update_asset(self):
asset_x_ = assets_helper.create(self.conn, asset_x)
asset_x_copy = asset_x_.copy()
data = {
'name': 'New name',
'mimetype': 'should not setted',
'empty': 'non exists field'
}
self.assertEquals(asset_x_, asset_x_copy)
server.update_asset(asset_x_copy, data)
asset_x_copy = assets_helper.update(self.conn, asset_x_copy.get('id'),
asset_x_copy)
self.assertEquals(
asset_x_copy, {
'is_enabled': 1,
'asset_id': None,
'end_date': datetime.datetime(2013, 1, 19, 23, 59),
'is_active': 0,
'duration': u'5',
'mimetype': u'web',
'name': 'New name',
'uri': u'http://www.wireload.net',
'play_order': 1,
'start_date': datetime.datetime(2013, 1, 16, 0, 0)
})
self.assertNotEqual(asset_x_, asset_x_copy)
def test_disable_asset(self):
with db.conn(settings['database']) as conn:
_asset_x = asset_x.copy()
_asset_x['is_enabled'] = 1
assets_helper.create(conn, _asset_x)
with Browser() as browser:
browser.visit(main_page_url)
wait_for_and_do(browser, 'span[class="off"]', lambda btn: btn.click())
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
self.assertEqual(len(assets), 1)
asset = assets[0]
self.assertEqual(asset['is_enabled'], 0)
def fetch_master_assets():
logging.debug("trying to fetch assets from Master " + settings["remote_host"] + ":" + settings["remote_port"])
try:
r = req_get("http://" + settings["remote_host"] + ":" + settings["remote_port"] + "/api/assets", timeout=10)
except:
logging.warn("Network error getting remote assets")
else:
if r.status_code != 200:
logging.warn("Unable to get remote assets " + str(r.status_code))
else:
logging.debug("Got " + str(r.text))
data = json_loads(r.text)
assets_helper.clear_table(db_conn)
for asset in data:
try:
a = json_to_asset(asset)
assets_helper.create(db_conn, a)
logging.info("Added remote asset " + str(a["uri"]))
except Exception, e:
logging.warn("Can not add remote asset: " + str(e))
def test_get_playlist(self):
assets_helper.create(self.conn, asset_x)
assets_helper.create(self.conn, asset_y)
self.set_now(date_e)
should_be_empty = assets_helper.get_playlist(self.conn)
self.assertEmpty(should_be_empty)
self.set_now(date_f)
[should_be_x] = assets_helper.get_playlist(self.conn)
self.assertEqual(asset_x['asset_id'], should_be_x['asset_id'])
self.set_now(date_g)
should_be_y_x = assets_helper.get_playlist(self.conn)
self.assertEqual(
[should_be_y_x[0]['asset_id'], should_be_y_x[1]['asset_id']],
[asset_y['asset_id'], asset_x['asset_id']])
self.set_now(date_h)
[should_be_y] = assets_helper.get_playlist(self.conn)
self.assertEqual(asset_y['asset_id'], should_be_y['asset_id'])
def test_get_playlist(self):
assets_helper.create(self.conn, asset_x)
assets_helper.create(self.conn, asset_y)
self.set_now(date_e)
should_be_empty = assets_helper.get_playlist(self.conn)
self.assertEmpty(should_be_empty)
self.set_now(date_f)
[should_be_x] = assets_helper.get_playlist(self.conn)
self.assertEqual(asset_x['asset_id'], should_be_x['asset_id'])
self.set_now(date_g)
should_be_y_x = assets_helper.get_playlist(self.conn)
self.assertEqual([should_be_y_x[0]['asset_id'],
should_be_y_x[1]['asset_id']],
[asset_y['asset_id'],
asset_x['asset_id']])
self.set_now(date_h)
[should_be_y] = assets_helper.get_playlist(self.conn)
self.assertEqual(asset_y['asset_id'], should_be_y['asset_id'])
def create_asset_from_schedule_slot(schedule_slot, start, end):
base_uri = k_settings['local_address']
asset_uri = base_uri + "/kenban?foreground_image_uuid={image}&display_text={text}&template_uuid={template}".format(
image=schedule_slot["foreground_image_uuid"],
text=schedule_slot["display_text"],
template=schedule_slot["template_uuid"])
asset_id = uuid.uuid4().hex
asset = {
"asset_id": asset_id,
"mimetype": "webpage",
"is_enabled": 1,
"name": schedule_slot["uuid"],
"end_date": end,
"duration": "10",
"play_order": 0,
"nocache": 0,
"uri": asset_uri,
"skip_asset_check": 1,
"start_date": start
}
with db.conn(s_settings['database']) as conn:
assets_helper.create(conn, asset)
def test_reorder_asset(self):
with db.conn(settings['database']) as conn:
_asset_x = asset_x.copy()
_asset_x['is_enabled'] = 1
assets_helper.create(conn, _asset_x)
assets_helper.create(conn, asset_y)
with Browser() as browser:
browser.visit(main_page_url)
asset_x_for_drag = browser.find_by_id(asset_x['asset_id'])
sleep(1)
asset_y_to_reorder = browser.find_by_id(asset_y['asset_id'])
asset_x_for_drag.drag_and_drop(asset_y_to_reorder)
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
x = assets_helper.read(conn, asset_x['asset_id'])
y = assets_helper.read(conn, asset_y['asset_id'])
self.assertEqual(x['play_order'], 0)
self.assertEqual(y['play_order'], 1)
def post(self):
asset = prepare_asset_v1_2(request)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
ids_of_active_assets = [x['asset_id'] for x in assets if x['is_active']]
asset = assets_helper.create(conn, asset)
if asset['is_active']:
ids_of_active_assets.insert(asset['play_order'], asset['asset_id'])
assets_helper.save_ordering(conn, ids_of_active_assets)
return assets_helper.read(conn, asset['asset_id']), 201
def test_reorder_asset(self):
with db.conn(settings['database']) as conn:
_asset_x = asset_x.copy()
_asset_x['is_enabled'] = 1
assets_helper.create(conn, _asset_x)
assets_helper.create(conn, asset_y)
with Browser() as browser:
browser.visit('http://localhost:8080')
asset_x_for_drag = browser.find_by_id(asset_x['asset_id'])
sleep(1)
asset_y_to_reorder = browser.find_by_id(asset_y['asset_id'])
asset_x_for_drag.drag_and_drop(asset_y_to_reorder)
sleep(3) # backend need time to process request
with db.conn(settings['database']) as conn:
x = assets_helper.read(conn, asset_x['asset_id'])
y = assets_helper.read(conn, asset_y['asset_id'])
self.assertEqual(x['play_order'], 0)
self.assertEqual(y['play_order'], 1)
def post(self):
asset = prepare_asset_v1_2(request)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
with db.conn(settings['database']) as conn:
assets = assets_helper.read(conn)
ids_of_active_assets = [x['asset_id'] for x in assets if x['is_active']]
asset = assets_helper.create(conn, asset)
if asset['is_active']:
ids_of_active_assets.insert(asset['play_order'], asset['asset_id'])
assets_helper.save_ordering(conn, ids_of_active_assets)
return assets_helper.read(conn, asset['asset_id']), 201
def post(self):
asset = prepare_asset_v1_2(request)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
with db.conn(settings['database']) as conn:
if (asset['mimetype'] == 'presentation'
or asset['mimetype'] == 'pdf'):
createMultipleAssetsFromPresentationOrPdf(asset, conn)
#return assets_helper.read(conn, asset['asset_id']),201
else:
assets = assets_helper.read(conn)
ids_of_active_assets = [
x['asset_id'] for x in assets if x['is_active']
]
asset = assets_helper.create(conn, asset)
if asset['is_active']:
ids_of_active_assets.insert(asset['play_order'],
asset['asset_id'])
assets_helper.save_ordering(conn, ids_of_active_assets)
return assets_helper.read(conn, asset['asset_id']), 201
def post(self):
asset = prepare_asset(request)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
with db.conn(settings['database']) as conn:
return assets_helper.create(conn, asset), 201
def post(self):
asset = prepare_asset(request, unique_name=True)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
with db.conn(settings['database']) as conn:
return assets_helper.create(conn, asset), 201
def test_create_read_asset(self):
assets_helper.create(self.conn, asset_x)
assets_helper.create(self.conn, asset_y)
should_be_y_x = assets_helper.read(self.conn)
self.assertEqual([asset_y, asset_x], should_be_y_x)
def test_create_read_asset(self):
assets_helper.create(self.conn, asset_x)
assets_helper.create(self.conn, asset_y)
should_be_y_x = assets_helper.read(self.conn)
self.assertEqual([asset_y, asset_x], should_be_y_x)
def add_asset():
asset = prepare_asset(request)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
return assets_helper.create(db_conn, asset)
def add_asset():
asset = prepare_asset(request)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
return assets_helper.create(db_conn, asset)
