Commits

jordilin  committed 05adc06

renamed methods in properties module

  • Participants
  • Parent commits df88b0d

Comments (0)

Files changed (22)

File log4client/src/log4tailer/Log.py

         self.wasTarget = False
         self.emphcolor = None
         if properties:
-            self.ownOutputColor = properties.getValue(path.lower())
-            self.ownTarget = properties.getValue(Log.TARGET_PROPERTY_PREFIX + \
+            self.ownOutputColor = properties.get_value(path.lower())
+            self.ownTarget = properties.get_value(Log.TARGET_PROPERTY_PREFIX + \
                                                 path.lower())
             if self.ownTarget:
                 self.logTargetColor = self.targets_colors()

File log4client/src/log4tailer/LogColors.py

         self.backgroundemph = self.color.backgroundemph
 
     def parseConfig(self,properties):
-        for key in properties.getKeys():
-            code = self.color.getCode(properties.getValue(key))
+        for key in properties.get_keys():
+            code = self.color.getCode(properties.get_value(key))
             if not code:
                 continue
             setattr(self, key, code)

File log4client/src/log4tailer/LogTailer.py

             self.mailAction = action
             return True
         if properties:
-            if properties.getValue('inactivitynotification') == 'mail':
+            if properties.get_value('inactivitynotification') == 'mail':
                 # check if there is any inactivity action actually setup
                 inactivityaction = self.__getAction(notifications.Inactivity)
                 if inactivityaction:
         notify_defaults = ('mail', 'print')
         properties = self.properties
         if properties:
-            notification_type = properties.getValue('analyticsnotification')
-            analyticsgap = properties.getValue('analyticsgaptime')
+            notification_type = properties.get_value('analyticsnotification')
+            analyticsgap = properties.get_value('analyticsgaptime')
             if notification_type and notification_type not in notify_defaults:
                 resume.notification_type(notification_type)
             elif notification_type == 'mail':

File log4client/src/log4tailer/Properties.py

 from log4Exceptions import *
 import re
 
-class Property:
+class Property(object):
     '''class to read a user provided key=value config 
     file. Comments supported are # or //'''
 
-    def __init__(self,propertyfile):
+    def __init__(self, propertyfile):
         self.propertyfile = propertyfile
         self.lines = []
         self.keys = []
         self.validsep = ["="]
         self.resep = "|".join(self.validsep)
     
-    def parseProperties(self):
+    def parse_properties(self):
         # is that a huge config file?
         try:
             fd = open(self.propertyfile,'r')
         fd.close()
         self.keys = self.dictproperties.keys()
 
-    def getValue(self,key):
+    def get_value(self, key):
         if key in self.dictproperties:
             return self.dictproperties[key]
         return None
     
-    def getKeys(self):
+    def get_keys(self):
         return self.keys
 
-    def isKey(self,key):
+    def is_key(self,key):
         if key in self.dictproperties:
             return True
         else:

File log4client/src/log4tailer/SSHLogTailer.py

         self.rsa_key = SSH_KEY
 
     def sanityCheck(self):
-        hostnamescsv = self.properties.getValue('sshhostnames')
+        hostnamescsv = self.properties.get_value('sshhostnames')
         if not hostnamescsv:
             self.logger.error("sshhostnames should be provided "
                               "in configfile for ssh tailing")
         hostnames = [hostname.strip() for hostname in hostnamescsv.split(',')]
         for hostname in hostnames:
             self.logger.debug("hostname [%s] found in config file" % hostname)
-            hostnameValues = self.properties.getValue(hostname)
+            hostnameValues = self.properties.get_value(hostname)
             if not hostnameValues:
                 self.logger.debug("values for hostname [%s] are [%s]" % (
-                    hostname,self.properties.getValue(hostname)))
+                    hostname,self.properties.get_value(hostname)))
                 self.logger.error("missing username and logs for [%s]" % (
                                   hostname))
                 return False
                 hostnameDict['logs'].append(log.strip())
             self.logger.debug("logs for hostname [%s] are [%s]" % (hostname, 
                               hostnameDict['logs']))
-        rsa_key = self.properties.getValue('rsa_key')
+        rsa_key = self.properties.get_value('rsa_key')
         if rsa_key:
             print "rsa key provided: "+rsa_key
             self.rsa_key = rsa_key

