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)
