Python settings.MythSettings类代码示例

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 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_saveSettings_LoadedDefaultsCreatesNewSettingsFile(self):
     filename = "settings.xml"
     filepath = os.path.join(self.sandbox, filename)
     when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
     self.assertFalse(os.path.exists(filepath))
     s = MythSettings(self.platform, self.translator)
     s.save()
     self.assertTrue(os.path.exists(filepath))

 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_verifyRecordingDirs_OneInvalidOutOfManyOKThrowsSettingsException(self):
     try:
         MythSettings.verifyRecordingDirs(
             tempfile.gettempdir() + os.pathsep + "someBogusDir" + os.pathsep + os.getcwd()
         )
         self.fail("expected failure")
     except SettingsException, se:
         log.debug("PASS: %s" % se)

 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_verifyBoolean_AllValuesThatShouldRaiseException(self):
     badValues = ("true", "false", "", "2", "crap")
     for b in badValues:
         try:
             MythSettings.verifyBoolean(b, "blah")
             self.fail("should have throws SettingsException")
         except SettingsException, se:
             log.debug("PASS: %s %s" % (b, se))

    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)

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):
     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 MythThumbnailResolverTest(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'))
        
        log.debug('%s' % self.settings)
        
        self.db = MythDatabase(self.settings, self.translator, self.domainCache)
        self.bus = EventBus()
        self.conn = Connection(self.settings, self.translator, self.platform, self.bus, self.db)

    def tearDown(self):
        self.conn.close()

    def test_store_download_thumbnail(self):
        # Setup
        recordings = self.conn.getRecordings()
        self.assertTrue(recordings, 'Recordings needed in to run test')
        downloader = MythThumbnailResolver(self.conn, self.db)
        dest = os.path.sep.join([tempfile.gettempdir(), 'thumbnail_' + str(random.randint(1, 999999)) + '.png'])

        # Test
        downloader.store(recordings[-1], dest)
         
        # Verify
        log.debug('Downloaded %s to %s' % (safe_str(recordings[-1].title()), 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_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_constructor_NonExistentSettingsFilesLoadsDefaults(self):
     when(self.platform).getScriptDataDir().thenReturn(self.sandbox)
     s = MythSettings(self.platform, self.translator)
     self.assertEquals("localhost", s.get("mysql_host"))
     self.assertEquals("3306", s.get("mysql_port"))
     self.assertEquals("mythconverg", s.get("mysql_database"))
     self.assertEquals("mythtv", s.get("mysql_user"))
     self.assertEquals("change_me", s.get("mysql_password"))

 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)