File log4client/src/log4tailer/__init__.py

 
 def parseConfig(configfile):
     properties = Properties.Property(configfile)
-    properties.parseProperties()
+    properties.parse_properties()
     return properties
 
 def initialize(options):

File log4client/src/log4tailer/modes.py

         for pauseKey in pauseKeys:
             try:
                 level = pauseKey.split('pause')[1]
-                pauseLevel = float(properties.getValue(pauseKey))
+                pauseLevel = float(properties.get_value(pauseKey))
                 self.defaultLevelPauses[level] = pauseLevel
             except:
                 pass

File log4client/src/log4tailer/notifications.py

     Pullers = ['ERROR', 'FATAL', 'CRITICAL']
     
     def __init__(self, properties):
-        self.screenshot = properties.getValue('screenshot')
+        self.screenshot = properties.get_value('screenshot')
         self.winid = self.get_windowsid()
         self.screenproc = ['import', '-window', self.winid, 
                 self.screenshot]
         self.mailAction = None
         notification = None
         if properties:
-            notification = properties.getValue(
+            notification = properties.get_value(
                     Inactivity.InactivityActionNotification)
             self.logColors.parseConfig(properties)
         self.notification = notification or 'print'
     Pullers = ['ERROR', 'FATAL', 'CRITICAL']
 
     def __init__(self, properties):
-        executable = properties.getValue('executor')
+        executable = properties.get_value('executor')
         if not executable:
             raise Exception("need to provide executor option")
         self.executable = executable.split(' ')
             uri, register and unregister uri will need to be provided in a
             configuration file.
         """ 
-        self.url = properties.getValue('server_url')
-        self.port = properties.getValue('server_port')
-        self.service_uri = properties.getValue('server_service_uri')
-        self.register_uri = properties.getValue('server_service_register_uri')
-        self.unregister_uri = properties.getValue('server_service_unregister_uri')
+        self.url = properties.get_value('server_url')
+        self.port = properties.get_value('server_port')
+        self.service_uri = properties.get_value('server_service_uri')
+        self.register_uri = properties.get_value('server_service_register_uri')
+        self.unregister_uri = properties.get_value('server_service_unregister_uri')
         self.headers = {'Content-type' : 'application/json'}
         self.registered_logs = {}
         from socket import gethostname

File log4client/src/log4tailer/utils.py

 from log4tailer import notifications
 
 def setup_mail(properties):
-    username = properties.getValue("mail_username")
-    hostname = properties.getValue("mail_hostname")
-    port = properties.getValue("mail_port") or 25
-    ssl = properties.getValue("mail_ssl")
-    mail_from = properties.getValue("mail_from")
-    mail_to = properties.getValue("mail_to")
+    username = properties.get_value("mail_username")
+    hostname = properties.get_value("mail_hostname")
+    port = properties.get_value("mail_port") or 25
+    ssl = properties.get_value("mail_ssl")
+    mail_from = properties.get_value("mail_from")
+    mail_to = properties.get_value("mail_to")
     password = getpass.getpass()
     mailAction = notifications.Mail(mail_from, mail_to, hostname, username,
             password, port, ssl) 

File log4client/tests/test_colors.py

     def __init__(self):
         pass
 
-    def getKeys(self):
+    def get_keys(self):
         return ['one', 'two']
 
-    def getValue(self, key):
+    def get_value(self, key):
         if key == 'one':
             return 'john'
         else:
 
 class PropertiesBackGround(PropertiesMock):
     """docstring for PropertiesBackGround"""
-    def getKeys(self):
+    def get_keys(self):
         return ['fatal']
 
-    def getValue(self, key):
+    def get_value(self, key):
         return "yellow, on_cyan"
         
 

File log4client/tests/test_cornermark.py

         fh.write("targets "+logfile+"=targeted\n")
         fh.close()
         properties = Property(configfile)
-        properties.parseProperties()
+        properties.parse_properties()
         sys.stdout = Writer()
         logcolors = LogColors()
         termcolors = TermColorCodes()
         fh.write("targets "+logfile+"=targeted\n")
         fh.close()
         properties = Property(configfile)
-        properties.parseProperties()
+        properties.parse_properties()
         sys.stdout = Writer()
         logcolors = LogColors()
         termcolors = TermColorCodes()

File log4client/tests/test_executor.py

         fh.write('executor = ls -l\n')
         fh.close()
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         self.assertEquals(['ls', '-l'], executor.executable)
         executor.stop()
         fh.write('anything = ls -l\n')
         fh.close()
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         self.assertRaises(Exception, notifications.Executor, properties)
 
     def testShouldProvideNotifyMethod(self):
         fh.write('executor = ls -l\n')
         fh.close()
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         self.assertTrue(hasattr(executor, 'notify'))
 
         fh.write('executor = ls -l %s %s\n')
         fh.close()
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         self.assertEqual(True, executor.full_trigger_active)
         executor.stop()
         fh.write('executor = ls -l\n')
         fh.close()
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         self.assertEqual(False, executor.full_trigger_active)
         executor.stop()
         trace = "this is a FATAL log trace"
         trigger = ['ls', '-l', trace, log.path ]
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         os_mock = self.mocker.replace('subprocess')
         os_mock.call(' '.join(trigger), shell = True)
         self.mocker.result(True)
         fh.close()
         trace = "this is a fatal log trace"
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         message.parse(trace, log)
         trigger = executor._build_trigger(trace, logpath)
         fh.close()
         trace = "this is a critical log trace"
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         message.parse(trace, log)
         executor.notify(message, log)
         fh.close()
         trace = "this is an error log trace"
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         message.parse(trace, log)
         start = time.time()
         fh.close()
         trace = "this is an info log trace"
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         executor = notifications.Executor(properties)
         message.parse(trace, log)
         executor.notify(message, log)
         trace = "this is an info log trace"
         trigger = ['echo', trace, logfile]
         properties = Property(CONFIG)
-        properties.parseProperties()
+        properties.parse_properties()
         message = Message(logcolor, target = 'trace')
         executor_mock = self.mocker.mock()
         executor_mock._build_trigger(trace, logfile)

File log4client/tests/test_inactivityAction.py

         fh.write('inactivitynotification = mail\n')
         fh.close()
         property = Property('config.txt')
-        property.parseProperties()
+        property.parse_properties()
         notifier = notifications.Inactivity(1,property)
         self.assertEqual('mail',notifier.getNotificationType())
         os.remove('config.txt')
         fh.write('inactivitynotification = mail\n')
         fh.close()
         property = Property('config.txt')
-        property.parseProperties()
+        property.parse_properties()
         notifier = notifications.Inactivity(1,property)
         if notifier.getNotificationType() == 'mail':
             notifier.setMailNotification(mail)

File log4client/tests/test_log.py

         fh.write(self.logname+'='+'green\n')
         fh.close()
         properties = Property('config')
-        properties.parseProperties()
+        properties.parse_properties()
         log = Log(self.logname,properties)
         log.openLog()
         self.assertTrue(log.ownOutputColor)
         fh.write(targetsline)
         fh.close()
         property = Property('config.txt')
-        property.parseProperties()
+        property.parse_properties()
         self.assertEqual(regexesColors, 
-                         property.getValue('targets /var/log/messages'))
+                         property.get_value('targets /var/log/messages'))
         log = Log('/var/log/messages', property)
         logTargetsColors = {re.compile('log$'): 'yellow, on_cyan',
             re.compile("^2009-10-12 got something here$") : 'black, on_cyan'}
         fh.write("/var/log/messages = green\n")
         fh.close()
         property = Property('config.txt')
-        property.parseProperties()
+        property.parse_properties()
         return property
 
     def testshouldGetTupleOfOptionalParameters(self):
         fh.write(targetsline)
         fh.close()
         property = Property('config.txt')
-        property.parseProperties()
+        property.parse_properties()
         self.assertEqual(regexes, 
-                         property.getValue('targets /var/log/messages'))
+                         property.get_value('targets /var/log/messages'))
         log = Log('/var/log/messages', property)
         color = log.logTargetColor.get(re.compile('log$'))
         self.assertFalse(color)

File log4client/tests/test_logtailer.py

     def testshouldReturnFalseMailNotSetup(self):
         self.__setupAConfig()
         properties = Property('aconfig')
-        properties.parseProperties()
+        properties.parse_properties()
         defaults = getDefaults()
         defaults['properties'] = properties
         logtailer = LogTailer(defaults)
         fh.write('analyticsnotification = ' + reportfile + '\n')
         fh.close()
         properties = Property(configfile)
-        properties.parseProperties()
+        properties.parse_properties()
         defaults = getDefaults()
         defaults['properties'] = properties
         logtailer = LogTailer(defaults)
 
     def test_monitor_inactivity_withmail(self):
         properties_mock = self.mocker.mock()
-        properties_mock.getValue('inactivitynotification')
+        properties_mock.get_value('inactivitynotification')
         self.mocker.result('mail')
-        properties_mock.getKeys()
+        properties_mock.get_keys()
         self.mocker.result([])
         defaults = getDefaults()
         defaults['properties'] = properties_mock

File log4client/tests/test_mailaction.py

         mail_to = 'john@doe.com'
         password = 'anypassword'
         properties_mock = self.mocker.mock()
-        properties_mock.getValue('mail_username')
+        properties_mock.get_value('mail_username')
         self.mocker.result(username)
-        properties_mock.getValue('mail_hostname')
+        properties_mock.get_value('mail_hostname')
         self.mocker.result(hostname)
-        properties_mock.getValue('mail_port')
+        properties_mock.get_value('mail_port')
         self.mocker.result(port)
-        properties_mock.getValue('mail_ssl')
+        properties_mock.get_value('mail_ssl')
         self.mocker.result(ssl)
-        properties_mock.getValue('mail_to')
+        properties_mock.get_value('mail_to')
         self.mocker.result(mail_to)
-        properties_mock.getValue('mail_from')
+        properties_mock.get_value('mail_from')
         self.mocker.result(mail_from)
         getpass_mock = self.mocker.replace('getpass.getpass')
         getpass_mock()

File log4client/tests/test_pauseMode.py

     def testgetOverridePauseModeLevels(self):
         pauseMode = modes.PauseMode()
         properties = Property(self.configfile)
-        properties.parseProperties()
+        properties.parse_properties()
         pauseMode.parseConfig(properties)
         for key,value in self.overridenLevelPauses.iteritems():
             key = key.split('pause')[1]

File log4client/tests/test_postnotifier.py

 
         def test_post_notification(self):
             properties = self.mocker.mock()
-            properties.getValue('server_url')
+            properties.get_value('server_url')
             self.mocker.result('localhost')
-            properties.getValue('server_port')
+            properties.get_value('server_port')
             self.mocker.result(8000)
-            properties.getValue('server_service_uri')
+            properties.get_value('server_service_uri')
             self.mocker.result('/')
-            properties.getValue('server_service_register_uri')
+            properties.get_value('server_service_register_uri')
             self.mocker.result('/register')
-            properties.getValue('server_service_unregister_uri')
+            properties.get_value('server_service_unregister_uri')
             self.mocker.result('/unregister')
             self.mocker.replay()
             poster = notifications.Poster(properties)
 
         def test_has_notify_method(self):
             properties = self.mocker.mock()
-            properties.getValue('server_url')
+            properties.get_value('server_url')
             self.mocker.result('localhost')
-            properties.getValue('server_port')
+            properties.get_value('server_port')
             self.mocker.result(8000)
-            properties.getValue('server_service_uri')
+            properties.get_value('server_service_uri')
             self.mocker.result('/')
-            properties.getValue('server_service_register_uri')
+            properties.get_value('server_service_register_uri')
             self.mocker.result('/register')
-            properties.getValue('server_service_unregister_uri')
+            properties.get_value('server_service_unregister_uri')
             self.mocker.result('/unregister')
             self.mocker.replay()
             poster = notifications.Poster(properties)
 
         def test_shouldPost_if_alertable(self):
             properties = self.mocker.mock()
-            properties.getValue('server_url')
+            properties.get_value('server_url')
             self.mocker.result('localhost')
-            properties.getValue('server_port')
+            properties.get_value('server_port')
             self.mocker.result(8000)
-            properties.getValue('server_service_uri')
+            properties.get_value('server_service_uri')
             self.mocker.result('/')
-            properties.getValue('server_service_register_uri')
+            properties.get_value('server_service_register_uri')
             self.mocker.result('/register')
-            properties.getValue('server_service_unregister_uri')
+            properties.get_value('server_service_unregister_uri')
             self.mocker.result('/unregister')
             logcolors = LogColors()
             logtrace = 'this is an error log trace'
 
         def test_execute_if_targetMessage(self):
             properties = self.mocker.mock()
-            properties.getValue('server_url')
+            properties.get_value('server_url')
             self.mocker.result('localhost')
-            properties.getValue('server_port')
+            properties.get_value('server_port')
             self.mocker.result(8000)
-            properties.getValue('server_service_uri')
+            properties.get_value('server_service_uri')
             self.mocker.result('/')
-            properties.getValue('server_service_register_uri')
+            properties.get_value('server_service_register_uri')
             self.mocker.result('/register')
-            properties.getValue('server_service_unregister_uri')
+            properties.get_value('server_service_unregister_uri')
             self.mocker.result('/unregister')
             logcolors = LogColors()
             logtrace = 'this is a target log trace'
 
         def test_not_execute_if_not_alertable_Level(self):
             properties = self.mocker.mock()
-            properties.getValue('server_url')
+            properties.get_value('server_url')
             self.mocker.result('localhost')
-            properties.getValue('server_port')
+            properties.get_value('server_port')
             self.mocker.result(8000)
-            properties.getValue('server_service_uri')
+            properties.get_value('server_service_uri')
             self.mocker.result('/')
-            properties.getValue('server_service_register_uri')
+            properties.get_value('server_service_register_uri')
             self.mocker.result('/register')
-            properties.getValue('server_service_unregister_uri')
+            properties.get_value('server_service_unregister_uri')
             self.mocker.result('/unregister')
             logcolors = LogColors()
             logtrace = 'this is an info log trace'
 
         def test_register_to_server_first_time(self):
             properties = self.mocker.mock()
-            properties.getValue('server_url')
+            properties.get_value('server_url')
             self.mocker.result('localhost')
-            properties.getValue('server_port')
+            properties.get_value('server_port')
             self.mocker.result(8000)
-            properties.getValue('server_service_uri')
+            properties.get_value('server_service_uri')
             self.mocker.result('/')
-            properties.getValue('server_service_register_uri')
+            properties.get_value('server_service_register_uri')
             self.mocker.result('/register')
-            properties.getValue('server_service_unregister_uri')
+            properties.get_value('server_service_unregister_uri')
             self.mocker.result('/unregister')
             logcolors = LogColors()
             log = Log('anylog')
 
         def test_unregister_method_for_shutdown(self):
             properties = self.mocker.mock()
-            properties.getValue('server_url')
+            properties.get_value('server_url')
             self.mocker.result('localhost')
-            properties.getValue('server_port')
+            properties.get_value('server_port')
             self.mocker.result(8000)
-            properties.getValue('server_service_uri')
+            properties.get_value('server_service_uri')
             self.mocker.result('/')
-            properties.getValue('server_service_register_uri')
+            properties.get_value('server_service_register_uri')
             self.mocker.result('/register')
-            properties.getValue('server_service_unregister_uri')
+            properties.get_value('server_service_unregister_uri')
             self.mocker.result('/unregister')
             logcolors = LogColors()
             log = Log('anylog')

File log4client/tests/test_printshot.py

     def test_instantiatesprintshot(self):
         output = 'picture.png'
         propertiesmock = self.mocker.mock()
-        propertiesmock.getValue('screenshot')
+        propertiesmock.get_value('screenshot')
         self.mocker.result(output)
         self.mocker.replay()
         printshot = notifications.PrintShot(propertiesmock)
         self.mocker.result(procins)
         output = 'picture.png'
         propertiesmock = self.mocker.mock()
-        propertiesmock.getValue('screenshot')
+        propertiesmock.get_value('screenshot')
         self.mocker.result(output)
         self.mocker.replay()
         printshot = notifications.PrintShot(propertiesmock)
         logcolors = LogColors()
         output = 'picture.png'
         propertiesmock = self.mocker.mock()
-        propertiesmock.getValue('screenshot')
+        propertiesmock.get_value('screenshot')
         self.mocker.result(output)
         self.mocker.replay()
         printandshoot = notifications.PrintShot(propertiesmock)

File log4client/tests/test_properties.py

         self.configfh.close()
         self.configKeys = colorconfigs.keys().sort()
 
-    def testparseProperties(self):
+    def testparse_properties(self):
         property = Property(self.configfile)
-        property.parseProperties()
-        configPropertyKeys = property.getKeys().sort()
+        property.parse_properties()
+        configPropertyKeys = property.get_keys().sort()
         # my colorconfigs keys are already in lowercase
         self.assertEqual(self.configKeys,configPropertyKeys)
     
         self.configfh.write(targetline)
         self.configfh.close()
         property = Property('anotherconfig.txt')
-        property.parseProperties()
-        self.assertEqual(value,property.getValue(key))
+        property.parse_properties()
+        self.assertEqual(value,property.get_value(key))
         os.remove('anotherconfig.txt')
 
     def testshouldReturnNoneifKeyNotFound(self):
         property = Property(self.configfile)
-        property.parseProperties()
+        property.parse_properties()
         key = 'hi'
-        self.assertFalse(property.getValue(key))
+        self.assertFalse(property.get_value(key))
     
     def __createDuplicateKeysConfig(self):
         os.remove(self.configfile)
     def testKeyAlreadyExistsException(self):                                    
         self.__createDuplicateKeysConfig()
         property = Property(self.configfile)
-        self.assertRaises(KeyAlreadyExistsException,property.parseProperties)
+        self.assertRaises(KeyAlreadyExistsException,property.parse_properties)
 
     def tearDown(self):
         os.remove(self.configfile)

File log4client/tests/test_resume.py

         fh.write("targets "+logfile+" = should\n")
         fh.close()
         properties = Property(configfile)
-        properties.parseProperties()
+        properties.parse_properties()
         mylog = Log(logfile, properties)
         optional_params = (None, True, logfile)
         self.assertEqual(optional_params, (mylog.ownOutputColor,
         fh.write('analyticsgaptime = 3600\n')
         fh.close()
         properties = Property('aconfig')
-        properties.parseProperties()
-        self.assertTrue(properties.isKey('analyticsnotification'))
+        properties.parse_properties()
+        self.assertTrue(properties.is_key('analyticsnotification'))
         arrayLog = [Log('out.log')]
         resume = reporting.Resume(arrayLog)
         mailactionmocker = mox.Mox()
         mailaction = mailactionmocker.CreateMock(notifications.Mail)
-        if properties.getValue('analyticsnotification') == 'mail':
+        if properties.get_value('analyticsnotification') == 'mail':
             resume.setMailNotification(mailaction)
             self.assertEquals('mail',resume.getNotificationType())
-            gaptime = properties.getValue('analyticsgaptime')
+            gaptime = properties.get_value('analyticsgaptime')
             if gaptime:
                 resume.setAnalyticsGapNotification(gaptime)
                 self.assertEquals(3600,int(resume.getGapNotificationTime()))
         fh.write('analyticsgaptime = 0.1\n')
         fh.close()
         properties = Property('aconfig')
-        properties.parseProperties()
-        self.assertTrue(properties.isKey('analyticsnotification'))
+        properties.parse_properties()
+        self.assertTrue(properties.is_key('analyticsnotification'))
         log = Log('out.log')
         arrayLog = [log]
         resume = reporting.Resume(arrayLog)

File log4client/tests/test_sshTailer.py

     def testShouldHaveUsernameandAtLeastOneHostnameSetUp(self):
         self.__setUpConfigFile()
         properties = Property(self.configfile)        
-        properties.parseProperties()
-        logging.debug(properties.getKeys())
+        properties.parse_properties()
+        logging.debug(properties.get_keys())
         defaults = self.__getDefaults()
         defaults['properties'] = properties
         logtailer = SSHLogTailer(defaults)
         fh.write('anything = anything\n')
         fh.close()
         properties = Property('wrongconfigfile')
-        properties.parseProperties()
+        properties.parse_properties()
         defaults = self.__getDefaults()
         defaults['properties'] = properties
         logtailer = SSHLogTailer(defaults)
     def testItShouldhaveBuildADictWithAllParamsIfAllParametersOk(self):
         self.__setUpConfigFile()
         properties = Property(self.configfile)        
-        properties.parseProperties()
-        logging.debug(properties.getKeys())
+        properties.parse_properties()
+        logging.debug(properties.get_keys())
         defaults = self.__getDefaults()
         defaults['properties'] = properties
         logtailer = SSHLogTailer(defaults)
     def testshouldBuildCommandTailBasedOnHostnamesDict(self):
         self.__setUpConfigFile()
         properties = Property(self.configfile)        
-        properties.parseProperties()
-        logging.debug(properties.getKeys())
+        properties.parse_properties()
+        logging.debug(properties.get_keys())
         defaults = self.__getDefaults()
         defaults['properties'] = properties
         logtailer = SSHLogTailer(defaults)