def test_token_error(self): token = Mock() token.value = 'unknown' token.lexer = Mock() token.lexer.lineno = 10 self.assertRaises(LingoLexingException, self.parser.t_error, token)
def test_production_error(self): production = Mock() production.lexer = Mock() production.lexer.lexdata = 'hello\nworld' production.lexpos = 0 production.lineno = 1 self.assertRaises(LingoParsingException, self.parser.p_error, production)
def test_gen_user_secret(self): """Generation of a user secret which randomly salts and hashes.""" secret_hasher = Mock() secret_hasher.digest_size = 3 when(secret_hasher).hexdigest().thenReturn('ababa') secret_generator = secrets.SecretGenerator(lambda: secret_hasher, lambda x: 'aaa') self.assertEqual(secret_generator.gen_user_secret(1), u'ababa') verify(secret_hasher).update(u'aaa#1')
def test_gen_for_two_users(self): """Generation of a user secret from two user ids.""" secret_hasher = Mock() secret_hasher.digest_size = 3 secret_generator = secrets.SecretGenerator(lambda: secret_hasher, lambda x: 'aaa') when(secret_hasher).hexdigest().thenReturn('ababa') self.assertEqual(secret_generator.gen_user_secret(1), u'ababa') verify(secret_hasher).update(u'aaa#1') when(secret_hasher).hexdigest().thenReturn('bcax') self.assertEqual(secret_generator.gen_user_secret(2), u'bcax') verify(secret_hasher).update(u'aaa#2')
def setUp(self): self.platform = getPlatform() self.translator = Mock() self.domainCache = Mock() self.settings = MythSettings(self.platform, self.translator) self.settings.put('streaming_enabled', 'False') privateConfig = OnDemandConfig() self.settings.put('mysql_host', privateConfig.get('mysql_host')) self.settings.put('mysql_port', privateConfig.get('mysql_port')) self.settings.setMySqlDatabase(privateConfig.get('mysql_database')) self.settings.setMySqlUser(privateConfig.get('mysql_user')) self.settings.put('mysql_password', privateConfig.get('mysql_password')) self.settings.put('paths_recordedprefix', privateConfig.get('paths_recordedprefix')) self.db = MythDatabase(self.settings, self.translator, self.domainCache) self.bus = EventBus() self.conn = Connection(self.settings, self.translator, self.platform, self.bus, self.db)
def setUp(self): self.delegate = Mock() self.nextProvider = Mock() self.platform = Mock() self.sandbox = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, self.sandbox) when(self.platform).getCacheDir().thenReturn(self.sandbox) self.program = TVProgram( { 'title': 'Two Fat Ladies', 'category_type': 'series', 'channum': '5.1', 'starttime': datetime.datetime.now(), 'endtime': datetime.datetime.now(), 'subtitle': 'blah', 'description': 'blah' }, translator=Mock())
def test_enterText_Should_NotUpdateControlAndModel_When_UserEnteredTextFailsValidation( self): # Setup xbmc.Keyboard.stubConfirmed = True xbmc.Keyboard.stubText = 'Bubba' control = Mock() updater = Mock() validator = Mock() when(validator).validate(any()).thenRaise(Exception('Invalid name')) # Test enterText(control=control, validator=validator.validate, updater=updater.update) # Verify verifyZeroInteractions(updater) verify(control, 0).setLabel(any(str), any(str))
def test_getPosters_When_program_is_not_movie_Then_returns_empty_list( self): program = TVProgram({ 'title': 'Seinfeld', 'category_type': 'series' }, translator=Mock()) provider = TheMovieDbFanartProvider(nextProvider=None) self.assertListEqual([], provider.getPosters(program))
def test_getSetting_When_empty_setting_but_setting_exists_Then_return_as_empty_str( self): p = Mock() when(p).getUserDataDir().thenReturn('') s = AdvancedSettings( platform=p, init_with= '<advancedsettings><loglevel></loglevel></advancedsettings>') self.assertEqual('', s.getSetting('loglevel'))
def createJob(self, conn=Mock(), db=Mock(), domainCache=Mock(), id=1, jobType=JobType.COMMFLAG, jobStatus=JobStatus.FINISHED): return Job( id=id, channelId=2, startTime=None, insertTime=None, jobType=jobType, cmds=None, flags=None, jobStatus=jobStatus, statusTime=None, hostname='localhost', comment=None, scheduledRunTime=None, translator=self.translator, conn=conn, db=db, domainCache=domainCache)
def test_getPosters_When_title_has_override_Then_returns_posters_for_override( self): # 'Conan' is mapped to 'Conan (2010)' as TVDB's official title program = TVProgram({ 'title': u'Conan', 'category_type': u'series' }, translator=Mock()) urls = self.getProvider().getPosters(program) self.assertTrue(len(urls) > 0)
def test_createKey_When_program_title_contains_unicode_chars_Then_dont_blow_up( self): program = TVProgram( { 'title': u'madeleine (Grabación Manual)', 'category_type': 'series' }, translator=Mock()) key = self.provider.createKey('getPosters', program) self.assertGreater(len(key), 0)
def test_getPositionInQueue_Position_Is_1_of_1(self): # Setup db = Mock() conn = Mock() job = self.createJob(conn=conn, db=db, jobStatus=JobStatus.QUEUED, jobType=JobType.COMMFLAG) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn([job]) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn([job]) # Test pos, numJobs = job.getPositionInQueue() # Verify log.debug('Job is %d of %d' % (pos, numJobs)) self.assertEqual(1, pos) self.assertEqual(1, numJobs)
def test_isJobFor_ShouldReturnTrue(self): # Setup job = self.createJob() job.startTime = datetime.datetime(2009, 12, 5, 10, 20, 00) job.channelId = 1999 data = [''] * self.protocol.recordSize() data[4] = 1999 data[11] = time.mktime( datetime.datetime(2009, 12, 5, 10, 20, 00).timetuple()) program = RecordedProgram(data=data, settings=Mock(), translator=Mock(), platform=Mock(), protocol=self.protocol, conn=Mock()) # Test & verify self.assertTrue(job.isJobFor(program))
def test_isJobFor_ShouldReturnFalse_ChannelIds_DontMatch(self): # Setup job = self.createJob() job.startTime = datetime.datetime(2008, 11, 4, 23, 45, 00) job.channelId = 200 data = [''] * self.protocol.recordSize() data[4] = 1999 data[11] = time.mktime( datetime.datetime(2008, 11, 4, 23, 45, 00).timetuple()) program = RecordedProgram(data=data, settings=Mock(), translator=Mock(), platform=Mock(), protocol=self.protocol, conn=Mock()) # Test & verify self.assertFalse(job.isJobFor(program))
def setUp(self): self.platform = getPlatform() self.translator = Mock() self.domainCache = Mock() self.settings = MythSettings(self.platform, self.translator) privateConfig = OnDemandConfig() self.settings.setMySqlHost(privateConfig.get('mysql_host')) self.settings.setMySqlPort(privateConfig.get('mysql_port')) self.settings.setMySqlDatabase(privateConfig.get('mysql_database')) self.settings.setMySqlUser(privateConfig.get('mysql_user')) self.settings.setMySqlPassword(privateConfig.get('mysql_password')) log.debug('%s' % self.settings) self.db = MythDatabase(self.settings, self.translator, self.domainCache) self.bus = EventBus() self.conn = Connection(self.settings, self.translator, self.platform, self.bus, self.db)
def test_getPositionInQueue_Position_Is_7_of_10(self): # Setup db = Mock() conn = Mock() jobs = [] for i in xrange(1, 11): jobs.append(self.createJob(id=i, jobStatus=JobStatus.QUEUED, jobType=JobType.COMMFLAG)) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn(jobs) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn(jobs) job = self.createJob(conn=conn, db=db, id=7, jobStatus=JobStatus.QUEUED, jobType=JobType.COMMFLAG) # Test pos, numJobs = job.getPositionInQueue() # Verify log.debug('Job is %d of %d' % (pos, numJobs)) self.assertEqual(7, pos) self.assertEqual(10, numJobs)
def programs(cnt): for i in xrange(cnt): #@UnusedVariable yield TVProgram({ 'starttime': '20081121140000', 'endtime' : '20081121140000', 'chanid' : random.randint(1,9999999), 'channum' : str(random.randint(1,10)), 'title' : 'Two Fat Ladies %d' % random.randint(1,999999), 'subtitle' : 'Away we go....', 'description' : 'blah blah blah', 'category_type':'series'}, translator=Mock())
def test_enterText_Should_UpdateModelAndControl_When_UserInputIsValid( self): # Setup xbmc.Keyboard.stubConfirmed = True xbmc.Keyboard.stubText = "Bubba" control = Mock() when(control).getLabel().thenReturn('Name') validator = Mock() updater = Mock() # Test enterText(control=control, validator=validator.validate, updater=updater.update) # Verify verify(validator, 1).validate('Bubba') # TODO: type(xbmc.ControlButton) fails for Mock #verify(control, 1).setLabel(any(str), any(str)) verify(updater, 1).update('Bubba')
def test_getPosters_When_program_is_a_movie_Then_returns_fanart(self): # Setup program = TVProgram({'title':'Fargo', 'category_type':'movie'}, translator=Mock()) provider = ImdbFanartProvider() # Test posters = provider.getPosters(program) # Verify log.debug('Poster URLs = %s' % posters) for p in posters: self.assertEqual('http', p[0:4])
def test_getFramerate(self): from mythbox.mythtv.conn import Connection from mythbox.util import safe_str from mythbox.mythtv.enums import RecordingStatus conn = Connection(settings=self.settings, translator=Mock(), platform=Mock(), bus=Mock(), db=self.db) try: recordings = conn.getAllRecordings()[-10:] for r in recordings: if r.isCommFlagged() and r.getRecordingStatus( ) == RecordingStatus.RECORDED: fps = self.db.getFramerate(r) log.debug('%s - %s - %s %d' % (safe_str(r.title()), safe_str( r.subtitle()), fps, r.getRecordingStatus())) self.assertGreaterEqual(fps, 0.0, fps) finally: conn.close()
def test_setSetting_When_nested_setting_does_not_exist_Then_create_it( self): p = Mock() when(p).getUserDataDir().thenReturn('') s = AdvancedSettings(platform=p) s.setSetting('video/displayremotecodes', 'true') xml = s.__str__() log.debug(xml) [ self.assertTrue(s in xml) for s in ('<video>', '<displayremotecodes>', 'true', '</displayremotecodes>', '</video>') ]
def setUp(self): self.platform = Platform() #self.translator = Mock() self.langInfo = util_mock.XBMCLangInfo(self.platform) self.translator = util_mock.Translator(self.platform, self.langInfo) self.bus = Mock() self.domainCache = Mock() self.settings = MythSettings(self.platform, self.translator) privateConfig = OnDemandConfig() self.settings.put('mysql_host', privateConfig.get('mysql_host')) self.settings.put('mysql_database', privateConfig.get('mysql_database')) self.settings.put('mysql_password', privateConfig.get('mysql_password')) self.db = MythDatabase(self.settings, self.translator, self.domainCache) self.conn = Connection(self.settings, self.translator, self.platform, self.bus, self.db)
def test_moveToFrontOfQueue_From_5_Of_10(self): # Setup jobPos = 4 # zero based index db = Mock() conn = Mock() jobs = [] for i in xrange(1, 11): job = self.createJob(conn=conn, db=db, id=i, jobStatus=JobStatus.QUEUED, jobType=JobType.COMMFLAG) job.scheduledRunTime = datetime.datetime.now().replace(year=(2000 + i)) jobs.append(job) #log.debug('%s' % job) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn(jobs) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn(jobs) job = copy.copy(jobs[jobPos]) # Test job.moveToFrontOfQueue() # Verify # pushed back [1:4] for i, j in enumerate(jobs[:jobPos]): log.debug('job %s = %s' % (i, j)) self.assertTrue(2000 + (i + 2), j.scheduledRunTime.year) # moved to first in queue log.debug('current job = %s' % job) self.assertTrue(2001, job.scheduledRunTime.year) # unaffected jobs [5,10] for i, j in enumerate(jobs[jobPos + 1:]): log.debug('job %s = %s' % (i, j)) self.assertTrue(2000 + (i + 2), j.scheduledRunTime.year)
def test_moveToFrontOfQueue_From_2_Of_2(self): # Setup db = Mock() conn = Mock() jobs = [] for i in xrange(1, 3): job = self.createJob(conn=conn, db=db, id=i, jobStatus=JobStatus.QUEUED, jobType=JobType.COMMFLAG) job.scheduledRunTime = datetime.datetime.now().replace(year=(2000+i)) jobs.append(job) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn(jobs) when(db).getJobs(jobStatus=JobStatus.QUEUED).thenReturn(jobs) job = copy.copy(jobs[1]) # Test job.moveToFrontOfQueue() # Verify for i, j in enumerate(jobs[:-1]): log.debug('job %s = %s' % (i, j)) self.assertEqual(2000 + (i+2), j.scheduledRunTime.year) log.debug('current job = %s' % job) self.assertEqual(2001, job.scheduledRunTime.year)
def test_getSeasonAndEpisode_dont_blowup_when_a_season_is_missing(self): # Given fields = { 'title': u'The Daily Show With Jon Stewart', 'starttime': socketDateTime(2010, 12, 2, 22, 45, 00), 'endtime': socketDateTime(2010, 12, 2, 23, 50, 00), 'hasairdate': 1, 'airdate': u'2005-01-04' } program = RecordedProgram(data=pdata(fields, P.version()), settings=Mock(), translator=Mock(), platform=self.platform, protocol=P, conn=Mock()) provider = TvRageProvider(self.platform) # When -- Season 3 for The Daily Show with Jon Stewart is missing season, episode = provider.getSeasonAndEpisode(program) # Then self.assertIsNotNone(season) self.assertIsNotNone(episode)
def test_getSeasonAndEpisode_When_show_not_found_Then_returns_none(self): # Given fields = { 'title': u'Crap Crappity Crapola', 'starttime': socketDateTime(2008, 11, 4, 22, 45, 00), 'endtime': socketDateTime(2008, 11, 4, 23, 50, 00), 'hasairdate': 1, 'airdate': u'2010-08-03' } program = RecordedProgram(data=pdata(fields, P.version()), settings=Mock(), translator=Mock(), platform=self.platform, protocol=P, conn=Mock()) provider = TvRageProvider(self.platform) # When season, episode = provider.getSeasonAndEpisode(program) # Then self.assertIsNone(season) self.assertIsNone(episode)
def test_getSeasonAndEpisode_When_show_not_found_Then_returns_none(self): # Setup fields = { 'title': u'This Show Does Not Exist', 'starttime': socketDateTime(2008, 11, 4, 22, 45, 00), 'endtime': socketDateTime(2008, 11, 4, 23, 45, 00), 'hasairdate': 1, 'airdate': u'2010-08-03' } program = RecordedProgram(data=pdata(fields, P.version()), settings=Mock(), translator=Mock(), platform=Mock(), protocol=P, conn=Mock()) provider = TvdbFanartProvider(self.platform, nextProvider=None) # When season, episode = provider.getSeasonAndEpisode(program) # Then self.assertIsNone(season) self.assertIsNone(episode)
def test_works_with_TVProgram_not_just_RecordedProgram(self): data = { 'title': u'Love and HipHop', 'subtitle': u'', 'category_type': 'series', 'originalairdate': u'2011-11-21', 'starttime': datetime.datetime(2011, 12, 8, 22), 'endtime': datetime.datetime(2011, 12, 8, 23), } tvProgram = TVProgram(data, translator=Mock()) tvRage = TvRageProvider(self.platform) season, episode = tvRage.getSeasonAndEpisode(tvProgram) self.assertEqual('2', season) self.assertEqual('2', episode)
def test_setSetting_Works_for_many_settings(self): p = Mock() when(p).getUserDataDir().thenReturn('') s = AdvancedSettings(platform=p) s.setSetting('loglevel', '2') s.setSetting('displayremotecodes', 'true') xml = s.__str__() log.debug(xml) self.assertTrue('<loglevel>' in xml) self.assertTrue('2' in xml) self.assertTrue('</loglevel>' in xml) self.assertTrue('<displayremotecodes>' in xml) self.assertTrue('true' in xml) self.assertTrue('</displayremotecodes>' in xml)
def test_setSetting_When_setting_exists_Then_update_it(self): p = Mock() when(p).getUserDataDir().thenReturn('') s = AdvancedSettings( platform=p, init_with= '<advancedsettings><loglevel>3</loglevel></advancedsettings>') s.setSetting('loglevel', '2') xml = s.__str__() log.debug(xml) self.assertTrue('<loglevel>' in xml) self.assertTrue('2' in xml) self.assertTrue('</loglevel>' in xml) self.assertFalse('3' in xml)
def test_setSetting_When_setting_does_not_exist_Then_create_it(self): p = Mock() when(p).getUserDataDir().thenReturn('') s = AdvancedSettings( platform=p, init_with= '<advancedsettings><loglevel>0</loglevel></advancedsettings>') s.setSetting('displayremotecodes', 'true') xml = s.__str__() log.debug(xml) [ self.assertTrue(s in xml) for s in ('<displayremotecodes>', 'true', '</displayremotecodes>') ]
def test_getSeasonAndEpisode_Success(self): # Given fields = { 'title': u'The Real World', 'starttime': socketDateTime(2008, 11, 4, 23, 45, 00), 'endtime': socketDateTime(2008, 11, 4, 23, 45, 00), 'hasairdate': 1, 'airdate': u'2010-07-14' } program = RecordedProgram(data=pdata(fields, P.version()), settings=Mock(), translator=Mock(), platform=self.platform, protocol=P, conn=Mock()) provider = TvRageProvider(self.platform) # When season, episode = provider.getSeasonAndEpisode(program) # Then self.assertEqual('24', season) self.assertEqual('3', episode)
def test_getSeasonAndEpisode_Success_HouseHunters(self): # Given fields = { 'title': u'House Hunters', 'starttime': socketDateTime(2010, 12, 2, 22, 45, 00), 'endtime': socketDateTime(2010, 12, 2, 23, 50, 00), 'hasairdate': 1, 'airdate': u'2008-11-02' } program = RecordedProgram(data=pdata(fields, P.version()), settings=Mock(), translator=Mock(), platform=self.platform, protocol=P, conn=Mock()) provider = TvRageProvider(self.platform) # When season, episode = provider.getSeasonAndEpisode(program) # Then self.assertEqual('30', season) self.assertEqual('2', episode)