def setUp(self):
     MiroTestCase.setUp(self)
     self.manual_feed = Feed(u'dtv:manualFeed')
     self.regular_feed = Feed(u'http://example.com/1')
     self.path, fp = self.make_temp_path_fileobj(".avi")
     fp.write("fake data")
     fp.close()

 def setUp(self):
     MiroTestCase.setUp(self)
     self.feed = Feed(u'http://example.com/1')
     self.item1 = Item(fp_values_for_url(u'http://example.com/1/item1'),
             feed_id=self.feed.id)
     self.item2 = Item(fp_values_for_url(u'http://example.com/1/item2'),
             feed_id=self.feed.id)

 def setUp(self):
     MiroTestCase.setUp(self)
     FakeInfo.counter = itertools.count()
     self.infolist = self.build_infolist()
     self.sorter = self.sort_key_func
     self.reverse = False
     self.correct_infos = []

 def tearDown(self):
     MiroTestCase.tearDown(self)
     logger = logging.getLogger()
     logger.setLevel(self._log_level)
     for old_filter in logger.filters:
         logger.removeFilter(old_filter)
     for filter in self._old_filters:
         logger.addFilter(filter)

 def setUp(self):
     MiroTestCase.setUp(self)
     self.items = []
     self.feed = Feed(u'dtv:manualFeed')
     self.items = [
         testobjects.make_item(self.feed, u'item-1'),
         testobjects.make_item(self.feed, u'item-2'),
     ]

 def setUp(self):
     MiroTestCase.setUp(self)
     self.init_data_package()
     self.feed = models.Feed(u'http://example.com/feed.rss')
     self.items = [testobjects.make_item(self.feed, u'item-%s' % i)
                   for i in xrange(10)]
     app.db.finish_transaction()
     self.pool = itemlist.ItemListPool()
     self.item_list = self.pool.get('feed', self.feed.id)
     self.item_list2 = self.pool.get('feed', self.feed.id + 1)

 def setUp(self):
     MiroTestCase.setUp(self)
     self.mock_grab_headers = self.patch_for_test("miro.httpclient.grab_headers")
     self.mock_try_scraping_url = self.patch_for_test("miro.flashscraper.try_scraping_url")
     self.mock_send = self.patch_for_test("miro.dl_daemon.command.Command.send")
     self.feed = testobjects.make_feed()
     self.url = u"http://example.com/my-video.mp4"
     self.item = testobjects.make_item(self.feed, u"my item", url=self.url)
     self.downloading_path = os.path.join(self.tempdir, "Incomplete Downloads", "download.mp4")
     self.final_path = os.path.join(self.tempdir, "download.mp4")

 def setUp(self):
     MiroTestCase.setUp(self)
     self.device = mock.Mock()
     self.device.database = devices.DeviceDatabase()
     self.device.database[u'audio'] = {}
     self.device.mount = self.tempdir
     self.device.id = 123
     self.device.name = 'Device'
     self.device.size = 1024000
     os.makedirs(os.path.join(self.device.mount, '.miro'))

    def setUp(self):
        app.testing_mdp = True # hack to override moviedata's in_unit_tests hack
        MiroTestCase.setUp(self)
        self.feed = models.Feed(u'dtv:manualFeed')
        mp3_path = resources.path("testdata/metadata/mp3-0.mp3")
        webm_path = resources.path("testdata/metadata/webm-0.webm")
        jpg_path = resources.path("testdata/dean.jpg")

        self.audio_item = models.FileItem(mp3_path, self.feed.id)
        self.video_item = models.FileItem(webm_path, self.feed.id)
        self.other_item = models.FileItem(jpg_path, self.feed.id)

 def setUp(self):
     MiroTestCase.setUp(self)
     self.mock_item_list_pool = self.patch_for_test(
         'miro.app.item_list_pool')
     self.items = [
         mock.Mock(id=0, title='one', is_playable=True),
         mock.Mock(id=1, title='two', is_playable=True),
         mock.Mock(id=2, title='three', is_playable=False),
         mock.Mock(id=3, title='four', is_playable=True),
     ]
     self.item_list = MockItemList(self.items)

    def setUp(self):
        MiroTestCase.setUp(self)
        self.feed = feed.Feed(u"http://feed.org")
        self.i1 = item.Item(item.FeedParserValues({'title': u'item1'}),
                            feed_id=self.feed.id)
        self.i2 = item.Item(item.FeedParserValues({'title': u'item2'}),
                            feed_id=self.feed.id)

        self.feed2 = feed.Feed(u"http://feed.com")
        self.i3 = item.Item(item.FeedParserValues({'title': u'item3'}),
                            feed_id=self.feed2.id)

    def setUp(self):
        MiroTestCase.setUp(self)
        logger = logging.getLogger()
        self._log_level = logger.getEffectiveLevel()
        self._old_filters = logger.filters

        self.log_filter = LogFilter()
        logger.setLevel(logging.DEBUG)
        for old_filter in logger.filters:
            logger.removeFilter(old_filter)
        logger.addFilter(self.log_filter)

    def setUp(self):
        MiroTestCase.setUp(self)
        ITUNES_FILE = "iTunes Music Library.xml"

        # import_itunes_path expects a named file directory path that
        # contains filename ITUNES_FILE underneath it.
        fd = -1
        self.tmpf_path = os.path.join(self.tempdir, ITUNES_FILE)
        fd = os.open(self.tmpf_path, os.O_RDWR | os.O_CREAT | os.O_EXCL)
        self.tmpf = os.fdopen(fd, 'w')
        self.file_url = "file://localhost"

 def setUp(self):
     MiroTestCase.setUp(self)
     self.renderer = itemrenderer.ItemRenderer()
     self.feed = models.Feed(u'http://example.com/feed.rss')
     self.item = testobjects.make_item(self.feed, u'item')
     self.manual_feed = models.Feed(u'dtv:manualFeed',
                                    initiallyAutoDownloadable=False)
     self.file_item = models.FileItem(self.make_temp_path(),
                                      self.manual_feed.id)
     app.saved_items = set()
     app.playback_manager = mock.Mock()
     app.playback_manager.item_resume_policy.return_value = False

 def setUp(self):
     MiroTestCase.setUp(self)
     self.init_data_package()
     self.feed = models.Feed(u'http://example.com/feed.rss')
     self.items = [testobjects.make_item(self.feed, u'item-%s' % i)
                   for i in xrange(10)]
     app.db.finish_transaction()
     self.item_list = itemlist.ItemList('feed', self.feed.id)
     self.items_changed_handler = mock.Mock()
     self.list_changed_handler = mock.Mock()
     self.item_list.connect("items-changed", self.items_changed_handler)
     self.item_list.connect("list-changed", self.list_changed_handler)

 def setUp(self):
     MiroTestCase.setUp(self)
     self.feed = models.Feed(u'http://example.com/')
     self.initial_list = []
     self.added_objects = []
     self.changed_objects = []
     self.removed_objects = []
     self.filterer = SearchFilter()
     self.info1 = self.make_info(u'info one')
     self.info2 = self.make_info(u'info two')
     self.info3 = self.make_info(u'info three')
     self.info4 = self.make_info(u'info four')

 def setUp(self):
     MiroTestCase.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)
     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):
     MiroTestCase.setUp(self)
     self.idle_scheduler = mock.Mock()
     self.init_data_package()
     self.setup_items()
     self.setup_connection_pool()
     self.force_wal_mode()
     self.setup_mock_message_handler()
     self.setup_tracker()
     # make the change tracker start fresh for the unittests.  Since we
     # don't know which change tracker our item type will use, we go for
     # the sledge hammer approach here and reset them all.
     models.Item.change_tracker.reset()
     models.DeviceItem.change_tracker.reset()
     models.SharingItem.change_tracker.reset()

    def setUp(self):
        MiroTestCase.setUp(self)
        self.save_path = os.path.join(self.tempdir, "test-db")
        # set up an error handler that tells LiveStorage to use temporary
        # storage if it fails to open a new database
        use_temp = storedatabase.LiveStorageErrorHandler.ACTION_USE_TEMPORARY
        self.error_handler = mock.Mock()
        self.error_handler.handle_open_error.return_value = use_temp

        self.row_data = []

        self.mock_add_timeout = mock.Mock()
        self.patch_function("miro.eventloop.add_timeout", self.mock_add_timeout)

        self.real_sqlite3_connect = sqlite3.connect
        self.patch_function("sqlite3.connect", self.mock_sqlite3_connect)

 def setUp(self):
     MiroTestCase.setUp(self)