def test_cache_consistent_across_sessions(self):
sandbox = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, sandbox, ignore_errors=True)
nextProvider = Mock()
platform = Mock()
when(platform).getCacheDir().thenReturn(sandbox)
when(nextProvider).getPosters(any(Program)).thenReturn([
'http://a.com/a.gif', 'http://b.com/b.gif', 'http://c.com/c.gif',
'http://d.com/d.gif'
])
provider = SuperFastFanartProvider(platform, nextProvider)
programs = []
for i in xrange(1000):
program = TVProgram({
'title': 'P%d' % i,
'category_type': 'series'
},
translator=Mock())
httpUrls = provider.getPosters(program)
self.assertTrue(4, len(httpUrls))
programs.append(program)
provider.close()
nextProvider = Mock()
provider2 = SuperFastFanartProvider(platform, nextProvider)
for p in programs:
httpUrls = provider2.getPosters(p)
self.assertTrue(4, len(httpUrls))
provider2.close()
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_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_hashable(self):
s1 = RecordingSchedule({'recordid' : 1}, Mock())
s2 = RecordingSchedule({'recordid' : 2}, Mock())
d = {s1:'schedule1',}
self.assertIn(s1, d)
self.assertEqual('schedule1', d[s1])
self.assertNotIn(s2, d)
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_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 setUp(self):
self.conn = Mock()
self.settings = Mock()
self.translator = Mock()
self.platform = Mock()
self.protocol = TEST_PROTOCOL
self.pkwargs = {'settings':self.settings, 'translator': self.translator, 'platform':self.platform, 'protocol':self.protocol, 'conn':self.conn}
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_token_error(self):
token = Mock()
token.value = 'unknown'
token.lexer = Mock()
token.lexer.lineno = 10
self.assertRaises(LingoLexingException, self.parser.t_error, token)
def setUp(self):
self.platform = getPlatform()
self.translator = Mock()
self.settings = MythSettings(self.platform, self.translator)
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.bus = EventBus()
self.domainCache = Mock()
pools['dbPool'] = Pool(
MythDatabaseFactory(settings=self.settings,
translator=self.translator,
domainCache=self.domainCache))
pools['connPool'] = Pool(
ConnectionFactory(settings=self.settings,
translator=self.translator,
platform=self.platform,
bus=self.bus))
def setUp(self):
self.db = Mock()
self.conn = Mock()
self.translator = Mock()
self.domainCache = Mock()
self.tuner = Tuner(4, 'mrbun', 1000, 6000, 'HDHOMERUN',
self.domainCache, self.conn, self.db,
self.translator)
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 setUp(self):
self.pcb1 = Mock()
self.pcb2 = Mock()
self.interruptor = Mock()
self.logger = Mock()
self.printLine1 = InstIO("Impresion 1", 0)
self.printLine2 = InstIO("Impresion 2", 0)
self.queue = Queue()
self.device = Device("Printer", self.interruptor, self.queue) # 0 equals to the device cod printer
self.device.setLogger(self.logger)
def setUp(self):
self.tracker = Mock()
self.translator = Mock()
when(self.translator).get(any()).thenReturn('some %s string')
self.player = Mock()
self.player.tracker = self.tracker
self.program = Mock()
when(self.program).title().thenReturn('movie.mpg')
def test_getLatestEntries_None(self):
# Setup
settings = Mock()
when(settings).get(any()).thenReturn('blah')
feedHose = FeedHose(settings=settings, bus=Mock())
# Test
entries = feedHose.getLatestEntries()
# Verify
self.assertTrue(len(entries) == 0)
def setUp(self):
self.sandbox = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.sandbox, ignore_errors=True)
self.platform = Mock()
when(self.platform).getCacheDir().thenReturn(self.sandbox)
self.deps = {
'settings': Mock(),
'translator': Mock(),
'platform': self.platform,
'protocol': TEST_PROTOCOL,
'conn': Mock()
}
def setUp(self):
self.conn = Mock()
self.settings = Mock()
self.translator = Mock()
self.platform = Mock()
self.protocol = protocol.Protocol23056()
self.pkwargs = {
'settings': self.settings,
'translator': self.translator,
'platform': self.platform,
'protocol': self.protocol,
'conn': self.conn
}
def setUp(self):
self.sandbox = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.sandbox, ignore_errors=True)
self.nextProvider = Mock()
self.platform = Mock()
when(self.platform).getCacheDir().thenReturn(self.sandbox)
self.program = TVProgram(
{
'title': 'Two Fat Ladies',
'category_type': 'series'
},
translator=Mock())
self.provider = SuperFastFanartProvider(self.platform,
self.nextProvider)
def setUp(self):
self.nextProvider = Mock()
self.dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, self.dir, ignore_errors=True)
self.httpCache = FileCache(self.dir, HttpResolver())
self.program = TVProgram(
{
'title': 'Not Important',
'category_type': 'series'
},
translator=Mock())
self.provider = HttpCachingFanartProvider(self.httpCache,
self.nextProvider)
self.addCleanup(self.provider.close)
def test_enterText_Should_DoNothing_When_UserCancelsOperation(self):
# Setup
xbmc.Keyboard.stubConfirmed = False
control = Mock()
validator = Mock()
updater = Mock()
# Test
enterText(control=control,
validator=validator.validate,
updater=updater.update)
# Verify
verifyZeroInteractions(validator)
verifyZeroInteractions(updater)
def setUp(self):
self.spam = TVProgram(
{
'title': 'Paid Programming',
'category_type': 'series'
},
translator=Mock())
self.notSpam = TVProgram(
{
'title': 'I am not spam',
'category_type': 'series'
},
translator=Mock())
self.next = Mock()
self.provider = SpamSkippingFanartProvider(nextProvider=self.next)
def test_episodeFilter_and_checkForDupesIn_read_from_and_written_to_dupin_field_correctly(
self):
data = {
'dupin':
CheckForDupesIn.ALL_RECORDINGS
| EpisodeFilter.EXCLUDE_REPEATS_AND_GENERICS
}
schedule = RecordingSchedule(data, Mock())
self.assertEqual(EpisodeFilter.EXCLUDE_REPEATS_AND_GENERICS,
schedule.getEpisodeFilter())
schedule.setEpisodeFilter(EpisodeFilter.NEW_EPISODES_ONLY)
self.assertEqual(EpisodeFilter.NEW_EPISODES_ONLY,
schedule.getEpisodeFilter())
self.assertEqual(CheckForDupesIn.ALL_RECORDINGS,
schedule.getCheckForDupesIn())
schedule.setCheckForDupesIn(CheckForDupesIn.PREVIOUS_RECORDINGS)
self.assertEqual(EpisodeFilter.NEW_EPISODES_ONLY,
schedule.getEpisodeFilter())
self.assertEqual(CheckForDupesIn.PREVIOUS_RECORDINGS,
schedule.getCheckForDupesIn())
schedule.setEpisodeFilter(EpisodeFilter.NONE)
self.assertEqual(EpisodeFilter.NONE, schedule.getEpisodeFilter())
self.assertEqual(CheckForDupesIn.PREVIOUS_RECORDINGS,
schedule.getCheckForDupesIn())
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_starttime_DataFromNativeMySQL(self):
data = {
'starttime':
datetime.timedelta(seconds=(1 * 60 * 60) + (2 * 60) + 3)
}
schedule = ScheduleFromQuery(data, Mock())
self.assertEquals('010203', schedule.starttime())
def test_getPosters_When_pounded_by_many_threads_looking_up_same_program_Then_doesnt_fail_miserably(
self):
programs = []
for i in xrange(10): #@UnusedVariable
programs.append(
TVProgram({
'title': 'Seinfeld',
'category_type': 'series'
},
translator=Mock()))
provider = self.getProvider()
@run_async
def work(p):
posters = provider.getPosters(p)
if len(posters) == 0:
self.fail = True
for poster in posters:
log.debug('%s - %s' % (p.title(), poster))
self.fail = False
threads = []
for p in programs:
threads.append(work(p))
for t in threads:
t.join()
self.assertFalse(self.fail)
def test_getPosters_When_program_is_movie_Then_returns_empty_list(self):
program = TVProgram({
'title': 'Departed',
'category_type': 'movie'
},
translator=Mock())
self.assertListEqual([], self.getProvider().getPosters(program))
def getTvShows(self):
return map(
lambda t: TVProgram({
'title': t,
'category_type': 'series'
},
translator=Mock()), self.tvShows)
def getMovies(self):
return map(
lambda t: TVProgram({
'title': t,
'category_type': 'movie'
},
translator=Mock()), self.movies)
