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 verifyMySQLConnectivity(self):
try:
domainCache = None
db = MythDatabase(self, self.translator, domainCache)
db.close()
del db
except Exception, ex:
raise SettingsException("Connect to MySQL failed: %s" % ex)
def verifyMySQLConnectivity(self):
try:
domainCache = None
db = MythDatabase(self, self.translator, domainCache)
db.close()
del db
except Exception, ex:
raise SettingsException("Connect to MySQL failed: %s" % ex)
def verifyMythTVConnectivity(self):
domainCache = None
db = MythDatabase(self, self.translator, domainCache)
self.master = db.getMasterBackend()
try:
from mythbox.mythtv.conn import Connection
session = Connection(self, translator=self.translator, platform=self.platform, bus=EventBus(), db=db)
session.close()
except Exception, ex:
slog.exception(ex)
raise SettingsException('Connection to MythTV host %s failed: %s' % (db.getMasterBackend().ipAddress, ex))
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 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 verifyMythTVConnectivity(self):
domainCache = None
db = MythDatabase(self, self.translator, domainCache)
self.master = db.getMasterBackend()
try:
from mythbox.mythtv.conn import Connection
session = Connection(self,
translator=self.translator,
platform=self.platform,
bus=EventBus(),
db=db)
session.close()
except Exception, ex:
slog.exception(ex)
raise SettingsException('Connection to MythTV host %s failed: %s' %
(db.getMasterBackend().ipAddress, ex))
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'))
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.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):
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):
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 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 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'))
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.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.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)
class LiveTVBrainTest(unittest.TestCase):
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 tearDown(self):
self.conn.close()
def test_watchLiveTV(self):
# tuners = self.conn.getTuners()
# for t in tuners:
# if t.tunerId == 5 and t.isRecording():
# t.stopLiveTV()
channel = self.db.getChannels()[1]
log.debug('Attempting to watch %s' % channel)
tuner = self.brain.watchLiveTV(channel)
log.debug("Assuming we're watching some tv...")
for x in range(20):
time.sleep(1)
log.debug(self.brain.getLiveTVStatus())
log.debug('Stopping live tv...')
self.brain.onPlayBackStopped()
log.debug('all done')
def xxxtest_stopAllTuners(self):
tuners = self.conn.getTuners()
for t in tuners:
if t.tunerId == 5:
t.stopLiveTV()
class LiveTVBrainTest(unittest.TestCase):
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 tearDown(self):
self.conn.close()
def test_watchLiveTV(self):
# tuners = self.conn.getTuners()
# for t in tuners:
# if t.tunerId == 5 and t.isRecording():
# t.stopLiveTV()
channel = self.db.getChannels()[1]
log.debug('Attempting to watch %s' % channel)
tuner = self.brain.watchLiveTV(channel)
log.debug("Assuming we're watching some tv...")
for x in range(20):
time.sleep(1)
log.debug(self.brain.getLiveTVStatus())
log.debug('Stopping live tv...')
self.brain.onPlayBackStopped()
log.debug('all done')
def xxxtest_stopAllTuners(self):
tuners = self.conn.getTuners()
for t in tuners:
if t.tunerId == 5:
t.stopLiveTV()
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 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 MythChannelIconResolverTest(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.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'))
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_store_When_channel_has_icon_Then_download_icon(self):
# Setup
channels = filter(lambda x: x.getIconPath(), self.db.getChannels()) # filter out channels that don't have an icon
self.assertTrue(len(channels) > 0, 'Channels with icon needed in db to run test')
downloader = MythChannelIconResolver(self.conn)
# Test - download icons for first 5 channels
for channel in channels[:min(5, len(channels))]:
if channel.getIconPath():
dest = os.path.sep.join([tempfile.gettempdir(), 'channel_' + str(channel.getChannelId()) + channel.getCallSign() + str(time.time()) + '.png'])
downloader.store(channel, dest)
# Verify
log.debug('Downloaded %s to %s' % (channel.getIconPath(), dest))
self.assertTrue(os.path.exists(dest))
self.assertTrue(os.path.isfile(dest))
self.assertTrue(os.path.getsize(dest) > 0)
# Cleanup
os.remove(dest)
def test_store_When_channel_has_no_icon_Then_do_nothing(self):
# Setup
channel = Channel({'name':'Bogus Channel', 'icon':None, 'chanid': '9', 'callsign': 'WXYZ'})
conn = Mock()
downloader = MythChannelIconResolver(conn)
# Test
downloader.store(channel, 'bogusDestDir')
# Verify
verifyZeroInteractions(conn)
def test_store_When_channel_has_iconpath_but_filename_misspelled_Then_do_nothing(self):
# Setup
channel = Channel({'name':'Bogus Channel', 'icon': 'bogusIcon.png', 'chanid': '9', 'callsign': 'WXYZ'})
downloader = MythChannelIconResolver(self.conn)
# Test - download icons for first 5 channels
dest = os.path.sep.join([tempfile.gettempdir(), str(channel.getChannelId()) + channel.getCallSign() + str(time.time()) + ".png"])
downloader.store(channel, dest)
# Verify
self.assertFalse(os.path.exists(dest))
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 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 MythChannelIconResolverTest(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.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'))
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_store_When_channel_has_icon_Then_download_icon(self):
# Setup
channels = filter(lambda x: x.getIconPath(), self.db.getChannels()
) # filter out channels that don't have an icon
self.assertTrue(
len(channels) > 0, 'Channels with icon needed in db to run test')
downloader = MythChannelIconResolver(self.conn)
# Test - download icons for first 5 channels
for channel in channels[:min(5, len(channels))]:
if channel.getIconPath():
dest = os.path.sep.join([
tempfile.gettempdir(),
'channel_' + str(channel.getChannelId()) +
channel.getCallSign() + str(time.time()) + '.png'
])
downloader.store(channel, dest)
# Verify
log.debug('Downloaded %s to %s' %
(channel.getIconPath(), dest))
self.assertTrue(os.path.exists(dest))
self.assertTrue(os.path.isfile(dest))
self.assertTrue(os.path.getsize(dest) > 0)
# Cleanup
os.remove(dest)
def test_store_When_channel_has_no_icon_Then_do_nothing(self):
# Setup
channel = Channel({
'name': 'Bogus Channel',
'icon': None,
'chanid': '9',
'callsign': 'WXYZ'
})
conn = Mock()
downloader = MythChannelIconResolver(conn)
# Test
downloader.store(channel, 'bogusDestDir')
# Verify
verifyZeroInteractions(conn)
def test_store_When_channel_has_iconpath_but_filename_misspelled_Then_do_nothing(
self):
# Setup
channel = Channel({
'name': 'Bogus Channel',
'icon': 'bogusIcon.png',
'chanid': '9',
'callsign': 'WXYZ'
})
downloader = MythChannelIconResolver(self.conn)
# Test - download icons for first 5 channels
dest = os.path.sep.join([
tempfile.gettempdir(),
str(channel.getChannelId()) + channel.getCallSign() +
str(time.time()) + ".png"
])
downloader.store(channel, dest)
# Verify
self.assertFalse(os.path.exists(dest))
