def test_hasCommercials_True(self):
p = RecordedProgram(pdata({'programflags':FlagMask.FL_COMMFLAG | FlagMask.FL_AUTOEXP}), **self.pkwargs)
commBreaks = []
commBreaks.append(CommercialBreak(120,180))
when(self.conn).getCommercialBreaks(p).thenReturn(commBreaks)
log.debug('comms = %s' % len(p.getCommercials()))
self.assertTrue(p.hasCommercials())
def test_hasCommercials_True(self):
p = RecordedProgram(pdata({'programflags':FlagMask.FL_COMMFLAG | FlagMask.FL_AUTOEXP}), **self.pkwargs)
commBreaks = []
commBreaks.append(CommercialBreak(120,180))
when(self.conn).getCommercialBreaks(p).thenReturn(commBreaks)
log.debug('comms = %s' % len(p.getCommercials()))
self.assertTrue(p.hasCommercials())
def test_When_program_title_contains_unicode_chars_Then_title_sorting_doesnt_break(self):
u1 = u'Königreich der Himmel'
u2 = u'Avocats et associés'
u3 = u'All Recordings'
protocol = Protocol23056()
ititle = protocol.recordFields().index('title')
d1 = ["0"] * protocol.recordSize()
d1[ititle] = u1
d2 = d1[:]
d2[ititle] = u2
d3 = d1[:]
d3[ititle] = u3
p1 = RecordedProgram(d1, Mock(), Mock(), Mock(), protocol, Mock())
p2 = RecordedProgram(d2, Mock(), Mock(), Mock(), protocol, Mock())
p3 = RecordedProgram(d3, Mock(), Mock(), Mock(), protocol, Mock())
c = [p1, p2, p3]
c.sort(key=TITLE_SORT_BY['Title']['sorter'], reverse=TITLE_SORT_BY['Title']['reverse'])
self.assertTrue(c[0].title() == u3)
self.assertTrue(c[1].title() == u2)
self.assertTrue(c[2].title() == u1)
def getUpcomingRecordings(self, filter=Upcoming.SCHEDULED):
"""
@type filter: UPCOMING_*
@rtype: RecordedProgram[]
"""
upcoming = []
reply = self._sendRequest(self.cmdSock, ['QUERY_GETALLPENDING', '2'])
log.debug('getUpcomingRecordings reply begin= %s' %
safe_str(reply[:80]))
log.debug('getUpcomingRecordings reply end = %s' %
safe_str(reply[-80:]))
numRows = int(reply[1])
offset = 2
from mythbox.mythtv.domain import RecordedProgram
for i in xrange(numRows):
program = RecordedProgram(
reply[offset:offset + self.protocol.recordSize()],
self.settings, self.translator, self.platform, self.protocol,
[self, None][self._db is None])
if program.getRecordingStatus() in filter:
upcoming.append(program)
offset += self.protocol.recordSize()
return upcoming
def test_formattedAirTime(self):
# 9:00pm 9:30pm
p = RecordedProgram(pdata({'starttime':socketTime(21, 0, 0), 'endtime':socketTime(21, 30, 0)}), **self.pkwargs)
print p
self.assertEqual('9:00 - 9:30PM', p.formattedAirTime(short=False))
self.assertEqual('9 - 9:30PM', p.formattedAirTime(short=True))
self.assertEqual('9 - 9:30PM', p.formattedAirTime())
def getRecordings(self, recordingGroup='default', title='all shows'):
"""
Returns a list of RecordedProgram for the given recording group and show title (both case insensetive).
@param recordingGroup: Recording group name or 'All Groups'
@type recordingGroup: string
@param title: Title of program or 'All Shows'
@type title: string
@rtype: RecordedProgram[]
"""
# TODO: Optimize so it doesn't get all recordings and filters locally
programs = []
offset = 0
reply = self._sendRequest(self.cmdSock,
self.protocol.genQueryRecordingsCommand())
numRows = int(reply.pop(0))
recordingGroup = recordingGroup.upper()
title = title.upper()
from mythbox.mythtv.domain import RecordedProgram
for i in xrange(numRows):
response = reply[offset:offset + self.protocol.recordSize()]
# use of self._db intentional
p = RecordedProgram(response, self.settings, self.translator,
self.platform, self.protocol,
[self, None][self._db is None])
if recordingGroup.upper() in ('ALL GROUPS', p.getRecordingGroup().upper(),) and \
title.upper() in ('ALL SHOWS', p.title().upper(),):
programs.append(p)
offset += self.protocol.recordSize()
return programs
def getUpcomingRecordings(self, filter=Upcoming.SCHEDULED):
"""
@type filter: UPCOMING_*
@rtype: RecordedProgram[]
"""
upcoming = []
reply = self._sendRequest(self.cmdSock, ['QUERY_GETALLPENDING', '2'])
log.debug('getUpcomingRecordings reply begin= %s' % safe_str(reply[:80]))
log.debug('getUpcomingRecordings reply end = %s' % safe_str(reply[-80:]))
numRows = int(reply[1])
offset = 2
from mythbox.mythtv.domain import RecordedProgram
for i in xrange(numRows):
program = RecordedProgram(
reply[offset:offset+self.protocol.recordSize()],
self.settings,
self.translator,
self.platform,
self.protocol,
[self, None][self._db is None])
if program.getRecordingStatus() in filter:
upcoming.append(program)
offset += self.protocol.recordSize()
return upcoming
def getRecordings(self, recordingGroup='default', title='all shows'):
"""
Returns a list of RecordedProgram for the given recording group and show title (both case insensetive).
@param recordingGroup: Recording group name or 'All Groups'
@type recordingGroup: string
@param title: Title of program or 'All Shows'
@type title: string
@rtype: RecordedProgram[]
"""
# TODO: Optimize so it doesn't get all recordings and filters locally
programs = []
offset = 0
reply = self._sendRequest(self.cmdSock, self.protocol.genQueryRecordingsCommand())
numRows = int(reply.pop(0))
recordingGroup = recordingGroup.upper()
title = title.upper()
from mythbox.mythtv.domain import RecordedProgram
for i in xrange(numRows):
response = reply[offset:offset+self.protocol.recordSize()]
# use of self._db intentional
p = RecordedProgram(response, self.settings, self.translator, self.platform, self.protocol, [self, None][self._db is None])
if recordingGroup.upper() in ('ALL GROUPS', p.getRecordingGroup().upper(),) and \
title.upper() in ('ALL SHOWS', p.title().upper(),):
programs.append(p)
offset += self.protocol.recordSize()
return programs
def test_originalAirDate_When_missing_Returns_None(self):
rp = RecordedProgram(pdata({
'airdate': '',
'hasairdate': 0
}), **self.pkwargs)
self.assertFalse(rp.hasOriginalAirDate())
self.assertEqual('', rp.originalAirDate())
def test_originalAirDate_When_available_Returns_date_as_string(self):
rp = RecordedProgram(pdata({
'airdate': '2008-10-10',
'hasairdate': 1
}), **self.pkwargs)
self.assertEqual('2008-10-10', rp.originalAirDate())
self.assertTrue(rp.hasOriginalAirDate())
def test_hashable(self):
p1 = RecordedProgram(pdata({'channum':'99', 'starttime':999999}), **self.pkwargs)
p2 = RecordedProgram(pdata({'channum':'101', 'starttime':888888}), **self.pkwargs)
mydict = {p1:'p1', p2:'p2'}
self.assertTrue(p1 in mydict)
self.assertTrue(p2 in mydict)
self.assertEqual('p1', mydict[p1])
self.assertEqual('p2', mydict[p2])
def test_getCommercials_ReturnsOneCommercial(self):
p = RecordedProgram(pdata({'programflags':FlagMask.FL_COMMFLAG | FlagMask.FL_AUTOEXP}), **self.pkwargs)
commBreaks = []
commBreaks.append(CommercialBreak(120,180))
when(self.conn).getCommercialBreaks(p).thenReturn(commBreaks)
result = p.getCommercials()
log.debug('commercials = %s'%result)
self.assertEqual(commBreaks, result)
verify(self.conn).getCommercialBreaks(p)
def test_getCommercials_ReturnsOneCommercial(self):
p = RecordedProgram(pdata({'programflags':FlagMask.FL_COMMFLAG | FlagMask.FL_AUTOEXP}), **self.pkwargs)
commBreaks = []
commBreaks.append(CommercialBreak(120,180))
when(self.conn).getCommercialBreaks(p).thenReturn(commBreaks)
result = p.getCommercials()
log.debug('commercials = %s'%result)
self.assertEqual(commBreaks, result)
verify(self.conn).getCommercialBreaks(p)
def test_eq_False_different_channelNumber_same_startttime(self):
p1 = RecordedProgram(pdata({
'channum': '99',
'starttime': 999999
}), **self.pkwargs)
p2 = RecordedProgram(pdata({
'channum': '101',
'starttime': 999999
}), **self.pkwargs)
self.assertNotEquals(p1, p2)
self.assertNotEquals(p2, p1)
def test_getJobs_ForProgram_ByJobType(self):
# Setup
when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs())
jobs = self.db.getJobs()
if len(jobs) == 0:
log.warn('No jobs in database to test with. Test skipped...')
return
job = jobs[-1] # last job
data = [''] * self.protocol.recordSize()
data[4] = job.channelId
data[11] = time.mktime(job.startTime.timetuple())
program = RecordedProgram(data=data,
settings=Mock(),
translator=Mock(),
platform=Mock(),
protocol=self.protocol,
conn=Mock())
# Test
jobs = self.db.getJobs(program=program, jobType=job.jobType)
# Verify
self.assertTrue(len(jobs) > 0)
for index, actual in enumerate(jobs):
log.debug('job %d = %s' % (index, actual))
self.assertEquals(job.channelId, actual.channelId)
self.assertEquals(job.startTime, actual.startTime)
self.assertEquals(job.jobType, actual.jobType)
def test_getSeasonAndEpisode_try_to_cache_output(self):
# Given
fields = {
'title': u'Seinfeld',
'starttime': socketDateTime(2008, 11, 4, 23, 45, 00),
'endtime': socketDateTime(2008, 11, 4, 23, 50, 00),
'hasairdate': 1,
'airdate': u'1989-07-05'
}
program = RecordedProgram(data=pdata(fields, P.version()),
settings=Mock(),
translator=Mock(),
platform=self.platform,
protocol=P,
conn=Mock())
provider = TvRageProvider(self.platform)
# When
for i in xrange(100): #@UnusedVariable
# TODO Verify hitting cache < 1sec per invocation.
# Since tvrage api is not injected, cannot mock
season, episode = provider.getSeasonAndEpisode(program)
# Then
self.assertEqual('1', season)
self.assertEqual('1', episode)
def test_getSeasonAndEpisode_When_match_not_found_using_original_airdate_Then_match_by_subtitle(
self):
# Given
fields = {
'title': u'WCG Ultimate Gamer',
'subtitle': u'In The Crosshairs',
'starttime': socketDateTime(2010, 12, 2, 22, 45, 00),
'endtime': socketDateTime(2010, 12, 2, 23, 50, 00),
'hasairdate': 1,
'airdate': u'2010-09-20', # TVRage shows date as 2010-09-16
}
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('2', season)
self.assertEqual('5', episode)
def test_getSeasonAndEpisode_NBCNightlyNews_returns_None_cuz_TVRage_throws_KeyError(
self):
# Given
fields = {
'title': u'NBC Nightly News',
'subtitle': u'blah',
'starttime': socketDateTime(2008, 11, 4, 23, 45, 00),
'endtime': socketDateTime(2008, 11, 4, 23, 50, 00),
'hasairdate': 1,
'airdate': u'2010-07-14'
}
program = RecordedProgram(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_getDuration_When_start_and_end_times_same_Then_return_0mins(self):
self.assertEqual(
0,
RecordedProgram(
pdata({
'starttime': socketTime(18, 30, 0),
'endtime': socketTime(18, 30, 0)
}), **self.pkwargs).getDuration())
def test_getSeasonAndEpisode_When_show_not_found_Then_returns_none(self):
fields = {
'title' : u'Crap Crappity Crapola',
'starttime' : socketDateTime(2008, 11, 4, 22, 45, 00),
'endtime' : socketDateTime(2008, 11, 4, 23, 50, 00),
'airdate' : u'2010-08-03'
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), None, None)
def test_getSeasonAndEpisode_Success_HouseHunters(self):
fields = {
'title' : u'House Hunters',
'starttime' : socketDateTime(2010, 12, 2, 22, 45, 00),
'endtime' : socketDateTime(2010, 12, 2, 23, 50, 00),
'airdate' : u'2008-11-02'
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), u'30', u'2')
def test_getSeasonAndEpisode_Success(self):
fields = {
'title' : u'The Real World',
'starttime' : socketDateTime(2008, 11, 4, 23, 45, 00),
'endtime' : socketDateTime(2008, 11, 4, 23, 45, 00),
'airdate' : u'2010-07-14'
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), u'24', u'3')
def test_getSeasonAndEpisode_When_original_airdate_not_available_Then_return_nones(self):
fields = {
'title' : u'The Real World',
'subtitle' : u'',
'starttime' : socketDateTime(2008, 11, 4, 22, 45, 00),
'endtime' : socketDateTime(2008, 11, 4, 23, 50, 00),
'airdate' : u''
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), None, None)
def test_getSeasonAndEpisode_When_search_by_original_airdate_and_subtitle_fails_Then_search_on_record_date(self):
fields = {
'title' : u'Late Night With Jimmy Fallon',
'subtitle' : u'xxx',
'starttime' : socketDateTime(2011, 12, 2, 2, 00, 00),
'endtime' : socketDateTime(2011, 12, 2, 3, 00, 00),
'airdate' : u'2006-10-10'
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), u'2011', u'184')
def test_love_and_hiphop_failure(self):
fields = {
'title' : u'Love and HipHop',
'subtitle' : u'',
'airdate' : u'2011-11-21',
'starttime' : socketDateTime(2011, 12, 8, 22, 00, 00),
'endtime' : socketDateTime(2011, 12, 8, 23, 00, 00),
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), u'2', u'2')
def test_getDuration_When_duration_is_half_hour_Then_return_30mins(self):
# 6:30pm 7:00pm
self.assertEqual(
30,
RecordedProgram(
pdata({
'starttime': socketTime(18, 30, 0),
'endtime': socketTime(19, 0, 0)
}), **self.pkwargs).getDuration())
def test_getSeasonAndEpisode_When_original_airdate_and_subtitle_not_available_Then_return_Nones(self):
fields = {
'title' : u'WCG Ultimate Gamer',
'subtitle' : u'',
'airdate' : u'',
'starttime' : socketDateTime(2010, 12, 2, 22, 45, 00),
'endtime' : socketDateTime(2010, 12, 2, 23, 50, 00),
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), None, None)
def test_isJobFor_ShouldReturnFalse_ChannelIds_DontMatch(self):
# Setup
job = self.createJob()
job.startTime = datetime.datetime(2008, 11, 4, 23, 45, 00)
job.channelId = 200
program = RecordedProgram(pdata({'chanid':1999, 'starttime':time.mktime(datetime.datetime(2008, 11, 4, 23, 45, 00).timetuple())}), **self.deps)
# Test & verify
self.assertFalse(job.isJobFor(program))
def test_getSeasonAndEpisode_NBCNightlyNews_returns_None_cuz_TVRage_throws_KeyError(self):
fields = {
'title' :u'NBC Nightly News',
'subtitle' :u'blah',
'starttime' :socketDateTime(2008, 11, 4, 23, 45, 00),
'endtime' :socketDateTime(2008, 11, 4, 23, 50, 00),
'airdate' :u'2010-07-14'
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), None, None)
def test_getSeasonAndEpisode_When_original_airdate_not_available_and_subtitle_matches_Then_return_season_and_episode(self):
fields = {
'title' : u'The Real World',
'subtitle' : u"Jemmye's White Knight",
'starttime' : socketDateTime(2008, 11, 4, 22, 45, 00),
'endtime' : socketDateTime(2008, 11, 4, 23, 50, 00),
'airdate' : u''
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), u'24', u'3')
def test_getSeasonAndEpisode_When_match_not_found_using_original_airdate_Then_match_by_subtitle(self):
fields = {
'title' : u'WCG Ultimate Gamer',
'subtitle' : u'In The Crosshairs',
'starttime' : socketDateTime(2010, 12, 2, 22, 45, 00),
'endtime' : socketDateTime(2010, 12, 2, 23, 50, 00),
'airdate' : u'2010-09-20', # TVRage shows date as 2010-09-16
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), u'2', u'5')
def test_isJobFor_ShouldReturnTrue(self):
# Setup
job = self.createJob()
job.startTime = datetime.datetime(2009, 12, 5, 10, 20, 00)
job.channelId = 1999
program = RecordedProgram(pdata({'chanid':1999, 'starttime' : time.mktime(datetime.datetime(2009, 12, 5, 10, 20, 00).timetuple())}), **self.deps)
# Test & verify
self.assertTrue(job.isJobFor(program))
def test_getSeasonAndEpisode_succeeds_when_original_airdate_incorrect_and_one_day_behind(self):
fields = {
'title' : u'Love and HipHop',
'subtitle' : u'',
'airdate' : u'2011-11-20',
'starttime' : socketDateTime(2011, 12, 8, 22, 00, 00),
'endtime' : socketDateTime(2011, 12, 8, 23, 00, 00),
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), u'2', u'2')
def test_getSeasonAndEpisode_When_no_matching_original_airdate_or_subtitle_Then_return_nones(self):
fields = {
'title' : u'MasterChef',
'subtitle' : u'',
'starttime' : socketDateTime(2008, 11, 4, 22, 45, 00),
'endtime' : socketDateTime(2008, 11, 4, 23, 50, 00),
'airdate' : u''
}
self.assertSeasonAndEpisode(RecordedProgram(data=pdata(fields), **self.deps), None, None)
def test_originalAirDate_When_missing_Returns_None(self):
rp = RecordedProgram(pdata({'airdate':'','hasairdate':0}), **self.pkwargs)
self.assertFalse(rp.hasOriginalAirDate())
self.assertEqual('', rp.originalAirDate())
def test_originalAirDate_When_available_Returns_date_as_string(self):
rp = RecordedProgram(pdata({'airdate': '2008-10-10', 'hasairdate':1}), **self.pkwargs)
self.assertEqual('2008-10-10', rp.originalAirDate())
self.assertTrue(rp.hasOriginalAirDate())
def test_hasBookmark_True(self):
p = RecordedProgram(pdata(), **self.pkwargs)
p.setProgramFlags(FlagMask.FL_BOOKMARK | FlagMask.FL_AUTOEXP)
self.assertTrue(p.isBookmarked())
self.assertTrue(p.isAutoExpire())
