def test_getRecordingDirs_SingleDirectory(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
settings.put("paths_recordedprefix", "/mnt/mythtv")
log.debug("Recording prefix = %s" % settings.get("paths_recordedprefix"))
dirs = settings.getRecordingDirs()
self.assertEquals(1, len(dirs))
self.assertEquals("/mnt/mythtv", dirs[0])
def test_getRecordingDirs_ManyDirectories(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
settings.put("paths_recordedprefix", os.pathsep.join(["a", "b", "c"]))
log.debug("Recording prefix = %s" % settings.get("paths_recordedprefix"))
dirs = settings.getRecordingDirs()
self.assertEquals(3, len(dirs))
self.assertEquals(["a", "b", "c"], dirs)
def test_getRecordingDirs_SingleDirectory(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
settings.put('paths_recordedprefix', '/mnt/mythtv')
log.debug("Recording prefix = %s" %
settings.get('paths_recordedprefix'))
dirs = settings.getRecordingDirs()
self.assertEquals(1, len(dirs))
self.assertEquals('/mnt/mythtv', dirs[0])
def test_getRecordingDirs_ManyDirectories(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
settings.put('paths_recordedprefix', os.pathsep.join(['a', 'b', 'c']))
log.debug("Recording prefix = %s" %
settings.get('paths_recordedprefix'))
dirs = settings.getRecordingDirs()
self.assertEquals(3, len(dirs))
self.assertEquals(['a', 'b', 'c'], dirs)
def test_When_setting_has_a_unicode_value_Then_saving_and_loading_should_still_work(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
s = MythSettings(self.platform, self.translator)
unicodeStr = u"Königreich der Himmel"
s.put("recordings_selected_group", unicodeStr)
s.save()
s2 = MythSettings(self.platform, self.translator)
actualStr = s2.get("recordings_selected_group")
self.assertTrue(unicodeStr == actualStr)
self.assertTrue(isinstance(unicodeStr, unicode))
def test_When_existing_setting_changed_to_different_value_Then_event_published_to_bus(self):
# Setup
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
s = MythSettings(self.platform, self.translator, bus=self.bus)
# Test
s.get("mysql_host")
s.put("mysql_host", "foo")
# Verify
verify(self.bus, 1).publish(any(dict))
def test_When_setting_has_a_unicode_value_Then_saving_and_loading_should_still_work(
self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
s = MythSettings(self.platform, self.translator)
unicodeStr = u'Königreich der Himmel'
s.put('recordings_selected_group', unicodeStr)
s.save()
s2 = MythSettings(self.platform, self.translator)
actualStr = s2.get('recordings_selected_group')
self.assertTrue(unicodeStr == actualStr)
self.assertTrue(isinstance(unicodeStr, unicode))
def test_When_existing_setting_changed_to_different_value_Then_event_published_to_bus(
self):
# Setup
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
s = MythSettings(self.platform, self.translator, bus=self.bus)
# Test
s.get('mysql_host')
s.put('mysql_host', 'foo')
# Verify
verify(self.bus, 1).publish(any(dict))
def setUp(self):
translator = mockito.Mock()
platform = mockito.Mock()
bus = mockito.Mock()
settings = MythSettings(platform, translator)
privateConfig = OnDemandConfig()
settings.put('mysql_host', privateConfig.get('mysql_host'))
settings.put('mysql_password', privateConfig.get('mysql_password'))
settings.put('mysql_database', privateConfig.get('mysql_database'))
self.db = MythDatabase(settings, translator)
self.conn = Connection(settings, translator, platform, bus, self.db)
self.brain = FileLiveTvBrain(self.conn, self.db)
def setUp(self):
translator = mockito.Mock()
platform = mockito.Mock()
bus = mockito.Mock()
settings = MythSettings(platform, translator)
privateConfig = OnDemandConfig()
settings.put('mysql_host', privateConfig.get('mysql_host'))
settings.put('mysql_password', privateConfig.get('mysql_password'))
settings.put('mysql_database', privateConfig.get('mysql_database'))
self.db = MythDatabase(settings, translator)
self.conn = Connection(settings, translator, platform, bus, self.db)
self.brain = FileLiveTvBrain(self.conn, self.db)
class MythDatabaseTest(unittest.TestCase):
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 tearDown(self):
# self.db.close()
self.conn.close()
def test_saveSchedule_NewSchedule(self):
now = datetime.datetime.now()
programs = self.db.getTVGuideDataFlattened(now, now, self.db.getChannels())
if len(programs) == 0:
log.warn("Cannot run unit tests without program listings in the database")
return
schedule = RecordingSchedule.fromProgram(programs[0], self.translator)
log.debug("Test schedule = %s" % schedule)
result = self.db.saveSchedule(schedule)
log.debug("Save schedule result = %s" % result)
def test_addJob_UserJob1(self):
recordings = self.conn.getAllRecordings()
if not recordings:
log.warn("Cannot run unit tests without program listings in the database")
return
job = Job.fromProgram(recordings[-1], JobType.USERJOB & JobType.USERJOB1)
log.debug(job)
self.assertIsNone(job.id)
self.db.addJob(job)
log.debug(job)
self.assertIsNotNone(job.id)
def test_verifyMythTVConnectivity_OK(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
privateConfig = OnDemandConfig()
settings.put('mysql_host', privateConfig.get('mysql_host'))
settings.put('mysql_database', privateConfig.get('mysql_database'))
settings.put('mysql_user', privateConfig.get('mysql_user'))
settings.put('mysql_password', privateConfig.get('mysql_password'))
settings.verifyMythTVConnectivity()
def test_verifyMythTVConnectivity_OK(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
privateConfig = OnDemandConfig()
settings.put("mysql_host", privateConfig.get("mysql_host"))
settings.put("mysql_database", privateConfig.get("mysql_database"))
settings.put("mysql_user", privateConfig.get("mysql_user"))
settings.put("mysql_password", privateConfig.get("mysql_password"))
settings.verifyMythTVConnectivity()
def test_verifyMySQLConnectivity_InvalidUsernamePasswordThrowsSettingsException(self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
privateConfig = OnDemandConfig()
settings.put("mysql_host", privateConfig.get("mysql_host"))
settings.put("mysql_database", privateConfig.get("mysql_database"))
settings.put("mysql_user", "bogususer")
settings.put("mysql_password", "boguspassword")
try:
settings.verifyMySQLConnectivity()
self.fail("expected failure on invalid username and password")
except SettingsException, se:
log.debug("PASS: %s" % se)
class EventConnectionTest(unittest.TestCase):
def setUp(self):
self.platform = getPlatform()
self.translator = 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_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 = EventConnection(self.settings, self.translator,
self.platform, self.bus, self.db)
def tearDown(self):
self.conn.close()
def test_read_a_system_event(self):
x = 1
if 'MYTH_SNIFFER' in os.environ:
x = 9999999
for i in xrange(x):
msg = self.conn.readEvent()
print(msg)
log.debug(msg)
def setUp(self):
p = Platform()
langInfo = util_mock.XBMCLangInfo(p)
translator = util_mock.Translator(p, langInfo)
settings = MythSettings(p, translator)
domainCache = Mock()
privateConfig = OnDemandConfig()
settings.put('mysql_host', privateConfig.get('mysql_host'))
settings.put('mysql_database', privateConfig.get('mysql_database'))
settings.put('mysql_user', privateConfig.get('mysql_user'))
settings.put('mysql_password', privateConfig.get('mysql_password'))
self.dbPool = pool.pools['dbPool'] = pool.Pool(MythDatabaseFactory(settings=settings, translator=translator, domainCache=domainCache))
class EventConnectionTest(unittest.TestCase):
def setUp(self):
self.platform = getPlatform()
self.translator = 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_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 = EventConnection(self.settings, self.translator, self.platform, self.bus, self.db)
def tearDown(self):
self.conn.close()
def test_read_a_system_event(self):
x = 1
if 'MYTH_SNIFFER' in os.environ:
x = 9999999
for i in xrange(x):
msg = self.conn.readEvent()
print(msg)
log.debug(msg)
def test_verifyMySQLConnectivity_InvalidUsernamePasswordThrowsSettingsException(
self):
when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
settings = MythSettings(self.platform, self.translator)
privateConfig = OnDemandConfig()
settings.put('mysql_host', privateConfig.get('mysql_host'))
settings.put('mysql_database', privateConfig.get('mysql_database'))
settings.put('mysql_user', 'bogususer')
settings.put('mysql_password', 'boguspassword')
try:
settings.verifyMySQLConnectivity()
self.fail('expected failure on invalid username and password')
except SettingsException, se:
log.debug('PASS: %s' % se)
class MythEventPublisherTest(unittest.TestCase):
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 tearDown(self):
pools['connPool'].shutdown()
pools['dbPool'].shutdown()
def test_event_publisher(self):
publisher = MythEventPublisher(settings=self.settings, translator=self.translator, platform=self.platform, bus=self.bus)
publisher.startup()
time.sleep(5)
publisher.shutdown()
class MythDatabaseTest(unittest.TestCase):
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 tearDown(self):
#self.db.close()
self.conn.close()
def test_saveSchedule_NewSchedule(self):
now = datetime.datetime.now()
programs = self.db.getTVGuideDataFlattened(now, now,
self.db.getChannels())
if len(programs) == 0:
log.warn(
'Cannot run unit tests without program listings in the database'
)
return
schedule = RecordingSchedule.fromProgram(programs[0], self.translator)
log.debug('Test schedule = %s' % schedule)
result = self.db.saveSchedule(schedule)
log.debug('Save schedule result = %s' % result)
def test_addJob_UserJob1(self):
recordings = self.conn.getAllRecordings()
if not recordings:
log.warn(
'Cannot run unit tests without program listings in the database'
)
return
job = Job.fromProgram(recordings[-1],
JobType.USERJOB & JobType.USERJOB1)
log.debug(job)
self.assertIsNone(job.id)
self.db.addJob(job)
log.debug(job)
self.assertIsNotNone(job.id)
class MythEventPublisherTest(unittest.TestCase):
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 tearDown(self):
pools['connPool'].shutdown()
pools['dbPool'].shutdown()
def test_event_publisher(self):
publisher = MythEventPublisher(settings=self.settings,
translator=self.translator,
platform=self.platform,
bus=self.bus)
publisher.startup()
time.sleep(5)
publisher.shutdown()
class MythDatabaseTest(unittest.TestCase):
def setUp(self):
self.platform = Platform()
self.langInfo = util_mock.XBMCLangInfo(self.platform)
self.translator = util_mock.Translator(self.platform, self.langInfo)
self.settings = MythSettings(self.platform, self.translator)
self.protocol = protocol.Protocol56()
privateConfig = OnDemandConfig()
self.settings.put('mysql_host', privateConfig.get('mysql_host'))
self.settings.put('mysql_port', privateConfig.get('mysql_port'))
self.settings.put('mysql_database',
privateConfig.get('mysql_database'))
self.settings.put('mysql_user', privateConfig.get('mysql_user'))
self.settings.put('mysql_password',
privateConfig.get('mysql_password'))
self.domainCache = Mock()
self.db = MythDatabase(self.settings, self.translator,
self.domainCache)
def tearDown(self):
try:
self.db.close()
except:
pass
def test_constructor(self):
self.assertTrue(self.db)
def test_toBackend(self):
master = self.db.getMasterBackend()
self.assertEqual(master, self.db.toBackend(master.hostname))
self.assertEqual(master, self.db.toBackend(master.ipAddress))
self.assertTrue(master, self.db.toBackend('bogus'))
self.assertEqual(master, self.db.toBackend(master.hostname.upper()))
self.assertEqual(master, self.db.toBackend(master.hostname.lower()))
def test_getBackends(self):
bes = self.db.getBackends()
self.assertTrue(len(bes) >= 1)
def test_getMasterBackend(self):
mbe = self.db.getMasterBackend()
log.debug(mbe)
self.assertTrue(mbe.hostname)
self.assertTrue(mbe.ipAddress)
self.assertTrue(mbe.port)
self.assertTrue(mbe.master)
self.assertFalse(mbe.slave)
def test_getSlaveBackends(self):
slaves = self.db.getSlaveBackends()
for slave in slaves:
log.debug(slave)
self.assertFalse(slave.master)
self.assertTrue(slave.slave)
def test_getChannels(self):
channels = self.db.getChannels()
for i, channel in enumerate(channels):
log.debug("%d - %s" % (i + 1, channel))
self.assertTrue(
'Expected int but was %s' % type(channel.getChannelId()),
isinstance(channel.getChannelId(), int))
self.assertTrue(
'Expected str but was %s' % type(channel.getChannelNumber()),
isinstance(channel.getChannelNumber(), str))
self.assertTrue(
'Expected str but was %s' % type(channel.getCallSign()),
isinstance(channel.getCallSign(), str))
self.assertTrue(
'Expected str but was %s' % type(channel.getChannelName()),
isinstance(channel.getChannelName(), str))
self.assertTrue(
'Expected str but was %s' % type(channel.getIconPath()),
isinstance(channel.getIconPath(), str))
self.assertTrue(
'Expected int but was %s' % type(channel.getTunerId()),
isinstance(channel.getTunerId(), int))
def test_getRecordingProfileNames(self):
self.assertTrue(self.db.getRecordingProfileNames())
def test_getRecordingGroups(self):
groups = self.db.getRecordingGroups()
self.assertTrue('Default' in groups)
def test_getRecordingTitles_InAllGroups(self):
titles = self.db.getRecordingTitles('All Groups')
self.assertTrue(len(titles) > 0)
total = titles[0][1]
for i, title in enumerate(titles):
titleName = title[0]
titleCount = title[1]
log.debug('%d - %s x %s' % (i + 1, titleCount, titleName))
def test_getRecordingTitles_ForNonExistantRecordingGroupReturnsAllShowsWithCountOfZero(
self):
titles = self.db.getRecordingTitles('bogus group')
self.assertEquals(1, len(titles))
self.assertEquals('All Shows', titles[0][0])
self.assertEquals(0, titles[0][1])
def test_getRecordingTitles_ForDeletedRecordingsGroup(self):
deleted = self.db.getRecordingTitles('Deleted')
for i, title in enumerate(deleted):
titleName = title[0]
titleCount = title[1]
log.debug('%d - Deleted recording %s recorded %s times' %
(i + 1, titleName, titleCount))
self.assertTrue(len(deleted) > 0)
def test_getTuners(self):
tuners = self.db.getTuners()
self.assertTrue(len(tuners) > 0, 'No tuners found')
for i, tuner in enumerate(tuners):
log.debug('%d - %s' % (i + 1, tuner))
self.assertIsNotNone(tuner.tunerId)
self.assertIsNotNone(tuner.hostname)
self.assertIsNotNone(tuner.signalTimeout)
self.assertIsNotNone(tuner.channelTimeout)
self.assertIsNotNone(tuner.domainCache)
def test_getMythSetting_KeyOnly_Found(self):
s = self.db.getMythSetting('mythfilldatabaseLastRunStatus')
log.debug('mythfillstatus = %s' % s)
self.assertFalse(s is None)
def test_getMythSetting_KeyOnly_NotFound(self):
s = self.db.getMythSetting('blahblah')
self.assertTrue(s is None)
def test_getMythSetting_KeyWithHostname_Found(self):
# TODO
pass
def test_getMythSetting_KeyWithHostname_NotFound(self):
s = self.db.getMythSetting('blahblah', 'foobar')
self.assertTrue(s is None)
def test_getRecordingSchedules_All(self):
schedules = self.db.getRecordingSchedules()
for i, s in enumerate(schedules):
log.debug('%d - %s' % (i + 1, s))
self.assertTrue(schedules)
def test_getRecordingSchedules_By_Channel(self):
# TODO
pass
def test_getRecordingSchedules_By_ScheduleId(self):
# Setup
schedules = self.db.getRecordingSchedules()
if len(schedules) == 0:
self.fail('Need schedules to run test')
expectedSchedule = schedules.pop()
# Test
actualSchedules = self.db.getRecordingSchedules(
scheduleId=expectedSchedule.getScheduleId())
# Verify
self.assertEquals(1, len(actualSchedules))
self.assertEquals(expectedSchedule.getScheduleId(),
actualSchedules.pop().getScheduleId())
def test_getJobs_All(self):
when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs())
jobs = self.db.getJobs()
self.assertTrue(jobs is not None)
for index, job in enumerate(jobs):
log.debug('job %d = %s' % (index, job))
def test_getJobs_ForProgram(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)
# 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)
def test_getJobs_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[0]
# Test
jobs = self.db.getJobs(jobType=job.jobType)
# Verify
self.assertTrue(len(jobs) > 0)
for index, j2 in enumerate(jobs):
log.debug('job %d = %s' % (index, j2))
self.assertEquals(job.jobType, j2.jobType)
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_getUserJobs(self):
userJobs = self.db.getUserJobs()
for j in userJobs:
log.debug(j)
self.assertEqual(4, len(userJobs))
def test_getTVGuideDataFlattened(self):
# TODO: Convert to mocks w/ assertions
channels = self.db.getChannels()[:2]
programs = self.db.getTVGuideDataFlattened(
datetime.datetime.now(),
datetime.datetime.now() + datetime.timedelta(hours=4), channels)
for p in programs:
log.debug(p)
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()
class DeleteOrphansTest(unittest.TestCase):
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 tearDown(self):
self.conn.close()
def test_getAllRecordings(self):
recordings = self.conn.getAllRecordings()
log.debug('Num Recordings = %s' % len(recordings))
for i,r in enumerate(recordings):
print i,r.getBareFilename()
dirs = ['/usr2/mythtv','/usr2/mythtv2', '/usr2/mythtv3']
mpgs = []
for d in dirs:
files = os.listdir(d)
for f in files:
if f.endswith('.mpg'):
mpgs.append(f)
print f
print 'Recs total = ', len(recordings)
print 'Files total = ', len(mpgs)
print 'Extras = ', len(mpgs) - len(recordings)
todelete = mpgs[:]
for r in recordings:
if r.getBareFilename() in mpgs:
todelete.remove(r.getBareFilename())
print 'Todelete = ', len(todelete)
bucket = []
import datetime
for f in todelete:
for d in dirs:
path = os.path.join(d,f)
if os.path.exists(path):
bucket.append(path)
print path, os.path.getsize(path)
print 'Bucket = ', len(bucket)
sorted(bucket)
total = 0
for f in bucket:
s = os.path.getsize(f)
total += s
print total/1000000000
import shutil
for src in bucket[:25]:
dest = '/usr2/mythtv/backup/' + os.path.basename(src)
print src,' -> ', dest
class ConnectionTest(unittest.TestCase):
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 tearDown(self):
self.conn.close()
def test_getServerVersion(self):
sock = self.conn.connect(announce=None)
try:
version = self.conn.getServerVersion()
log.debug('Server Protcol = %s' % version)
self.assertTrue(version > 0)
finally:
sock.close()
def test_negotiateProtocol_RaisesProtocolException_When_ClientVersion_NotSupported_By_Server(
self):
sock = self.conn.connect(announce=None)
try:
try:
self.conn.negotiateProtocol(sock,
clientVersion=8,
versionToken='')
self.fail('Should have thrown ProtocolException')
except ProtocolException, pe:
log.debug('PASS: %s', pe)
finally:
sock.close()
def test_getSetting(self):
reply = self.conn.getSetting('mythfillstatus', 'none')
log.debug('reply = %s' % reply)
if reply[0] == "-1":
pass # fail
else:
pass # success
# TODO : Left off here!
def test_getTunerStatus_Success(self):
tuners = self.db.getTuners()
if len(tuners) == 0:
log.warn('SKIPPING: need tuners to run test')
return
status = self.conn.getTunerStatus(tuners.pop())
log.debug('Tuner status = %s' % status)
self.assertFalse(status is None)
def test_getDiskUsage(self):
du = self.conn.getDiskUsage()
log.debug('Disk usage = %s' % du)
self.assertTrue(du['hostname'] is not None)
self.assertTrue(du['dir'] is not None)
self.assertTrue(du['total'] is not None)
self.assertTrue(du['used'] is not None)
self.assertTrue(du['free'] is not None)
def test_getLoad(self):
load = self.conn.getLoad()
log.debug('CPU Load = %s' % load)
self.assertEquals(3, len(load))
self.assertTrue(load['1'])
self.assertTrue(load['5'])
self.assertTrue(load['15'])
def test_getUptime(self):
uptime = self.conn.getUptime()
log.debug('Uptime = %s' % uptime)
self.assertFalse(uptime is None)
def test_getGuideDataStatus(self):
guideStatus = self.conn.getGuideDataStatus()
log.debug('Guide data status = %s' % guideStatus)
self.assertFalse(guideStatus is None)
def test_getAllRecordings(self):
recordings = self.conn.getAllRecordings()
log.debug('Num Recordings = %s' % len(recordings))
self.assertTrue(len(recordings) > 0)
def test_getRecordings_AllRecordingGroupsAndTitles(self):
recordings = self.conn.getRecordings()
log.debug('Num Recordings = %s' % len(recordings))
for i, r in enumerate(recordings):
log.debug('%d - %s' % (i + 1, r))
self.assertTrue(len(recordings) > 0)
def test_getRecording_Found(self):
expected = self.getRecordings().pop()
actual = self.conn.getRecording(expected.getChannelId(),
expected.recstarttime())
self.assertEquals(expected, actual)
def test_getRecording_NotFound(self):
recording = self.getRecordings().pop()
actual = self.conn.getRecording(32, recording.recstarttime())
self.assertTrue(actual is None)
def test_getUpcomingRecordings_When_no_args_Then_returns_only_programs_that_will_be_recorded(
self):
upcoming = self.conn.getUpcomingRecordings()
log.debug('Num upcoming recordings = %d' % (len(upcoming)))
for i, program in enumerate(upcoming):
log.debug('%d: tuner=%s %s' % (i, program.getTunerId(), program))
#program.dumpData()
for program in upcoming:
self.assertTrue(program.getRecordingStatus() in Upcoming.SCHEDULED)
self.assertTrue(program.getTunerId() >= 0)
def test_getUpcomingRecordings_When_filter_is_scheduled_Then_returns_only_program_that_will_be_recorded(
self):
upcoming = self.conn.getUpcomingRecordings(Upcoming.SCHEDULED)
log.debug(
'Num upcoming recordings (filter = Upcoming.SCHEDULED) = %d' %
(len(upcoming)))
for program in upcoming:
self.assertTrue(program.getRecordingStatus() in Upcoming.SCHEDULED)
def test_getUpcomingRecordings_When_filter_is_conflict_Then_returns_only_program_that_will_not_be_recorded_because_of_a_conflict(
self):
upcoming = self.conn.getUpcomingRecordings(Upcoming.CONFLICTS)
log.debug(
'Num upcoming recordings (filter = Upcoming.CONFLICTS) = %d' %
(len(upcoming)))
for program in upcoming:
self.assertTrue(program.getRecordingStatus() in Upcoming.CONFLICTS)
def test_getScheduledRecordings(self):
scheduled = self.conn.getScheduledRecordings()
log.debug('Num scheduled recordings = %d' % (len(scheduled)))
for i, program in enumerate(scheduled):
log.debug('%d: %s' % (i, program))
self.assertFalse(scheduled is None)
def test_getTunerShowing_NoCardsAreWatchingOrRecordingThePassedInShow(
self):
tunerId = self.conn.getTunerShowing('bogusshow')
self.assertEquals(
-1, tunerId,
'Expected no encoder to be watching or recording a bogus tv show')
def test_getTunerShowing_ReturnCardThatShowIsBeingWatchedOn(self):
log.warn("TODO: Write unit test - mockito")
def test_getTunerShowing_ReturnCardThatShowIsBeingWatchedAndRecordedOn(
self):
log.warn("TODO: Write unit test - mockito")
def test_getFreeTuner(self):
tunerId, hostname, port = self.conn.getFreeTuner()
if tunerId == -1:
log.debug('No free tuners available')
self.assertEquals('', hostname)
self.assertEquals(-1, port)
else:
log.debug('Free tuner = id: %d hostname: %s port: %d' %
(tunerId, hostname, port))
self.assertTrue(tunerId >= 0)
self.assertTrue(len(hostname) > 0)
self.assertTrue(port > 0)
def test_getNextFreeTuner(self):
tunerId, hostname, port = self.conn.getNextFreeTuner(-1)
if tunerId is None:
pass
else:
log.debug('Next free tuner = id:%d hostname:%s port:%d' %
(tunerId, hostname, port))
# TODO: valid assertions when tuner free and not available
def test_isOk_OKMessageReturnsTrue(self):
self.assertTrue(self.conn._isOk(['OK']))
def test_isOk_OKMessageWithAdditionPayloadReturnsTrue(self):
self.assertTrue(self.conn._isOk(['OK', 'foo', 'bar', 'baz']))
def test_isOk_NoneMessageReturnsFalse(self):
self.assertFalse(self.conn._isOk(None))
def test_isOk_EmptyMessageReturnsFalse(self):
self.assertFalse(self.conn._isOk([]))
def test_isOk_BadMessageReturnsFalse(self):
self.assertFalse(self.conn._isOk(['Bad']))
def test_isTunerRecording(self):
for t in self.conn.getTuners():
log.debug('isTunerRecording(%d) = %s' %
(t.tunerId, self.conn.isTunerRecording(t)))
def test_getBookmark_Success(self):
# TODO: only check bookmarked recordings
recording = self.getRecordings()[0]
log.debug('Getting bookmark for %s' % recording)
bookmark = self.conn.getBookmark(recording)
log.debug('bookmark = %s seconds' % bookmark)
self.assertTrue(bookmark >= 0)
def test_setBookmark_Success(self):
p = self.getRecordings().pop()
log.debug('Setting bookmark for %s' % p)
self.conn.setBookmark(p, 1000)
self.assertEquals(1000, self.conn.getBookmark(p))
def test_setBookmark_ChannelIdInvalid(self):
p = self.getRecordings().pop()
p.setChannelId(999)
self.assertEquals(999, p.getChannelId())
self.assertRaises(ServerException, self.conn.setBookmark, p, 500)
def test_getCommercialBreaks(self):
recordings = reversed(self.conn.getAllRecordings())
foundRecordingWithCommBreaks = False
for r in recordings:
if r.hasCommercials():
foundRecordingWithCommBreaks = True
log.debug('Recording %s has comm breaks' % r)
breaks = self.conn.getCommercialBreaks(r)
for j, b in enumerate(breaks):
log.debug(' %d - comm break = %s' % (j + 1, b))
return
if not foundRecordingWithCommBreaks:
log.warn(
'Could not find any comm flagged recordings to run unit test against'
)
def test_getNumFreeTuners(self):
cnt = self.conn.getNumFreeTuners()
log.debug('Num free tuners = %d' % cnt)
self.assertTrue(cnt >= 0)
def test_getTuners(self):
tuners = self.conn.getTuners()
for i, t in enumerate(tuners):
log.debug('Tuner %d = %s' % (i, t.tunerType))
self.assertTrue(t.conn != None)
def test_generateThumbnail_ReturnsTrue(self):
recording = self.getRecordings()[-1]
log.debug('Generating thumbnail for program: %s' % recording)
result = self.conn.generateThumbnail(
recording,
self.db.getMasterBackend().ipAddress)
self.assertTrue(result)
def test_generateThumbnail_WithSpecificSize(self):
recording = self.getRecordings()[-1]
log.debug('Generating thumbnail for program: %s' % recording.title())
result = self.conn.generateThumbnail(
recording,
self.db.getMasterBackend().ipAddress, 1280 / 4, 720 / 4)
log.debug(result)
self.assertTrue(result)
def test_getThumbnailCreationTime_ThumbnailExists(self):
recording = self.getRecordings()[0]
log.debug('Getting thumbnail creation time for: %s' %
recording.title())
dt = self.conn.getThumbnailCreationTime(
recording,
self.db.getMasterBackend().ipAddress)
log.debug('datetime = %s' % dt)
def test_getThumbNailCreationTime_ThumbnailDoesNotExist(self):
# TODO
pass
def test_rescheduleNotify_Successful(self):
schedules = self.db.getRecordingSchedules()
self.conn.rescheduleNotify(schedules.pop())
log.debug('reschedule notify OK')
def test_rescheduleNotify_Does_Something_Else_When_ScheduleId_missing(
self):
"""
@todo: fixme
"""
pass
def test_transferFile_FileExistsOnBackend_Success(self):
# Setup
recording = self.getRecordings()[-1]
if not self.conn.getThumbnailCreationTime(
recording,
recording.hostname()): # generate thumbnail if necessary
log.debug('Generating thumbnail...')
self.conn.generateThumbnail(recording, recording.hostname())
recording = self.conn.getRecording(recording.getChannelId(),
recording.recstarttime())
backendPath = recording.getBareFilename()
if self.conn.protocol.genPixMapPreviewFilename(recording) != '<EMPTY>':
backendPath += '.640x360'
backendPath += '.png'
destPath = os.path.join(tempfile.gettempdir(),
recording.getBareFilename() + ".png")
# Test
try:
log.debug('Transferring file %s to %s' % (backendPath, destPath))
result = self.conn.transferFile(backendPath, destPath,
recording.hostname())
# Verify
self.assertTrue(result)
self.assertTrue(os.path.exists(destPath))
self.assertTrue(os.path.isfile(destPath))
finally:
try:
os.remove(destPath)
except:
pass
def test_transferFile_When_file_does_not_exist_on_backend_Then_transfer_aborted(
self):
dest = tempfile.mktemp('bogusfile.mpg')
backendPath = "myth://" + self.db.getMasterBackend(
).ipAddress + ":" + str(
self.db.getMasterBackend().port) + "/bogusfile.mpg"
result = self.conn.transferFile(backendPath, dest,
self.db.getMasterBackend().ipAddress)
self.assertFalse(os.path.exists(dest))
self.assertFalse(result)
def test_transferFile_When_partial_transfer_requested_Then_only_send_part_of_file(
self):
# Setup
recording = self.getRecordings()[-1]
dest = tempfile.mktemp('.mpg', 'test_partial_transfer_')
print dest
try:
# Test
result = self.conn.transferFile(recording.getFilename(), dest,
recording.hostname(), 1024 * 1000)
# Verify
self.assertTrue(result)
self.assertTrue(os.path.exists(dest))
self.assertEquals(1024 * 1000, os.path.getsize(dest))
finally:
try:
os.remove(dest)
except:
pass
def getRecordings(self):
recordings = self.conn.getRecordings()
self.assertTrue(recordings, 'Recordings required to run this test')
return recordings
class ConnectionTest(unittest.TestCase):
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 tearDown(self):
self.conn.close()
def test_getServerVersion(self):
sock = self.conn.connect(announce=None)
try:
version = self.conn.getServerVersion()
log.debug('Server Protcol = %s'%version)
self.assertTrue(version > 0)
finally:
sock.close()
def test_negotiateProtocol_RaisesProtocolException_When_ClientVersion_NotSupported_By_Server(self):
sock = self.conn.connect(announce=None)
try:
try:
self.conn.negotiateProtocol(sock, clientVersion=8, versionToken='')
self.fail('Should have thrown ProtocolException')
except ProtocolException, pe:
log.debug('PASS: %s', pe)
finally:
sock.close()
def test_getSetting(self):
reply = self.conn.getSetting('mythfillstatus', 'none')
log.debug('reply = %s' % reply)
if reply[0] == "-1":
pass # fail
else:
pass # success
# TODO : Left off here!
def test_getTunerStatus_Success(self):
tuners = self.db.getTuners()
if len(tuners) == 0:
log.warn('SKIPPING: need tuners to run test')
return
status = self.conn.getTunerStatus(tuners.pop())
log.debug('Tuner status = %s' % status)
self.assertFalse(status is None)
def test_getDiskUsage(self):
du = self.conn.getDiskUsage()
log.debug('Disk usage = %s' % du)
self.assertTrue(du['hostname'] is not None)
self.assertTrue(du['dir'] is not None)
self.assertTrue(du['total'] is not None)
self.assertTrue(du['used'] is not None)
self.assertTrue(du['free'] is not None)
def test_getLoad(self):
load = self.conn.getLoad()
log.debug('CPU Load = %s' % load)
self.assertEquals(3, len(load))
self.assertTrue(load['1'])
self.assertTrue(load['5'])
self.assertTrue(load['15'])
def test_getUptime(self):
uptime = self.conn.getUptime()
log.debug('Uptime = %s' % uptime)
self.assertFalse(uptime is None)
def test_getGuideDataStatus(self):
guideStatus = self.conn.getGuideDataStatus()
log.debug('Guide data status = %s' % guideStatus)
self.assertFalse(guideStatus is None)
def test_getAllRecordings(self):
recordings = self.conn.getAllRecordings()
log.debug('Num Recordings = %s' % len(recordings))
self.assertTrue(len(recordings) > 0)
def test_getRecordings_AllRecordingGroupsAndTitles(self):
recordings = self.conn.getRecordings()
log.debug('Num Recordings = %s' % len(recordings))
for i, r in enumerate(recordings):
log.debug('%d - %s' %(i+1, r))
self.assertTrue(len(recordings) > 0)
def test_getRecording_Found(self):
expected = self.getRecordings().pop()
actual = self.conn.getRecording(expected.getChannelId(), expected.recstarttime())
self.assertEquals(expected, actual)
def test_getRecording_NotFound(self):
recording = self.getRecordings().pop()
actual = self.conn.getRecording(32, recording.recstarttime())
self.assertTrue(actual is None)
def test_getUpcomingRecordings_When_no_args_Then_returns_only_programs_that_will_be_recorded(self):
upcoming = self.conn.getUpcomingRecordings()
log.debug('Num upcoming recordings = %d' % (len(upcoming)))
for i,program in enumerate(upcoming):
log.debug('%d: tuner=%s %s' % (i, program.getTunerId(), program))
#program.dumpData()
for program in upcoming:
self.assertTrue(program.getRecordingStatus() in Upcoming.SCHEDULED)
self.assertTrue(program.getTunerId() >= 0)
def test_getUpcomingRecordings_When_filter_is_scheduled_Then_returns_only_program_that_will_be_recorded(self):
upcoming = self.conn.getUpcomingRecordings(Upcoming.SCHEDULED)
log.debug('Num upcoming recordings (filter = Upcoming.SCHEDULED) = %d' % (len(upcoming)))
for program in upcoming:
self.assertTrue(program.getRecordingStatus() in Upcoming.SCHEDULED)
def test_getUpcomingRecordings_When_filter_is_conflict_Then_returns_only_program_that_will_not_be_recorded_because_of_a_conflict(self):
upcoming = self.conn.getUpcomingRecordings(Upcoming.CONFLICTS)
log.debug('Num upcoming recordings (filter = Upcoming.CONFLICTS) = %d' % (len(upcoming)))
for program in upcoming:
self.assertTrue(program.getRecordingStatus() in Upcoming.CONFLICTS)
def test_getScheduledRecordings(self):
scheduled = self.conn.getScheduledRecordings()
log.debug('Num scheduled recordings = %d' % (len(scheduled)))
for i,program in enumerate(scheduled):
log.debug('%d: %s' % (i, program))
self.assertFalse(scheduled is None)
def test_getTunerShowing_NoCardsAreWatchingOrRecordingThePassedInShow(self):
tunerId = self.conn.getTunerShowing('bogusshow')
self.assertEquals(-1, tunerId, 'Expected no encoder to be watching or recording a bogus tv show')
def test_getTunerShowing_ReturnCardThatShowIsBeingWatchedOn(self):
log.warn("TODO: Write unit test - mockito")
def test_getTunerShowing_ReturnCardThatShowIsBeingWatchedAndRecordedOn(self):
log.warn("TODO: Write unit test - mockito")
def test_getFreeTuner(self):
tunerId, hostname, port = self.conn.getFreeTuner()
if tunerId == -1:
log.debug('No free tuners available')
self.assertEquals('', hostname)
self.assertEquals(-1, port)
else:
log.debug('Free tuner = id: %d hostname: %s port: %d'%(tunerId, hostname, port))
self.assertTrue(tunerId >= 0)
self.assertTrue(len(hostname) > 0)
self.assertTrue(port > 0)
def test_getNextFreeTuner(self):
tunerId, hostname, port = self.conn.getNextFreeTuner(-1)
if tunerId is None:
pass
else:
log.debug('Next free tuner = id:%d hostname:%s port:%d'%(tunerId, hostname, port))
# TODO: valid assertions when tuner free and not available
def test_isOk_OKMessageReturnsTrue(self):
self.assertTrue(self.conn._isOk(['OK']))
def test_isOk_OKMessageWithAdditionPayloadReturnsTrue(self):
self.assertTrue(self.conn._isOk(['OK','foo', 'bar', 'baz']))
def test_isOk_NoneMessageReturnsFalse(self):
self.assertFalse(self.conn._isOk(None))
def test_isOk_EmptyMessageReturnsFalse(self):
self.assertFalse(self.conn._isOk([]))
def test_isOk_BadMessageReturnsFalse(self):
self.assertFalse(self.conn._isOk(['Bad']))
def test_isTunerRecording(self):
for t in self.conn.getTuners():
log.debug('isTunerRecording(%d) = %s' % (t.tunerId, self.conn.isTunerRecording(t)))
def test_getBookmark_Success(self):
# TODO: only check bookmarked recordings
recording = self.getRecordings()[0]
log.debug('Getting bookmark for %s' % recording)
bookmark = self.conn.getBookmark(recording)
log.debug('bookmark = %s seconds' % bookmark)
self.assertTrue(bookmark >= 0)
def test_setBookmark_Success(self):
p = self.getRecordings().pop()
log.debug('Setting bookmark for %s' % p)
self.conn.setBookmark(p, 1000)
self.assertEquals(1000, self.conn.getBookmark(p))
def test_setBookmark_ChannelIdInvalid(self):
p = self.getRecordings().pop()
p.setChannelId(999)
self.assertEquals(999, p.getChannelId())
self.assertRaises(ServerException, self.conn.setBookmark, p, 500)
def test_getCommercialBreaks(self):
recordings = reversed(self.conn.getAllRecordings())
foundRecordingWithCommBreaks = False
for r in recordings:
if r.hasCommercials():
foundRecordingWithCommBreaks = True
log.debug('Recording %s has comm breaks' % r)
breaks = self.conn.getCommercialBreaks(r)
for j, b in enumerate(breaks):
log.debug(' %d - comm break = %s' % (j+1, b))
return
if not foundRecordingWithCommBreaks:
log.warn('Could not find any comm flagged recordings to run unit test against')
def test_getNumFreeTuners(self):
cnt = self.conn.getNumFreeTuners()
log.debug('Num free tuners = %d' % cnt)
self.assertTrue(cnt >= 0)
def test_getTuners(self):
tuners = self.conn.getTuners()
for i,t in enumerate(tuners):
log.debug('Tuner %d = %s' % (i, t.tunerType))
self.assertTrue(t.conn != None)
def test_generateThumbnail_ReturnsTrue(self):
recording = self.getRecordings()[-1]
log.debug('Generating thumbnail for program: %s' % recording)
result = self.conn.generateThumbnail(recording, self.db.getMasterBackend().ipAddress)
self.assertTrue(result)
def test_generateThumbnail_WithSpecificSize(self):
recording = self.getRecordings()[-1]
log.debug('Generating thumbnail for program: %s' % recording.title())
result = self.conn.generateThumbnail(recording, self.db.getMasterBackend().ipAddress, 1280/4, 720/4)
log.debug(result)
self.assertTrue(result)
def test_getThumbnailCreationTime_ThumbnailExists(self):
recording = self.getRecordings()[0]
log.debug('Getting thumbnail creation time for: %s' % recording.title())
dt = self.conn.getThumbnailCreationTime(recording, self.db.getMasterBackend().ipAddress)
log.debug('datetime = %s' % dt)
def test_getThumbNailCreationTime_ThumbnailDoesNotExist(self):
# TODO
pass
def test_rescheduleNotify_Successful(self):
schedules = self.db.getRecordingSchedules()
self.conn.rescheduleNotify(schedules.pop())
log.debug('reschedule notify OK')
def test_rescheduleNotify_Does_Something_Else_When_ScheduleId_missing(self):
"""
@todo: fixme
"""
pass
def test_transferFile_FileExistsOnBackend_Success(self):
# Setup
recording = self.getRecordings()[-1]
if not self.conn.getThumbnailCreationTime(recording, recording.hostname()): # generate thumbnail if necessary
log.debug('Generating thumbnail...')
self.conn.generateThumbnail(recording, recording.hostname())
recording = self.conn.getRecording(recording.getChannelId(), recording.recstarttime())
backendPath = recording.getBareFilename()
if self.conn.protocol.genPixMapPreviewFilename(recording) != '<EMPTY>':
backendPath += '.640x360'
backendPath += '.png'
destPath = os.path.join(tempfile.gettempdir(), recording.getBareFilename() + ".png")
# Test
try:
log.debug('Transferring file %s to %s' % (backendPath, destPath))
result = self.conn.transferFile(backendPath, destPath, recording.hostname())
# Verify
self.assertTrue(result)
self.assertTrue(os.path.exists(destPath))
self.assertTrue(os.path.isfile(destPath))
finally:
try: os.remove(destPath);
except: pass
def test_transferFile_When_file_does_not_exist_on_backend_Then_transfer_aborted(self):
dest = tempfile.mktemp('bogusfile.mpg')
backendPath = "myth://" + self.db.getMasterBackend().ipAddress + ":" + str(self.db.getMasterBackend().port) + "/bogusfile.mpg"
result = self.conn.transferFile(backendPath, dest, self.db.getMasterBackend().ipAddress)
self.assertFalse(os.path.exists(dest))
self.assertFalse(result)
def test_transferFile_When_partial_transfer_requested_Then_only_send_part_of_file(self):
# Setup
recording = self.getRecordings()[-1]
dest = tempfile.mktemp('.mpg', 'test_partial_transfer_')
print dest
try:
# Test
result = self.conn.transferFile(recording.getFilename(), dest, recording.hostname(), 1024 * 1000)
# Verify
self.assertTrue(result)
self.assertTrue(os.path.exists(dest))
self.assertEquals(1024*1000, os.path.getsize(dest))
finally:
try: os.remove(dest)
except: pass
def getRecordings(self):
recordings = self.conn.getRecordings()
self.assertTrue(recordings, 'Recordings required to run this test')
return recordings
class MythDatabaseTest(unittest.TestCase):
def setUp(self):
self.platform = Platform()
self.langInfo = util_mock.XBMCLangInfo(self.platform)
self.translator = util_mock.Translator(self.platform, self.langInfo)
self.settings = MythSettings(self.platform, self.translator)
self.protocol = protocol.Protocol56()
privateConfig = OnDemandConfig()
self.settings.put('mysql_host', privateConfig.get('mysql_host'))
self.settings.put('mysql_port', privateConfig.get('mysql_port'))
self.settings.put('mysql_database', privateConfig.get('mysql_database'))
self.settings.put('mysql_user', privateConfig.get('mysql_user'))
self.settings.put('mysql_password', privateConfig.get('mysql_password'))
self.domainCache = Mock()
self.db = MythDatabase(self.settings, self.translator, self.domainCache)
def tearDown(self):
try:
self.db.close()
except:
pass
def test_constructor(self):
self.assertTrue(self.db)
def test_toBackend(self):
master = self.db.getMasterBackend()
self.assertEqual(master, self.db.toBackend(master.hostname))
self.assertEqual(master, self.db.toBackend(master.ipAddress))
self.assertTrue(master, self.db.toBackend('bogus'))
self.assertEqual(master, self.db.toBackend(master.hostname.upper()))
self.assertEqual(master, self.db.toBackend(master.hostname.lower()))
def test_getBackends(self):
bes = self.db.getBackends()
self.assertTrue(len(bes) >= 1)
def test_getMasterBackend(self):
mbe = self.db.getMasterBackend()
log.debug(mbe)
self.assertTrue(mbe.hostname)
self.assertTrue(mbe.ipAddress)
self.assertTrue(mbe.port)
self.assertTrue(mbe.master)
self.assertFalse(mbe.slave)
def test_getSlaveBackends(self):
slaves = self.db.getSlaveBackends()
for slave in slaves:
log.debug(slave)
self.assertFalse(slave.master)
self.assertTrue(slave.slave)
def test_getChannels(self):
channels = self.db.getChannels()
for i, channel in enumerate(channels):
log.debug("%d - %s"%(i+1, channel))
self.assertTrue('Expected int but was %s' % type(channel.getChannelId()), isinstance(channel.getChannelId(), int))
self.assertTrue('Expected str but was %s' % type(channel.getChannelNumber()), isinstance(channel.getChannelNumber(), str))
self.assertTrue('Expected str but was %s' % type(channel.getCallSign()), isinstance(channel.getCallSign(), str))
self.assertTrue('Expected str but was %s' % type(channel.getChannelName()), isinstance(channel.getChannelName(), str))
self.assertTrue('Expected str but was %s' % type(channel.getIconPath()), isinstance(channel.getIconPath(), str))
self.assertTrue('Expected int but was %s' % type(channel.getTunerId()), isinstance(channel.getTunerId(), int))
def test_getRecordingProfileNames(self):
self.assertTrue(self.db.getRecordingProfileNames())
def test_getRecordingGroups(self):
groups = self.db.getRecordingGroups()
self.assertTrue('Default' in groups)
def test_getRecordingTitles_InAllGroups(self):
titles = self.db.getRecordingTitles('All Groups')
self.assertTrue(len(titles) > 0)
total = titles[0][1]
for i, title in enumerate(titles):
titleName = title[0]
titleCount = title[1]
log.debug('%d - %s x %s' %(i+1, titleCount, titleName))
def test_getRecordingTitles_ForNonExistantRecordingGroupReturnsAllShowsWithCountOfZero(self):
titles = self.db.getRecordingTitles('bogus group')
self.assertEquals(1, len(titles))
self.assertEquals('All Shows', titles[0][0])
self.assertEquals(0, titles[0][1])
def test_getRecordingTitles_ForDeletedRecordingsGroup(self):
deleted = self.db.getRecordingTitles('Deleted')
for i, title in enumerate(deleted):
titleName = title[0]
titleCount = title[1]
log.debug('%d - Deleted recording %s recorded %s times' % (i+1, titleName, titleCount))
self.assertTrue(len(deleted) > 0)
def test_getTuners(self):
tuners = self.db.getTuners()
self.assertTrue(len(tuners) > 0, 'No tuners found')
for i, tuner in enumerate(tuners):
log.debug('%d - %s' %(i+1, tuner))
self.assertIsNotNone(tuner.tunerId)
self.assertIsNotNone(tuner.hostname)
self.assertIsNotNone(tuner.signalTimeout)
self.assertIsNotNone(tuner.channelTimeout)
self.assertIsNotNone(tuner.domainCache)
def test_getMythSetting_KeyOnly_Found(self):
s = self.db.getMythSetting('mythfilldatabaseLastRunStatus')
log.debug('mythfillstatus = %s' % s)
self.assertFalse(s is None)
def test_getMythSetting_KeyOnly_NotFound(self):
s = self.db.getMythSetting('blahblah')
self.assertTrue(s is None)
def test_getMythSetting_KeyWithHostname_Found(self):
# TODO
pass
def test_getMythSetting_KeyWithHostname_NotFound(self):
s = self.db.getMythSetting('blahblah', 'foobar')
self.assertTrue(s is None)
def test_getRecordingSchedules_All(self):
schedules = self.db.getRecordingSchedules()
for i, s in enumerate(schedules):
log.debug('%d - %s' % (i+1, s))
self.assertTrue(schedules)
def test_getRecordingSchedules_By_Channel(self):
# TODO
pass
def test_getRecordingSchedules_By_ScheduleId(self):
# Setup
schedules = self.db.getRecordingSchedules()
if len(schedules) == 0:
self.fail('Need schedules to run test')
expectedSchedule = schedules.pop()
# Test
actualSchedules = self.db.getRecordingSchedules(scheduleId=expectedSchedule.getScheduleId())
# Verify
self.assertEquals(1, len(actualSchedules))
self.assertEquals(expectedSchedule.getScheduleId(), actualSchedules.pop().getScheduleId())
def test_getJobs_All(self):
when(self.domainCache).getUserJobs().thenReturn(self.db.getUserJobs())
jobs = self.db.getJobs()
self.assertTrue(jobs is not None)
for index, job in enumerate(jobs):
log.debug('job %d = %s' % (index, job))
def test_getJobs_ForProgram(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)
# 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)
def test_getJobs_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[0]
# Test
jobs = self.db.getJobs(jobType=job.jobType)
# Verify
self.assertTrue(len(jobs) > 0)
for index, j2 in enumerate(jobs):
log.debug('job %d = %s' % (index, j2))
self.assertEquals(job.jobType, j2.jobType)
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_getUserJobs(self):
userJobs = self.db.getUserJobs()
for j in userJobs:
log.debug(j)
self.assertEqual(4, len(userJobs))
def test_getTVGuideDataFlattened(self):
# TODO: Convert to mocks w/ assertions
channels = self.db.getChannels()[:2]
programs = self.db.getTVGuideDataFlattened(
datetime.datetime.now(),
datetime.datetime.now() + datetime.timedelta(hours=4),
channels)
for p in programs:
log.debug(p)
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()
class DeleteOrphansTest(unittest.TestCase):
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 tearDown(self):
self.conn.close()
def test_delete_orphaned_recordings(self):
recordings = self.conn.getAllRecordings()
log.debug('Num Recordings = %s' % len(recordings))
for i,r in enumerate(recordings):
print i,r.getBareFilename()
dirs = ['/usr2/mythtv']
mpgs = []
for d in dirs:
files = os.listdir(d)
for f in files:
if f.endswith('.mpg'):
mpgs.append(f)
print f
print 'Recs total = ', len(recordings)
print 'Files total = ', len(mpgs)
print 'Extras = ', len(mpgs) - len(recordings)
todelete = mpgs[:]
for r in recordings:
if r.getBareFilename() in mpgs:
todelete.remove(r.getBareFilename())
print 'Todelete = ', len(todelete)
bucket = []
import datetime
for f in todelete:
for d in dirs:
path = os.path.join(d,f)
if os.path.exists(path):
bucket.append(path)
print path, os.path.getsize(path)
print 'Bucket = ', len(bucket)
sorted(bucket)
total = 0
for f in bucket:
s = os.path.getsize(f)
total += s
print total/1000000000
import shutil
for src in bucket:
dest = '/usr2/mythtv/backup/' + os.path.basename(src)
print src,' -> ', dest
#shutil.move(src, dest)
def test_recreate_lost_recordings(self):
recordings = self.conn.getAllRecordings()
log.debug('Num Recordings = %s' % len(recordings))
for i,r in enumerate(recordings):
print i,r.getBareFilename()
dirs = ['/usr2/mythtv']
mpgs = []
for d in dirs:
files = os.listdir(d)
for f in files:
if f.endswith('.mpg'):
mpgs.append(f)
print f
print 'Recs total = ', len(recordings)
print 'Files total = ', len(mpgs)
print 'Missing total = ', len(recordings) - len(mpgs)
rec_names = [r.getBareFilename() for r in recordings]
tocreate = rec_names[:]
for m in mpgs:
if m in rec_names:
tocreate.remove(m)
print 'Tocreate = ', len(tocreate)
bucket = []
import datetime
for f in tocreate:
for d in dirs:
path = os.path.join(d,f)
if not os.path.exists(path):
bucket.append(path)
print path
print 'Bucket = ', len(bucket)
sorted(bucket)
import shutil
src = '/usr/copy/me.mpg'
for dest in bucket:
print src,' -> ', dest
