def __testLibrarySearch(self, library_type):
library = getattr(self.deejayd, library_type + "lib")
testdata = getattr(self, "test_" + library_type + "data")
# search an unknown terms
f = Equals("title", testdata.get_random_string())
self.assertEqual(library.search(f), [])
# search with an unknown type
f = Equals(testdata.get_random_string(), testdata.get_random_string())
self.assertRaises(DeejaydError, library.search, f)
# search a known terms
media = testdata.get_random_media()
f = Equals("title", media["title"])
ans = library.search(f)
self.assertTrue(len(ans) > 0)
def testLibraryAudioTagList(self):
tag = 'artist'
ft = Or(Equals('genre', self.test_audiodata.get_random_genre()),
Equals('genre', self.test_audiodata.get_random_genre()))
expected_tag_list = []
for song_info in self.test_audiodata.get_medias():
matches = False
for f in ft.subfilters:
if song_info.tags['genre'] == f.pattern:
matches = True
if matches:
if song_info.tags[tag] not in expected_tag_list:
expected_tag_list.append(song_info.tags[tag])
result = self.deejayd.audiolib.tag_list(tag, ft)
for tag_value in expected_tag_list:
self.assertTrue(tag_value in result)
def testRecPlsMagicAddFilter(self):
"""test recpls.magicAddFilter command"""
recpls = self.deejayd.recpls
pl_id = self.__createRecordedPlaylist("magic")["pl_id"]
genre = self.test_audiodata.get_random_genre()
r_filter = Equals('genre', genre)
rnd_filter = Equals('genre', self.testdata.get_random_string())
# add correct filter
self.assertAckCmd(recpls.magic_add_filter(pl_id, r_filter))
# verify playlist content
medias = recpls.get_content(pl_id)
filters = recpls.magic_get_filters(pl_id)
self.assertEqual(len(filters), 1)
self.assertTrue(r_filter.equals(filters[0]))
for m in medias:
self.assertEqual(m['genre'], genre)
# remove filter
self.assertAckCmd(recpls.magic_remove_filter(pl_id, r_filter))
self.assertEqual(len(recpls.magic_get_filters(pl_id)), 0)
# add random filter
self.assertAckCmd(recpls.magic_add_filter(pl_id, rnd_filter))
# verify playlist content
medias = recpls.get_content(pl_id)
filters = recpls.magic_get_filters(pl_id)
self.assertEqual(len(filters), 1)
self.assertEqual(len(medias), 0)
self.assertTrue(rnd_filter.equals(filters[0]))
# clear filter
self.assertAckCmd(recpls.magic_clear_filter(pl_id))
self.assertEqual(len(recpls.magic_get_filters(pl_id)), 0)
def test_sub_broadcast_recpls_update(self):
"""Checks that recpls.update signals are broadcasted."""
ans = self.deejayd.audiolib.get_dir_content().wait_for_answer()
dir_obj = self.testdata.get_random_element(ans["directories"])
ft = Equals('genre', self.test_audiodata.get_random_genre())
st_pl_name = self.testdata.get_random_string()
mg_pl_name = self.testdata.get_random_string()
recpls = self.deejayd.recpls
st_pl_id = recpls.create(st_pl_name,
'static').wait_for_answer()["pl_id"]
mg_pl_id = recpls.create(mg_pl_name,
'magic').wait_for_answer()["pl_id"]
trigger_list = (
(recpls.static_load_folders, (st_pl_id, [dir_obj["id"]],)),
(recpls.magic_add_filter, (mg_pl_id, ft,)),
(recpls.magic_remove_filter, (mg_pl_id, ft,)),
(recpls.magic_set_property, (mg_pl_id, 'use-limit', '1'))
)
for trig in trigger_list:
self.generic_sub_bcast_test('recpls.update', trig[0], trig[1])
"data": base64.b64decode(album.cover),
"mimetype": album.cover_type
}
return None
if __name__ == "__main__":
import sys
import pprint
from deejayd.ui.i18n import DeejaydTranslations
from deejayd.db import connection
from deejayd.db.models import Equals
pp = pprint.PrettyPrinter(indent=2)
# init filter and audio library
f = Equals(tag="artist", pattern="J.A.H.O.")
DeejaydTranslations().install()
connection.init("sqlite://")
Session()
library = AudioLibrary(sys.argv[1])
library.update(sync=True)
# display root content
print("------------ Library content -------------")
pp.pprint(library.get_dir_content(''))
# display album list
print("------------ Album list -------------")
pp.pprint(library.album_list())
print(library.album_details(2))
# test simple filter
def get_sample_filter(self):
filter = And(
Contains(tag='artist', pattern='Britney'),
Or(Equals(tag='genre', pattern='Classical'),
Equals(tag='genre', pattern='Disco')))
return filter
def build(self, sections):
filter = And(Equals("artist", "artist_name"),
Or(Contains("genre", "Rock"), NotEquals("Rating", 4)))
j_sig = {
"type": "signal",
"answer": {
"name": "signal_name",
"attrs": {"attr1": "value1"},
}
}
signal = JSONRPCResponse(j_sig, None).to_json()
return """= deejayd - JSON-RPC Protocol =
Deejayd protocol follows JSON-RPC 1.0 specification available
[http://json-rpc.org/wiki/specification here].
All data between the client and server is encoded in UTF-8.
== Commands Format ==
%(cmd_format)s
== Response Format ==
%(answer)s
== Separator ==
Commands and Responses always finish with the separator `ENDJSON\\n`.
So a command is interpreted by deejayd server only if it finish with this
separator.
== Specific Objects ==
=== Mediafilter Objects ===
Mediafilter object has been serialized in a specific way to be passed as
an method argument or receive with an answer. An example is given here.
{{{
`%(filter)s`
}}}
=== Sort Objects ===
Sort object has been serialized in a specific way to be passed as
an method argument or receive with an answer. An example is given here.
{{{
`[["tag1", "ascending"], ["tag2", "descending"]]`
}}}
Possible sort values are : "ascending" and "descending".
=== Signal Objects ===
Signal is available for TCP connection only.
Signal object has been serialized in a specific way to be send to client.
An example is given here.
{{{
`%(signal)s`
}}}
== Common Available Commands ==
%(commands)s
""" % {
"cmd_format": self.commandDoc(),
"answer": self.answerDoc(),
"filter": filter.to_json(),
"commands": "\n\n".join([self.formatSectionDoc(s) for s in sections]),
"signal": signal,
}