def setUp(self):
EventLoopTest.setUp(self)
# need to call setup_tabs for PlaylistTracker() and
# ChannelTracker()
startup.setup_tabs()
self.setup_config()
self.setup_data()
def setUp(self):
print 'setting up'
EventLoopTest.setUp(self)
# We want to store our database in a file, so that we can test
# performance on a freshly opened db.
save_path = FilenameType(self.make_temp_path(extension=".db"))
if os.path.exists(save_path):
os.unlink(save_path)
self.reload_database(save_path)
models.Feed(u'dtv:search')
self.test_handler = messagetest.TestFrontendMessageHandler()
messages.FrontendMessage.install_handler(self.test_handler)
self.backend_message_handler = messagehandler.BackendMessageHandler(
None)
messages.BackendMessage.install_handler(self.backend_message_handler)
self.feed = models.Feed(u'dtv:manualFeed')
self.items = []
template_file = self.make_temp_path(".avi")
self.stats_path = self.make_temp_path(".prof")
open(template_file, 'w').write(' ')
app.bulk_sql_manager.start()
for x in xrange(5000):
path = self.make_temp_path(".avi")
shutil.copyfile(template_file, path)
models.FileItem(path, self.feed.id)
app.bulk_sql_manager.finish()
self.reload_database(save_path)
def setUp(self):
EventLoopTest.setUp(self)
# override the normal handler class with our own
workerprocess._subprocess_manager.handler_class = (
UnittestWorkerProcessHandler)
workerprocess._subprocess_manager.restart_delay = 0
self.reset_results()
def setUp(self):
EventLoopTest.setUp(self)
self.feed = Feed(u"http://feed.uk")
self.i1 = Item(FeedParserValues({"title": u"item1"}), feed_id=self.feed.id)
self.i2 = Item(FeedParserValues({"title": u"item2"}), feed_id=self.feed.id)
self.i3 = Item(FeedParserValues({"title": u"item3"}), feed_id=self.feed.id)
self.i4 = Item(FeedParserValues({"title": u"item4"}), feed_id=self.feed.id)
def setUp(self):
EventLoopTest.setUp(self)
# need to call setup_tabs for PlaylistTracker() and
# ChannelTracker()
startup.setup_tabs()
self.setup_config()
self.setup_data()
def setUp(self):
print 'setting up'
EventLoopTest.setUp(self)
# We want to store our database in a file, so that we can test
# performance on a freshly opened db.
save_path = FilenameType(self.make_temp_path(extension=".db"))
if os.path.exists(save_path):
os.unlink(save_path)
self.reload_database(save_path)
models.Feed(u'dtv:search')
self.test_handler = messagetest.TestFrontendMessageHandler()
messages.FrontendMessage.install_handler(self.test_handler)
self.backend_message_handler = messagehandler.BackendMessageHandler(None)
messages.BackendMessage.install_handler(self.backend_message_handler)
self.feed = models.Feed(u'dtv:manualFeed')
self.items = []
template_file = self.make_temp_path(".avi")
self.stats_path = self.make_temp_path(".prof")
open(template_file, 'w').write(' ')
app.bulk_sql_manager.start()
for x in xrange(5000):
path = self.make_temp_path(".avi")
shutil.copyfile(template_file, path)
models.FileItem(path, self.feed.id)
app.bulk_sql_manager.finish()
self.reload_database(save_path)
def tearDown(self):
self.remove_database()
corrupt_path = os.path.join(os.path.dirname(self.save_path), "corrupt_database")
if os.path.exists(corrupt_path):
os.remove(corrupt_path)
databaseupgrade._upgrade_overide = {}
EventLoopTest.tearDown(self)
def setUp(self):
EventLoopTest.setUp(self)
# override the normal handler class with our own
workerprocess._subprocess_manager.handler_class = (
UnittestWorkerProcessHandler)
workerprocess._subprocess_manager.restart_delay = 0
self.reset_results()
def setUp(self):
EventLoopTest.setUp(self)
self.start_http_server()
self.grab_url_info = self.grab_url_error = None
self.expecting_errback = False
self.event_loop_timeout = 1.0
test_txt_path = resources.path("testdata/httpserver/test.txt")
self.test_response_data = open(test_txt_path).read()
def setUp(self):
EventLoopTest.setUp(self)
self.responder = TestSubprocessResponder()
self.subprocess = subprocessmanager.SubprocessManager(TestMessage,
self.responder, TestSubprocessHandler)
self.subprocess.start()
self._wait_for_subprocess_ready()
def setUp(self):
EventLoopTest.setUp(self)
self.responder = TestSubprocessResponder()
self.subprocess = subprocessmanager.SubprocessManager(
TestMessage, self.responder, TestSubprocessHandler)
self.subprocess.start()
self._wait_for_subprocess_ready()
def tearDown(self):
# need to close the db before removing it from disk
app.db.close()
self.remove_database()
corrupt_path = os.path.join(os.path.dirname(self.save_path),
'corrupt_database')
if os.path.exists(corrupt_path):
os.remove(corrupt_path)
databaseupgrade._upgrade_overide = {}
EventLoopTest.tearDown(self)
def tearDown(self):
# need to close the db before removing it from disk
app.db.close()
self.remove_database()
corrupt_path = os.path.join(os.path.dirname(self.save_path),
'corrupt_database')
if os.path.exists(corrupt_path):
os.remove(corrupt_path)
databaseupgrade._upgrade_overide = {}
EventLoopTest.tearDown(self)
def setUp(self):
EventLoopTest.setUp(self)
app.directory_watcher = FakeDirectoryWatcher
self.dir = self.make_temp_dir_path()
self.url = u'dtv:directoryfeed:%s' % make_url_safe(self.dir)
self.feed = models.Feed(self.url)
self.source_path = resources.path("testdata/pop.mp3")
self.directory_watcher = self.feed.actualFeed.watcher
# not having to wait for a timeout makes the tests simpler and faster
self.feed.actualFeed.DIRECTORY_WATCH_UPDATE_TIMEOUT = 0.0
def setUp(self):
EventLoopTest.setUp(self)
app.directory_watcher = FakeDirectoryWatcher
self.dir = self.make_temp_dir_path()
self.url = u'dtv:directoryfeed:%s' % make_url_safe(self.dir)
self.feed = models.Feed(self.url)
self.source_path = resources.path("testdata/pop.mp3")
self.directory_watcher = self.feed.actualFeed.watcher
# not having to wait for a timeout makes the tests simpler and faster
self.feed.actualFeed.DIRECTORY_WATCH_UPDATE_TIMEOUT = 0.0
def setUp(self):
EventLoopTest.setUp(self)
self.feed = Feed(u"http://feed.uk")
self.i1 = Item(FeedParserValues({'title': u'item1'}),
feed_id=self.feed.id)
self.i2 = Item(FeedParserValues({'title': u'item2'}),
feed_id=self.feed.id)
self.i3 = Item(FeedParserValues({'title': u'item3'}),
feed_id=self.feed.id)
self.i4 = Item(FeedParserValues({'title': u'item4'}),
feed_id=self.feed.id)
def setUp(self):
EventLoopTest.setUp(self)
self.feed = Feed(u"http://feed.uk")
self.i1 = Item(FeedParserValues({'title': u'item1'}),
feed_id=self.feed.id)
self.i2 = Item(FeedParserValues({'title': u'item2'}),
feed_id=self.feed.id)
self.i3 = Item(FeedParserValues({'title': u'item3'}),
feed_id=self.feed.id)
self.i4 = Item(FeedParserValues({'title': u'item4'}),
feed_id=self.feed.id)
def setUp(self):
EventLoopTest.setUp(self)
Feed(u'dtv:search')
self.test_handler = TestFrontendMessageHandler()
messages.FrontendMessage.install_handler(self.test_handler)
self.backend_message_handler = messagehandler.BackendMessageHandler(
None)
messages.BackendMessage.install_handler(self.backend_message_handler)
self.channelTabOrder = TabOrder(u'channel')
self.playlistTabOrder = TabOrder(u'playlist')
# Adding a guide ensures that if we remove all our
# channel/playlist tabs the selection code won't go crazy.
self.guide = ChannelGuide(app.config.get(prefs.CHANNEL_GUIDE_URL))
def setUp(self):
EventLoopTest.setUp(self)
Feed(u'dtv:search')
self.test_handler = TestFrontendMessageHandler()
messages.FrontendMessage.install_handler(self.test_handler)
self.backend_message_handler = messagehandler.BackendMessageHandler(
None)
messages.BackendMessage.install_handler(self.backend_message_handler)
self.channelTabOrder = TabOrder(u'channel')
self.playlistTabOrder = TabOrder(u'playlist')
# Adding a guide ensures that if we remove all our
# channel/playlist tabs the selection code won't go crazy.
self.guide = ChannelGuide(app.config.get(prefs.CHANNEL_GUIDE_URL))
def setUp(self):
EventLoopTest.setUp(self)
self.updater = metadataprogress.MetadataProgressUpdater()
# make messages send immediately to speed up test execution
self.updater.message_interval = 0.0
# setup a fake device to use
self.device = mock.Mock()
self.device.id = 123
# make our handler
self.test_handler = TestFrontendMessageHandler()
messages.FrontendMessage.install_handler(self.test_handler)
# the warnings from MetadataProgressUpdater should be errors in the
# test case
self.log_filter.set_exception_level(logging.WARNING)
def setUp(self):
EventLoopTest.setUp(self)
self.updater = metadataprogress.MetadataProgressUpdater()
# make messages send immediately to speed up test execution
self.updater.message_interval = 0.0
# setup a fake device to use
self.device = mock.Mock()
self.device.id = 123
# make our handler
self.test_handler = TestFrontendMessageHandler()
messages.FrontendMessage.install_handler(self.test_handler)
# the warnings from MetadataProgressUpdater should be errors in the
# test case
self.log_filter.set_exception_level(logging.WARNING)
def setUp(self):
EventLoopTest.setUp(self)
download.chatter = False
download.next_free_filename = lambda x: self.make_temp_path_fileobj()
download._downloads = {}
self.start_http_server()
# screen-redirect is a 302 redirect to linux-screen.jpg, which is a
# fairly big file. The idea is to try to mimic a real-world item,
# which often have redirects.
self.download_url = unicode(
self.httpserver.build_url('screen-redirect'))
self.download_path = resources.path(
'testdata/httpserver/linux-screen.jpg')
self.event_loop_timeout = 0.5
self.download_size = 45572
def setUp(self):
EventLoopTest.setUp(self)
self.feed = Feed(u'dtv:manualFeed', initiallyAutoDownloadable=False)
self.mytempdir = FilenameType(tempfile.mkdtemp(dir=self.tempdir))
self._make_fake_item("pcf.avi")
self._make_fake_item("dean.avi")
self._make_fake_item("npr.txt")
self.container_item = FileItem(self.mytempdir, self.feed.id)
# Give the iterators some time to run
self.process_idles()
for child in self.container_item.get_children():
if child.filename.endswith("avi"):
child.file_type = u'video'
else:
child.file_type = u'other'
child.signal_change()
def setUp(self):
EventLoopTest.setUp(self)
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 0))
server.listen(1)
address = server.getsockname()
self.connectionHandler = TestingConnectionHandler(self)
def stopEventLoop(conn):
self.stopEventLoop(False)
self.connectionHandler.open_connection(address[0], address[1],
stopEventLoop, stopEventLoop)
self.runEventLoop()
self.remoteSocket, address = server.accept()
self.remoteSocket.setblocking(False)
def setUp(self):
EventLoopTest.setUp(self)
self.share = testobjects.make_share()
self.playlist_item_map = mappings.SharingItemPlaylistMap(
self.share.db_info.db.connection)
# Replace threading.Thread() with a mock object so that
# SharingItemTrackerImpl objects don't create real theads.
self.patch_for_test('threading.Thread')
# Replace update_started() and update_finished() with mock objects.
# We want to ignore the TabsChanged messages that they send out.
self.patch_for_test('miro.sharing.Share.update_started')
self.patch_for_test('miro.sharing.Share.update_finished')
# also use a Mock object for the daap client
self.client = testobjects.MockDAAPClient()
self.patch_function('miro.libdaap.make_daap_client',
lambda *args, **kwargs: self.client)
self.MockTabsChanged = self.patch_for_test('miro.messages.TabsChanged')
def tearDown(self):
shutil.rmtree(self.mytempdir, ignore_errors=True)
EventLoopTest.tearDown(self)
def tearDown(self):
EventLoopTest.tearDown(self)
self.stopEventLoop(abnormal=False)
def setUp(self):
EventLoopTest.setUp(self)
self.event_loop_timeout = 20
self.start_http_server()
def setUp(self):
self.data = None
self.errbackCalled = False
self.callbackCalled = False
self.fakeCallbackError = False
EventLoopTest.setUp(self)
def run_event_loop(self, timeout=None):
if timeout == None:
timeout = self.event_loop_timeout
EventLoopTest.runEventLoop(self, timeout=timeout)
def setUp(self):
self.current_value = None
EventLoopTest.setUp(self)
def setUp(self):
EventLoopTest.setUp(self)
self.save_path = FilenameType(self.make_temp_path(extension=".db"))
self.remove_database()
self.reload_test_database()
def setUp(self):
self.got_args = []
self.got_kwargs = []
EventLoopTest.setUp(self)
def setUp(self):
EventLoopTest.setUp(self)
self.filename = self.make_temp_path()
def tearDown(self):
EventLoopTest.tearDown(self)
messages.BackendMessage.reset_handler()
messages.FrontendMessage.reset_handler()
def tearDown(self):
self.subprocess.shutdown()
EventLoopTest.tearDown(self)
def runEventLoop(self, timeout):
EventLoopTest.runEventLoop(self, timeout=timeout)
if self.grab_url_error is not None and not self.expecting_errback:
raise AssertionError("grab_url error: %s" % self.grab_url_error)
def setUp(self):
self.dialogs_seen = 0
signals.system.connect('new-dialog', self.handle_dialog)
EventLoopTest.setUp(self)
def setUp(self):
EventLoopTest.setUp(self)
# override the normal handler class with our own
workerprocess._subprocess_manager.handler_class = (
UnittestWorkerProcessHandler)
self.result = self.error = None
def setUp(self):
self.dialogs_seen = 0
EventLoopTest.setUp(self)
def tearDown(self):
EventLoopTest.tearDown(self)
workerprocess.shutdown()
