class TestCoherence(unittest.TestCase):
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error'})
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_singleton(self):
d = Deferred()
c1 = Coherence({'unittest':'no','logmode':'error'})
c2 = Coherence({'unittest':'no','logmode':'error'})
c3 = Coherence({'unittest':'no','logmode':'error'})
def shutdown(r,instance):
return instance.shutdown()
d.addCallback(shutdown,c1)
d.addCallback(shutdown,c2)
d.addCallback(shutdown,c3)
reactor.callLater(3, d.callback, None)
return d
class TestSwitchPowerClient(unittest.TestCase):
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error','subsystem_log':{'controlpoint':'error'},'controlpoint':'yes'})
self.uuid = UUID()
p = self.coherence.add_plugin('SimpleLight', name='test-light-%d'%os.getpid(),uuid=str(self.uuid))
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_get_state(self):
""" tries to find the activated SimpleLight backend
and queries its state.
The state is expected to be "off"
"""
d = Deferred()
def the_result(r):
#print "the_result", r
self.assertEqual(str(self.uuid), r.udn)
call = r.client.switch_power.get_status()
def got_answer(r):
self.assertEqual(int(r['ResultStatus']), 0)
d.callback(None)
call.addCallback(got_answer)
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def setUp(self):
self.tmp_content = FilePath('tmp_content_coherence-%d'%os.getpid())
f = self.tmp_content.child('content')
audio = f.child('audio')
f.child('images').makedirs()
f.child('video').makedirs()
album = audio.child('album-1')
album.makedirs()
album.child('track-1.mp3').touch()
album.child('track-2.mp3').touch()
album = audio.child('album-2')
album.makedirs()
album.child('track-1.ogg').touch()
album.child('track-2.ogg').touch()
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'debug','subsystem_log':{'controlpoint':'error',
'action':'error',
'soap':'error'},'controlpoint':'yes'})
self.uuid = UUID()
p = self.coherence.add_plugin('FSStore',
name='MediaServer-%d'%os.getpid(),
content=self.tmp_content.path,
uuid=str(self.uuid))
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error','subsystem_log':{'controlpoint':'error'},'controlpoint':'yes'})
self.uuid = UUID()
p = self.coherence.add_plugin('SimpleLight', name='test-light-%d'%os.getpid(),uuid=str(self.uuid))
class TestContentDirectoryServer(unittest.TestCase):
def setUp(self):
self.tmp_content = FilePath('tmp_content_coherence-%d'%os.getpid())
f = self.tmp_content.child('content')
audio = f.child('audio')
f.child('images').makedirs()
f.child('video').makedirs()
album = audio.child('album-1')
album.makedirs()
album.child('track-1.mp3').touch()
album.child('track-2.mp3').touch()
album = audio.child('album-2')
album.makedirs()
album.child('track-1.ogg').touch()
album.child('track-2.ogg').touch()
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'debug','subsystem_log':{'controlpoint':'error',
'action':'error',
'soap':'error'},'controlpoint':'yes'})
self.uuid = UUID()
p = self.coherence.add_plugin('FSStore',
name='MediaServer-%d'%os.getpid(),
content=self.tmp_content.path,
uuid=str(self.uuid))
def tearDown(self):
self.tmp_content.remove()
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_Browse(self):
""" tries to find the activated FSStore backend
and browses its root.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_second_answer(r,childcount):
try:
self.assertEqual(int(r['TotalMatches']), childcount)
d.callback(None)
except:
d.errback()
def got_first_answer(r):
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.childCount, 3)
except:
d.errback()
call = mediaserver.client.content_directory.browse(object_id=item.id,
process_result=False)
call.addCallback(got_second_answer,item.childCount)
return call
call = mediaserver.client.content_directory.browse(process_result=False)
call.addCallback(got_first_answer)
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
return
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.title, 'root')
except:
d.errback()
return
d.callback(None)
call = mediaserver.client.content_directory.browse(object_id='0',browse_flag='BrowseMetadata',process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_XBOX_Browse(self):
""" tries to find the activated FSStore backend
and browses all audio files.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect four audio files here """
try:
self.assertEqual(int(r['TotalMatches']), 4)
except:
d.errback()
return
d.callback(None)
def my_browse(*args,**kwargs):
kwargs['ContainerID'] = kwargs['ObjectID']
del kwargs['ObjectID']
del kwargs['BrowseFlag']
kwargs['SearchCriteria'] = ''
return 'Search',kwargs
#mediaserver.client.overlay_actions = {'Browse':my_browse}
mediaserver.client.overlay_headers = {'user-agent':'Xbox/Coherence emulation'}
call = mediaserver.client.content_directory.browse(object_id='4',process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_XBOX_Browse_Metadata(self):
""" tries to find the activated FSStore backend
and requests metadata for ObjectID 0.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect one item here """
try:
self.assertEqual(int(r['TotalMatches']), 1)
except:
d.errback()
return
didl = DIDLLite.DIDLElement.fromString(r['Result'])
item = didl.getItems()[0]
try:
self.assertEqual(item.title, 'root')
except:
d.errback()
return
d.callback(None)
mediaserver.client.overlay_headers = {'user-agent':'Xbox/Coherence emulation'}
call = mediaserver.client.content_directory.browse(object_id='0',browse_flag='BrowseMetadata',process_result=False)
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def test_XBOX_Search(self):
""" tries to find the activated FSStore backend
and searches for all its audio files.
"""
d = Deferred()
def the_result(mediaserver):
try:
self.assertEqual(str(self.uuid), mediaserver.udn)
except:
d.errback()
def got_first_answer(r):
""" we expect four audio files here """
try:
self.assertEqual(len(r), 4)
except:
d.errback()
d.callback(None)
mediaserver.client.overlay_headers = {'user-agent':'Xbox/Coherence emulation'}
call = mediaserver.client.content_directory.search(container_id='4',
criteria='')
call.addCallback(got_first_answer)
call.addErrback(lambda x: d.errback(None))
self.coherence.ctrl.add_query(DeviceQuery('uuid', str(self.uuid), the_result, timeout=10, oneshot=True))
return d
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error','use_dbus':'yes','controlpoint':'yes'})
self.bus = dbus.SessionBus()
self.coherence_service = self.bus.get_object(BUS_NAME,OBJECT_PATH)
self.uuid = UUID()
class TestDBUS(unittest.TestCase):
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error','use_dbus':'yes','controlpoint':'yes'})
self.bus = dbus.SessionBus()
self.coherence_service = self.bus.get_object(BUS_NAME,OBJECT_PATH)
self.uuid = UUID()
def tearDown(self):
def cleaner(r):
self.coherence.clear()
return r
dl = self.coherence.shutdown()
dl.addBoth(cleaner)
return dl
def test_dbus_version(self):
""" tests the version number request via dbus
"""
d = Deferred()
def handle_version_reply(version):
self.assertEqual(version,__version__)
d.callback(version)
def handle_error(err):
d.errback(err)
self.coherence_service.version(dbus_interface=BUS_NAME,
reply_handler=handle_version_reply,
error_handler=handle_error)
return d
def test_dbus_plugin_add_and_remove(self):
""" tests creation and removal of a backend via dbus
"""
d = Deferred()
def handle_error(err):
d.errback(err)
def handle_add_plugin_reply(uuid):
uuid = str(uuid)
self.assertEqual(str(self.uuid),uuid)
def remove_it(uuid):
def handle_remove_plugin_reply(uuid):
self.assertEqual(str(self.uuid),uuid)
d.callback(uuid)
self.coherence_service.remove_plugin(uuid,
dbus_interface=BUS_NAME,
reply_handler=handle_remove_plugin_reply,
error_handler=handle_error)
reactor.callLater(2,remove_it,uuid)
self.coherence_service.add_plugin('SimpleLight',{'name':'dbus-test-light-%d'%os.getpid(),'uuid':str(self.uuid)},
dbus_interface=BUS_NAME,
reply_handler=handle_add_plugin_reply,
error_handler=handle_error)
return d
def start(self):
print "I'm started"
config = {'logmode':'warning'}
c = Coherence(config)
print "to connect"
c.connect(self.check_device, 'Coherence.UPnP.Device.detection_completed')
def setUp(self):
louie.reset()
self.coherence = Coherence({'unittest':'yes','logmode':'error'})
