def test_search_and_choose(self):
""" Whole process """
ep_finder = NetworkEpisodeVideoFinder()
def print_results(results):
""" presentation callback"""
#print("Résultats {}".format(len(results)))
pass
def catch_err(res):
""" error callback """
print "err catched {}".format(res)
def choose(res):
""" choose callback, actually launches a dl
"""
info("res {}".format(res))
info( "Choosing {}".format(ep_finder.candidates[0]))
ep_finder.on_chosen_launch_dl(ep_finder.candidates[0])
info ("dl_launched ?")
return True
final_test = OnEventDeferred(ep_finder, "download_launched")
final_test.add_error_event(ep_finder, "download_not_launched")
candidates_found = OnEventDeferred(ep_finder, "candidates_found")\
.addCallback(choose).addErrback(catch_err)
ep_find = ep_finder.search_newep(self.episode)\
.addCallback(print_results)
return final_test.addBoth(catch_err)
def test_search_for_ep(self):
def print_results(results):
#print("Résultats {}".format(len(results)))
pass
ep_finder = EpisodeVideoFinder()
ep_find = ep_finder.search_newep(self.episode).addCallback(print_results)
test = OnEventDeferred(ep_finder,"candidates_found")
return test.addCallback(self.assertTrue)
def testError(self):
""" checks if a deferred errbacks """
obj = Gobj()
defe = OnEventDeferred(obj, "ok")
defe.add_error_event(obj, "error")
obj.emit("error")
return defe.addCallbacks(self.fail,
self.assertIsInstance,
errbackArgs=(Failure,))
def test_search_and_choose(self):
ep_finder = EpisodeVideoFinder()
def print_results(results):
pass
#print("Résultats {}".format(len(results)))
def catch_err(res):
print "err catched {}".format(res)
def choose(res):
print ep_finder.candidates[0]
ep_finder.on_chosen_launch_dl(ep_finder.candidates[0])
print "dl_launched ?"
return True
final_test = OnEventDeferred(ep_finder,"download_launched")
final_test.add_error_event(ep_finder,"download_not_launched")
candidates_found = OnEventDeferred(ep_finder,"candidates_found")\
.addCallback(choose).addErrback(catch_err)
ep_find = ep_finder.search_newep(self.episode).addCallback(print_results)
return final_test.addBoth(catch_err)
def on_candidates_found(self):
""" Callback when results are back presents them
to the user """
candidates = finder.candidates
store = VideoResultStore(candidates)
logging.debug("candidates ... {}".format(candidates_view))
candidates_view.set_model(store.get_model())
clo["wait_for_click"] = OnEventDeferred(dl_button, "clicked")
clo["wait_for_click"].addCallback(choose).addCallback(chosen)
cancel_button.connect("clicked", on_cancel_pressed)
window.present()
def setUp(self):#pylint: disable=C0103
""" Init :
"""
print("setting-up")
self.service = app.service.PipeService("../video_finder_server.py")
wait_for_start = OnEventDeferred(self.service, "service-started")
self.service.start()
self.protoc = None
(self.serie, self.episode) = tests.common_test.get_serie_and_ep()
self.connected = None
self.candidates = None
import sys
wait_for_start.addCallback(lambda x: sys.stdout.write("callbask started\n"))
return wait_for_start
def async_start(service, dic, key): """ Puts service in dictionary in deferred start mode, and replaces it on service started """ def on_started_replace(res): """ Replaces deferred with real service """ dic[key] = service return service on_service_started = OnEventDeferred(service, "service_started")\ .addCallback(on_started_replace) dic[key] = on_service_started service.start() return on_service_started
def test_object_client(self):
""" Testing the object client 'NetworkEpisodeVideoFinder'
as a whole"""
finder = NetworkEpisodeVideoFinder()
finder.search_newep(self.episode)
founded = OnEventDeferred(finder, "candidates_found")\
.addCallback(self.set_candidates)
def choose(res):
""" Returns a candidate """
info("res passed to choose :{}".format(res))
return finder.candidates[0]
def launch(choice):
""" launches the dl"""
return finder.on_chosen_launch_dl(choice)
info("waiting for results ...")
return founded.addCallback(choose).addCallback(launch)
def tearDown(self):#pylint: disable=C0103
""" Nothing to do ?"""
print("Tearing down ...")
wait_for_stopping = OnEventDeferred(self.service, "service_ended")
self.service.stop()
return wait_for_stopping
def testCleanup(self): """ Tests the if _clean method clears reactor """ obj = Gobj() defe = OnEventDeferred(obj, "ok") defe._clean()
def testOK(self):
""" check if a deferred callbacks """
obj = Gobj()
defe = OnEventDeferred(obj,"ok")
obj.emit("ok")
return defe # .maybeDeferred(defe)
